The whole course ▾

System Design · Lesson 12 of 39 · Week 3

Sharding: splitting data across machines

Updated 22 Oct 2026 · By Akshay, software engineer, India · 5 min read

QuickBite's orders no longer fit on one machine, and replicas can't help: every copy is just as big. Today: sharding.

Got a doubt? Ask in the comments under the video.Subscribe

QuickBite in this lesson

QuickBite's orders table outgrows one machine.

QuickBite is the food delivery app we grow through the course, from one server to millions of orders.

Too big for one machine

Too big for one machine
App servers
Orders DB
leader + followers
every write
+100 GB a day
one leader for all writes

Yesterday, read replicas spread the reads. But every follower holds a full copy of the data, and the data keeps growing.

QuickBite now runs in forty cities and takes twenty million orders a day. With their items, status changes and indexes, each order takes about five kilobytes. The app servers send all of it to the orders DB: a hundred gigabytes of new data a day, more than thirty terabytes a year.

Here's where it hurts. The disks fill up, a backup takes a whole day, and the busy part of the data no longer fits in memory, so queries slow down. Followers can't fix any of that: each one is a full copy, just as big. And every write, thousands a second at peak, still goes through a single leader. We've hit the ceiling of one machine.

Split it into shards

Split it into shards
IN ONE LINE
Eachshardholdsasliceofthedata;
thepartitionkeydecideswhichslice.
Too big for one machine
App servers
Orders DB
leader + followers
every write
+100 GB a day
one leader for all writes
Shard router
which shard?
Shard
slice 1
Shard
slice 2
Shard
slice 3
customer 7
1
slice 2
2

So stop putting all the data in one place. Split it.

Sharding splits one big table across several databases. Each one is called a shard, and holds only its slice of the orders: a third each, then a tenth, then a hundredth as QuickBite grows. Every shard is an ordinary database with its own leader and followers, exactly like yesterday. And a shard router, often just a small library inside the app, decides which shard holds which data. Each shard can live on its own machine, so adding machines finally adds capacity for writes too.

In one line: each shard holds a slice of the data, and one field, the partition key, decides which slice a row belongs to. Writes now spread across many leaders, and each shard is small enough to back up, copy and keep in memory. So the whole design hangs on one question: which field?

Choosing the partition key

Choosing the partition key
A good partition key
The busiest queries include it
Spreads data and traffic evenly
Keeps related rows together
FOR QUICKBITE'S ORDERS
PartitionbycustomerID:
everycustomer'sorders
liveononeshard.

Choose the partition key the way you chose indexes: from the questions the app asks most.

A good partition key does three things. The busiest queries include it, so each one goes to exactly one shard. It spreads data and traffic evenly, so no shard gets more than its share. And it keeps rows that are read together on the same shard, so one request means one shard.

For QuickBite's orders, that's the customer ID. The history tab, the busiest query, always knows the customer. A customer's orders all sit on one shard, so their history is a single, fast query. And with millions of customers, the slices come out even. Compare a bad choice: order time. Every new order would land on the shard that holds today, one shard melting while the rest hold old history. Remember the good choice, because the next question is how a customer ID turns into a shard.

Range or hash

Range or hash
Range: by value
IDs 1 to 1 million -> shard 1
New customers all hit the last shard
One shard runs hot
Hash: by the key's hash
hash(customer ID) picks the shard
Customers spread evenly
New customers spread out too
THE TRADE-OFF
Hashspreadsloadevenly
butscattersranges;
rangekeepsorderbut
makeshotshards.

There are two ways to map a key to a shard, and they fail in opposite ways.

Range partitioning gives each shard a range of values: customers one to a million on shard one, the next million on shard two. It's simple, and range queries are fast. But new customers get the highest IDs, so every signup, and most new orders, land on the last shard while the others sit idle. Hash partitioning runs the key through a hash function, which scrambles it, and the result picks the shard. Neighbours end up far apart, so the load spreads evenly, new customers included.

