A Step-by-Step Framework for System Design Interviews
System design interviews are open-ended on purpose. There is no single correct answer, so interviewers watch how you structure ambiguity. Candidates who do well are rarely the ones who know the most technologies. They are the ones who follow a clear process, make their assumptions explicit, and talk through trade-offs. This framework gives you that process.
The framework at a glance
- Clarify requirements and scope
- Estimate scale
- Define the API
- Sketch the data model
- Draw the high-level design
- Deep dive on the hard parts
- Find bottlenecks and discuss trade-offs
Keep to roughly this order, and say where you are as you go: "I will start with requirements, then estimate scale." It reassures the interviewer and keeps you from jumping straight to boxes and arrows.
1. Clarify requirements and scope
Spend the first few minutes asking questions. Split them into two groups.
- Functional requirements: what the system must do. What are the core actions? Who are the users? What is out of scope?
- Non-functional requirements: how well it must do it. Think about availability, latency, consistency, durability and expected growth.
Write the agreed list down where the interviewer can see it. You will refer back to it when you justify decisions.
2. Estimate scale
Back-of-the-envelope numbers decide whether you need one database or many. State your assumptions out loud, because the interviewer is checking your reasoning, not the exact figures. Estimate requests per second, how much data you store per day and over several years, and the read-to-write ratio. A read-heavy system points toward caching and replicas; a write-heavy one points toward partitioning and queues.
3. Define the API
List the main operations with their inputs and outputs. For a REST-style design, that means a handful of endpoints. This step forces you to be concrete about what the system exposes, and it often surfaces requirements you missed.
4. Sketch the data model
Identify the main entities, their relationships and the access patterns. Then choose storage based on those patterns, not on habit. A relational database suits structured data with joins and transactions. A key-value or wide-column store suits simple lookups at very high scale. Explain why you chose one.
5. Draw the high-level design
Now draw the main components: clients, a load balancer, stateless application servers, storage, a cache, and any queues or background workers. Walk through one request from end to end. Keep it simple at this stage. You can add detail where the interviewer shows interest.
6. Deep dive on the hard parts
Every design has one or two hard problems. Name them and go deep. Typical examples include generating unique IDs without collisions, keeping a cache consistent with its database, fanning a post out to many followers, or handling a hot partition. This is where seniority shows, so slow down here.
7. Find bottlenecks and discuss trade-offs
Finish by stress-testing your own design. What happens when a component fails? Where is the single point of failure? What gets slow first as traffic grows? Every choice has a cost, so say what you traded away. Interviewers value a candidate who says "this design favours availability over strict consistency, and here is the effect on users" more than one who claims their design has no downsides.
A short worked example: a URL shortener
Here is how the framework applies to a classic prompt.
- Requirements: create a short link from a long URL, redirect a short link to the original, optionally support custom aliases and expiry. Redirects should be fast and highly available.
- Estimation: assume far more redirects than creations, so the system is read-heavy. That points to caching popular links.
- API: a create operation that takes a long URL and returns a short code, and a redirect operation that takes a code and returns the original URL.
- Data model: a mapping from short code to long URL, plus metadata such as creation time and expiry. A key-value store fits the lookup pattern.
- Deep dive: how to generate short codes without collisions. Options include encoding an incrementing counter, hashing the URL and handling collisions, or pre-generating a pool of codes. Compare their trade-offs.
- Trade-offs: a cache in front of the store speeds up reads but can serve a link after it expires unless you manage expiry carefully.
What interviewers listen for
| Signal | What it sounds like |
|---|---|
| Structure | You state a plan and follow it, instead of wandering |
| Communication | You explain why, not just what, and check in with the interviewer |
| Judgement | You pick a reasonable option and defend it, rather than listing every option |
| Depth | You can go one level deeper on any component you drew |
| Honesty about trade-offs | You name the downsides of your own design |
How to practise
Pick a prompt, set a 40-minute timer, and talk through your design out loud with a whiteboard or paper. Afterwards, compare your design against a worked solution and list what you missed. Repeat with a new prompt, and revisit earlier prompts after a few days to see whether the framework has become automatic. Our 4-week technical interview plan shows where system design practice fits in a full schedule.
Practise this with AI
Generate questions for your target role in one click, attempt them first, then reveal the full solution and answer AI follow-ups.
Generate your first question