Most system design rounds I've seen go wrong in the same place. Not the big boxes. The candidate draws a load balancer, a cache and a database, the interviewer nods, and then asks one small question about a single arrow: "what happens here when this fails?" That arrow is where the round is decided.
So here are eight flows that come up again and again, what to draw for each, and the one step interviewers almost always poke at. If you can walk through that step out loud, you're in good shape.
1. A request through a load balancer
Draw: client, DNS, load balancer, three app servers, a shared database.
The step they poke at: what the load balancer does when one server stops answering. Talk about health checks (how often, what counts as "unhealthy"), and what happens to requests already in flight on the dying server. Bonus: sticky sessions, and why they make scaling harder.
2. Cache-aside reads
Draw: app checks the cache, misses, reads the database, writes the result back into the cache with a TTL.
The step they poke at: the write path. When the data changes, do you update the cache or delete the key? Deleting is usually safer, because two concurrent writers can leave a stale value if both update. Then expect: "what if 10,000 requests miss the same hot key at once?" That's a cache stampede. Mention request coalescing or a short lock around the refill.
3. A rate limiter
Draw: requests hitting a counter per user or per API key before they reach the service.
The step they poke at: the algorithm and where the counter lives. Token bucket allows short bursts; a fixed window lets someone send double the limit across a window boundary; a sliding window fixes that at more cost. With many app servers the counter has to live somewhere shared, like Redis, and the increment has to be atomic.
4. A message queue between two services
Draw: producer, queue, consumer group, a dead-letter queue.
The step they poke at: delivery guarantees. Most queues give you at-least-once delivery, so the consumer will sometimes see the same message twice. Say how the consumer stays correct anyway: an idempotency key, or a "processed messages" table checked before the side effect. Then: what lands in the dead-letter queue and who looks at it.
5. Database read replicas
Draw: one primary taking writes, two replicas taking reads, replication arrows between them.
The step they poke at: replication lag. A user updates their profile, refreshes, and sees the old value because the read went to a replica a second behind. Fixes worth naming: read-your-own-writes by sending that user's reads to the primary for a short time, or tracking the write's position and waiting for a replica to catch up.
6. Consistent hashing for a sharded cache
Draw: a ring, nodes placed on it, keys mapped to the next node clockwise.
The step they poke at: adding or removing a node. With plain hash(key) % N, changing N moves almost every key. On the ring, only the keys between the new node and its neighbour move. Then they ask about uneven load, and the answer is virtual nodes: each physical server gets many positions on the ring.
7. A CDN in front of static assets
Draw: user, nearest edge location, origin server, cache headers on the response.
The step they poke at: invalidation. You shipped a new app.js and some users still get the old one. The clean answer is versioned file names (app.3f9c.js) with long cache lifetimes, so a deploy changes the URL instead of waiting for caches to expire. Purging the CDN is the fallback, not the plan.
8. A payment that must not run twice
Draw: client, payment service, payment provider, a payments table.
The step they poke at: the retry. The client times out and sends the same payment again. Without protection, the customer is charged twice. The standard answer is an idempotency key sent by the client and stored with a unique constraint, so the second attempt returns the first result instead of creating a new charge. This one shows up a lot because it ties together retries, databases and real money.
How I'd practise these
Reading about them isn't the hard part. Explaining them while someone interrupts you is. Three things that helped me:
- Say each flow out loud in two minutes, then again with one failure injected ("the cache node just died"). If you can't explain the failure case simply, that's the gap.
- Watch the flow move before you draw it. Seeing a request actually travel through the boxes makes the failure step easier to reason about than a static diagram does.
- Do one timed mock where someone, or something, keeps asking "and then what?"
Disclosure: I work on LastRound AI. Its concept explainers are animated, step-through versions of flows like these (238 of them across system design, DevOps, cloud, networking and coding patterns), and they're free on every plan. There's also a system design mock interview that does the "and then what?" part. Use whatever works for you; the eight flows above are the part that matters.
Which step do you get pushed on most? I'm curious whether it's the same arrows for everyone.
Top comments (0)