How to Use This Guide
On this page
Most engineers preparing for system design interviews hit the same wall. They read about caches, queues and sharding for weeks, then open a mock interview with "Design a ticket booking system" and freeze. They know the parts, but not where to start, what to say first, or how to tell which part matters for this problem. Reading more does not fix that. Practising the right loop does.
This guide is built around that loop. It is not a textbook to read cover to cover; it is a training path from "I don't know where to start" to "I can drive a 50-minute design conversation calmly". This page explains how the System Design track is organized and how to use it.
How it works
The sections, in reading order

| Section | What it gives you | How to use it |
|---|---|---|
| Quick Start | How the interview is scored, the 50-minute framework, common mistakes, 7-day and 30-day plans | Read all of it first, about two hours |
| Core Building Blocks | Database, cache, CDN, message queue, blob storage, API gateway, search | One or two a day; focus on "when to reach for it" |
| Problems | Full interview walkthroughs, easy to hard | The main practice material; try each one before reading |
| Deep Dive Toolkit | Locking, Bloom filters, sharding, consistent hashing, rate limiting, idempotency, backpressure, TTL | Look up a topic when a problem needs it |
| Patterns | Read-heavy, write-heavy, real-time, fanout, large files, sync | Read after 4–5 problems, to see what repeats |
| Before Interview | Cheat sheet, numbers, phrases, hire signals | The last 2–3 days |
Problems come early on purpose. A building block only makes sense once you have seen it solve something, and the Deep Dive Toolkit makes far more sense when a problem has just raised the question ("two users booked the same seat; now what?").
The practice loop

- Pick a problem at your level (the Problems list goes from easy to hard).
- Try it first. Set a 20-minute timer and sketch requirements, an API and a high-level design on paper. Every walkthrough has a "Try it first" pause after the requirements for exactly this.
- Read the walkthrough and compare it with your sketch. Note what you missed: a question you didn't ask, a number you didn't estimate, a bottleneck you didn't see.
- Fill the gaps. Follow the links to the building block or toolkit article for each thing you missed.
- Say it out loud in 5 minutes, without notes, as if to an interviewer.
Then repeat with a slightly harder problem. Most of the learning happens in steps 2 and 5, the parts that feel uncomfortable.
How to read a walkthrough
Each problem article follows the same structure as a real interview: the problem and good clarifying questions, requirements, core entities, API, the high-level design flow by flow, deep dives into the hard parts, and what is expected at each level.
Read the Weak / Good / Strong toggles closely. They show the difference between an answer that names a component and one that explains why it fits, what number drives it, and what it costs. That difference is most of what interviewers score.
Trade-offs and costs
- Trying first is slower than reading straight through. It is also the only way to find out what you can't do yet.
- Speaking out loud feels awkward. Do it anyway; the interview is spoken, and fluent explanation is a separate skill from understanding.
- Breadth vs depth: you can't master every toolkit topic. Learn each to the level of "when does it come up, what does it solve, what does it cost", and go deep only where your target roles need it.
When to reach for it
- Interview in a week or less: follow the 7-Day Crash Plan.
- Four or more weeks: follow the 30-Day Study Plan.
- New to system design: read every Quick Start article, then the building blocks, then easy problems only for the first week.
- Experienced but rusty: skim the framework, then go straight to medium and hard problems and the toolkit.
- The night before: the Requirements and Deep Dives of the problems you practised, and the Before Interview cheat sheet.
Example
A backend engineer with three weeks before an onsite:
- Days 1–2: Quick Start, then What System Design Interviews Test and the 50-Minute Interview Framework twice.
- Days 3–5: the seven building blocks, one short note each: when to use it, when not to, one trade-off, one example problem.
- Days 6–15: one problem a day with the full loop, starting with Design a URL Shortener and Design a Rate Limiter. Toolkit topics as they come up.
- Days 16–18: Patterns, then redo two earlier problems from memory.
- Days 19–21: three timed mocks with a friend, then Before Interview.
Common mistakes
- Reading every article before solving anything. It feels productive and builds little interview skill.
- Memorizing final diagrams. Interviewers change the requirements; you need the reasoning, not the picture.
- Skipping "Try it first". Without your own attempt, you can't see what you would have missed.
- Starting every design by adding a cache, a queue and a CDN. Each part needs a reason you can state.
- Never practising out loud.
Say this in the interview
The guide's whole approach comes down to an opening you can use in every round:
"I'd like to start by clarifying the core use cases and the scale, then sketch a simple design that works end to end, and then spend most of our time on the two or three parts most likely to break."