The trade-off: hash spreads the load evenly, but a range query, like every order from the last hour, now has to ask every shard. Range keeps things in order, but piles new data onto one shard. QuickBite reads orders by customer, not by range, so it hashes the customer ID.

What gets harder

What gets harder
The new problems
Queries without the key: ask every shard
Hot shards: one key far too busy
Joins and transactions across shards
Resharding: moving data while live
Too big for one machine
App servers
Orders DB
leader + followers
every write
+100 GB a day
one leader for all writes
Shard router
which shard?
Shard
slice 1
Shard
slice 2
Shard
slice 3
customer 7
1
slice 2
2
Restaurant
app
tonight's orders
asks every shard

Sharding solves the size problem, and hands you a few new ones. Here's the first, on the board.

A restaurant app opens its dashboard: tonight's orders. But orders are split by customer, so one restaurant's orders are spread across every shard. The router has to ask all of them and merge the answers, which is called scatter and gather. Fine for three shards; slow and fragile for a hundred. The usual fix is a second copy of the orders, split by restaurant, kept up to date from the same change log.

So, the new problems. Queries without the partition key must ask every shard. Hot shards appear when one key is far busier than the rest, like a viral restaurant if you'd split by restaurant. Joins and transactions across shards get hard, so you design to avoid them. And resharding, adding shards as you grow, means moving data while orders keep arriving. With hash mod N, going from four shards to five moves about eighty percent of the keys. In practice, you copy data to the new shards in the background, then switch reads and writes over, a slice at a time.

In the interview

In the interview
SAY THIS IN THE INTERVIEW
Shardordersbyhashof
customerID:evenload,
andeachcustomer's
querieshitoneshard.
Follow-ups to expect
->
Why not one bigger machine?
->
How do restaurants see their
orders?
->
One shard is overloaded. Now
what?
->
How do you add a shard?
THE COMMON MISTAKE
Shardingfirst.
Indexes,cachesand
replicascomebefore
splittingthedata.

Sharding is where interviewers check whether you scale with a reason, or just because big systems do.

Say it with the key and the reason together: shard orders by a hash of the customer ID, so the load is even and each customer's queries hit one shard. Then name the query that doesn't fit, the restaurant dashboard, and how you'd serve it. That's the part most candidates miss.

Then expect these. Why not one bigger machine? You can, for a while, as lesson five said, but it has a ceiling and a steep price. How do restaurants see their orders? A second copy split by restaurant. One shard is overloaded: now what? Find the hot key, and split it or give it its own shard. And how do you add a shard without moving most of the data? That's tomorrow's lesson.

The common mistake is sharding too early. It makes every query, every migration and every transaction harder. Use indexes, caches and replicas first, and shard when the numbers say one machine can't cope. Say those numbers out loud.

Quick check

Quick check
?
Orders are sharded by
customer ID. Which common
query gets slow?
Restaurant queries, like
tonight's orders: they must ask
every shard.
?
Keys go to shards by hash
mod 4. You add a fifth shard.
Roughly how many keys move?
About 80%: only 1 key in 5
stays where it was.
Remember
Shard when one machine can't
cope
The partition key decides
everything
Hash spreads evenly; range
keeps order
Quick check

Orders are sharded by customer ID. Which common query gets slow?

Show the answer

Restaurant queries, like tonight's orders: they must ask every shard.

Quick check

Keys go to shards by hash mod 4. You add a fifth shard. Roughly how many keys move?

Show the answer

About 80%: only 1 key in 5 stays where it was.

Remember: shard only when one machine can't cope. The partition key decides everything, so pick it from your busiest queries. And hash partitioning spreads load evenly, while range keeps order. Tomorrow, the fix for that eighty percent.

Practise with flashcardsYour progress stays on this device.
New System Design videos at 6 pm

Lessons on weekdays, the week's revision on Saturday, a mock interview on Sunday.