System Design HLD-18.01
A repeatable framework
An eight-step path for system design interviews and reviews: requirements, estimates, API, data model, diagram, deep dives, failures and wrap-up.
The big idea
"Design Twitter" is a terrifying prompt if you start drawing boxes immediately. It becomes manageable with a method. A repeatable framework does three things: it makes sure you understand the problem before solving it, it spends your limited time where the interviewer learns the most about you, and it gives the conversation a structure both sides can follow.
The framework is not a script to recite. It is a checklist that keeps you from the two classic failures: designing the wrong system, and running out of time before showing depth. Most interviewers care far more about how you reason, the questions you ask, the trade-offs you name, the numbers you use, than about whether your final diagram matches some answer key.
Think of a doctor's consultation. Symptoms first, then tests, then a diagnosis, then treatment options with their risks. Skipping straight to a prescription is both risky and unconvincing, however good the prescription.
How it works
Step 1: The eight steps
- Clarify requirements. Core features, users, scale, latency, availability and consistency needs, and what is out of scope ( Functional and non-functional requirements ).
- Estimate. Requests per second for reads and writes, peak, storage per year, bandwidth ( Back-of-the-envelope estimation ). These numbers decide whether you need caching, sharding or queues.
- Define the API. A handful of endpoints with inputs and outputs. It pins down exactly what the system must do.
- Sketch the data model. Entities, keys and access patterns, then the store that fits each ( Choosing the right database ).
- Draw the high-level design. Start simple and evolve it to meet the requirements, read and write paths separately, every arrow labeled ( Drawing the high-level diagram ).
- Deep dives. The one or two components most likely to break, with options and a reasoned choice ( Deep dives and trade-off discussions ).
- Bottlenecks and failures. What breaks first at ten times the load, and what happens when each component dies.
- Wrap up. Summarize the design, its main trade-offs and what you would do next.
Step 2: Drive, but listen
You lead the conversation, saying what you are doing ("let me estimate before choosing storage"), but the interviewer may steer you: "assume we have a cache", "go deeper on the feed". Follow the steer; it tells you what they want to see. Check in at transitions: "does this scope sound right?"
Step 3: Make each step feed the next
The value of the framework is in the links. The estimates justify the design ("200,000 reads per second means the timeline must be served from cache"); the access patterns justify the data store; the requirements decide which component deserves the deep dive. An answer where each decision points back to a number or a requirement is far more convincing than a correct diagram with no reasons.
Try it
Try this:
- Pick a prompt, such as "design a URL shortener" ( Design a URL shortener ), and run the timer in real time, talking out loud or writing notes.
- Notice where you overrun. Most people spend too long clarifying or drawing, and reach the deep dives with five minutes left.
- Use Skip to next step when you finish early; extra time is best spent in the deep dives.
Trade-offs
| Option | Wins when | Loses when |
|---|---|---|
| Following the framework closely | Nervous or new candidates, unfamiliar prompts: never miss a step | Flexibility when the interviewer wants to jump to a specific area |
| Jumping to the interesting part | When the interviewer explicitly asks to skip setup | Context: decisions without requirements and numbers look arbitrary |
Common mistakes
- Drawing before clarifying, then designing the wrong system.
- Spending twenty minutes on requirements and never reaching the deep dives.
- Estimating numbers and then never using them.
- Ignoring the interviewer's hints because they do not fit your plan.
Check yourself
-
Why estimate before choosing components?
Show answer
B. The numbers decide whether you need caching, sharding or queues Scale drives design; estimates justify each choice.
-
Which step usually deserves the most time?
Show answer
B. Deep dives into the riskiest components Deep dives show real understanding and trade-off reasoning.
-
The interviewer says 'assume the cache exists; tell me about the feed ranking'. What should you do?
Show answer
B. Follow the steer and go deep on ranking Steers show what the interviewer wants to evaluate.
-
What makes a design answer convincing?
Show answer
B. Decisions tied back to requirements and numbers Reasoned trade-offs matter more than matching an answer key.
Recap
- Use a repeatable path: clarify, estimate, API, data model, diagram, deep dives, failures, wrap-up.
- Time-box the early steps so you reach the deep dives.
- Lead the conversation, but follow the interviewer's steers.
- Tie every decision to a requirement or a number.
- Practice with a timer until the pacing is automatic.
Next up
- Crack the system design round learning path