Part 1
How to do well in the system design round
What the round is graded on
A system design interview gives you an open problem and watches how you work through it. It moves through a few areas, and each one is judged on its own. You shouldn’t lose marks on your first sketch for a failure case nobody has asked about yet; each part counts when you get to it. Here is what interviewers listen for in each.
Requirements
Before anything is drawn, you're expected to work out what the system has to do and for whom, and how big it is. You can ask, or state an assumption out loud, but you should come out of it with at least one number you'll design for: requests a second, how much data, how fast a response has to be.
The high-level design
Name the main parts, then walk one request through them from start to finish. A diagram on its own doesn't show that you know how the pieces talk to each other; the walk-through does.
Data and API
Say what gets stored, what it's keyed by and what kind of store holds it. Then the main calls: what goes in and what comes back.
The deep dive
The interviewer picks a part, or you do, and you go down into it. Say what's hard about it, how it actually works or how you'd fix it, and what that choice costs you.
Load and failure
What breaks first when traffic grows or a part dies, what you'd change or how the system recovers, and what that fix gives up.
Trade-offs
Find a real tension in your own design and pick a side. Say why, and what would make you choose the other way.
The drawing helps, but it isn’t what gets written down. Interviewers mostly note what you say, so a clear explanation over a messy board does better than a tidy board you can’t talk through.
On Calibrd, the interviewer grades each area against exactly these points, and reads your board as part of your answer, so a number or an endpoint you’ve written down counts as said.
How to open: the first five minutes
Say you’re asked to design a URL shortener. Before drawing anything, ask who creates links and who clicks them, whether links expire, and whether owners want to see click counts. Then put some rough numbers on it, out loud:
~40 a second
100 million new links a month works out to about 40 writes a second.
~3,900 a second
10 billion redirects a month is about 3,900 reads a second on average, so plan for peaks near 20,000.
100 to 1
That’s a hundred reads for every write, which tells you the redirect path is where the design matters.
~3 TB
Five years of links is around 6 billion records. At roughly 500 bytes each, that’s about 3 TB.
Then tell the interviewer how you’ll go about it:
“I’ll sketch the redirect path first, since it carries the load, then the data model, and then I’d like to go deeper on the cache.”
In about five minutes you’ve shown you can scope a problem, size it, and plan your time.
On Calibrd, the interviewer always starts with the requirements and waits for them before any design, then asks how you’d like to approach it and follows the order you choose.
The problems you’re most likely to get
Most loops draw their system design interview questions from a familiar set of problems, and people look them up by the product: “Netflix system design” means designing a service like Netflix, not knowing how Netflix built theirs. Each one is really a test of a few ideas, so it pays to know what each is checking rather than memorising a solution.
Netflix system design
Streaming video to millions at once: a CDN close to viewers, switching quality as the connection changes, and a catalogue that loads fast everywhere.
YouTube system design
Creators uploading video: the transcoding pipeline, storage for every format, view counts that stay roughly right, and search.
Instagram system design
Photo uploads and storage, building each person's feed, likes and comments at scale, and accounts with millions of followers.
WhatsApp system design
Long-lived connections, message order, delivery and read receipts, messages for people who are offline, and who is online.
8 more problemsTwitter · Uber · Dropbox · URL shortener · rate limiter · payment system · notification system · search autocompleteSee themHide
Twitter system design
The home timeline: writing posts out to followers ahead of time or assembling them on read, and what to do about celebrity accounts.
Uber system design
Indexing locations so nearby drivers are found fast, matching riders to drivers, and a flood of location updates every few seconds.
Dropbox system design
Splitting files into chunks, not storing the same chunk twice, syncing across devices, and settling two edits made offline.
Design a URL shortener
The worked example above: a read-heavy path, short unique IDs, caching and redirects. Small enough to finish, which is why it is taught first.
Design a rate limiter
Token bucket or sliding window, counters shared across servers, and where the limiter sits in the request path.
Design a payment system
Charges that never happen twice, a ledger that always balances, and reconciling with the bank afterwards.
Design a notification system
Fanning one event out to many people and channels, retries that never send twice, and each person's preferences.
Design search autocomplete
A prefix index, ranking the suggestions, and answering within a few tens of milliseconds.
Without a posting, the mock draws on problems like these, pitched at the role you pick. Paste a posting and it sets one in that company’s own area instead. Run a free mock →
Seven common mistakes, and how to avoid them
We read what interviewers and candidates say goes wrong in this round. The same seven come up again and again, and most of them are habits rather than gaps in knowledge.
- 1
Designing before you understand the problem
The problem is left vague on purpose, to see whether you ask. Candidates who start drawing straight away end up designing for a system nobody described. Spend the first few minutes on who uses it, what it must do and how big it is.
“System design interview questions are often intentionally vague” Educative's guide to the round
On Calibrd: The interviewer won’t move on from the requirements until you’ve pinned them down, and asks again if you skip ahead.
- 2
Skipping the numbers
Without a rough idea of traffic and data, there’s no way to tell whether a design is too small or wildly over-built. Nobody expects exact figures; a few honest estimates are enough to make every later choice defensible.
“The purpose of scale estimation is not mathematical precision.” Fahim ul Haq, who has interviewed hundreds of engineers at Microsoft and Meta
On Calibrd: The requirements only count as covered once there’s at least one number you’re designing for, and the debrief checks your board for them too.
- 3
Adding complexity before there’s a reason for it
Queues, shards and caches appear in the first sketch because they sound senior. An interviewer would rather see a simple design first, then each piece added when you’ve found the bottleneck it solves.
“Complexity should be introduced in response to real bottlenecks” Fahim ul Haq, who has interviewed hundreds of engineers at Microsoft and Meta
On Calibrd: The deep dive is graded on the problem first, then how you solve it, then what it costs, so a component named without its problem doesn’t land.
- 4
Making choices without saying why
Picking a database or a consistency model is fine. Not being able to say why, or what you gave up, is what worries an interviewer, because it suggests the choice was a guess.
“Being unable to justify a design decision” Educative's guide to the round
On Calibrd: The trade-offs area asks you to pick a side, give the reason, and say what would change your mind, and the deep dive asks what each choice costs.
- 5
Only designing the happy path
Real systems lose machines, networks and whole regions. If failure only comes up when the interviewer forces it, it sounds like an afterthought. Bring it up yourself: what breaks first, what users see, how it recovers.
“Strong candidates assume failures are inevitable.” Fahim ul Haq, who has interviewed hundreds of engineers at Microsoft and Meta
On Calibrd: Load and failure is its own area, and the interviewer may take one of the parts on your board down and ask what happens to users.
- 6
Letting the interviewer drive
Waiting to be told what to cover next makes even experienced engineers look unsure. Say what you’re going to do, do it, and narrate as you go.
“it made me seem unsure, unstructured, and junior.” Hemant Pandey, after failing more than ten design rounds
On Calibrd: After the requirements, the interviewer asks how you’d like to approach the design and follows your order, so you practise leading it.
- 7
Going into detail before there’s a whole design
Twenty minutes on one table’s schema leaves no time for the rest. Get the whole design down at a high level first, then choose where to go deep.
“Jumping straight into the details is one mistake that can lead to down-leveling.” Educative's guide to the round
On Calibrd: The deep dive, load and trade-off questions only come once the big picture or the data model is in place, and each area has its own time.
How to prepare: a two-week plan
Two weeks of system design interview practice is enough if you already build software for a living. Spend the first few days on the concepts and the rest on saying designs out loud.
The first five days: learn the building blocks
Caching, sharding, replication, queues, rate limiting and consistency come up in almost every design. For each one, make sure you can say what problem it solves and what it costs. Kleppmann's Designing Data-Intensive Applications is the book most engineers use for this.
Days six to nine: one design a day, out loud
Pick a problem, set a 45-minute timer and talk it through in the order the round runs: requirements and numbers first, then the request path, the data, a deep dive, a failure, and the trade-off you chose. Talking is the point. Reading a worked answer feels like progress but won't tell you where you get stuck.
Days ten to thirteen: full mocks, one fix at a time
Now run the whole round with someone asking follow-ups. Afterwards, pick the one area that went worst, work on just that, and run it again. Trying to fix everything at once usually fixes nothing.
The day before: keep it light
Run through your first five minutes once and tell one failure story out loud. Don't learn anything new.
The second week is where a mock helps most: an interviewer asking follow-ups whenever you have 45 minutes free, and one clear thing to fix after each round.
Ready to try it out loud? Your first mock is free.
Run a free mock →Part 2
Practising it on Calibrd
How Calibrd’s AI system design mock interview works
Pick your role, or paste the job you’re interviewing for, and the System design round is ready to start. An AI interviewer then asks a design problem out loud and runs the round the way a real one would, over about 45 minutes.
It always starts with the requirements and won’t move on until you’ve pinned them down. Then it asks how you’d like to approach the design, big picture first or data model first, and follows your order through the high-level design, the data and API, a deep dive, load and failure, and the trade-offs. Each area gets follow-up questions until it holds. If you spend too long on one, you get a single nudge and then the round moves on, the way it would with a person. It ends with a short wrap-up and then your debrief.
You can answer by voice or by typing, pause whenever you need to, and the round saves as you go. Your first mock is free with a free account, and needs no card.
Two ways to run it
Suggested first
Coached
You get a verdict and one fix after each part of the design, and a second go at any part that misses. If you get stuck, the interviewer can show you a worked example. It’s low-stakes on purpose: you’re learning how the round works, and coached rounds are kept apart from your record so they never flatter it.
The step up
Real interview
The interviewer keeps every note until the end, the way the real round runs. No feedback along the way and no second tries, just you, the problem and the clock. It’s how you find out how you do under pressure, and it’s the verdict to trust before the day.
The whiteboard beside you
Alongside the conversation you get a whiteboard: drag parts onto it, connect them with arrows, and keep your requirements, API and data model in the notes. Here it is with the URL shortener from the first part of this page. On a laptop or desktop you can move things around and add your own parts.
The interviewer reads it every time you answer and asks about what’s there or missing. Nothing you draw on this example is saved or sent.
The problem comes from your job
Most question banks start with the same dozen classics. If you paste the posting you’re interviewing for, Calibrd sets the problem in that company’s area instead, pitched at the level the job asks for, so a Staff role gets a harder problem than a mid-level one. No posting yet? Pick your role and you’ll get the kind of problem that role is usually asked.
If you want to know what candidates have reported at a particular company, its guide is the place to start:
- Stripe
- Netflix
- Databricks
- Datadog
- Atlassian
- Shopify
- Spotify
- Coinbase
- DoorDash
- Figma
- Notion
- OpenAI
- Anthropic
- Monzo
- Revolut
- Wise
- Booking.com
- TikTok
There are also guides to the AI system design interview and the mobile system design interview, company by company.
What your debrief tells you
A mock is only as useful as what you learn from it. When the round ends you don’t just get a score: you find out which parts of your design held up, the one change that would help most, what a strong answer would have sounded like, and whether you’ve improved since last time. This is roughly what one looks like for a second attempt at a round:
“A sound design. The failure story came late.”
Fixed since last timeRequirements with numbers
Still showingFailure handled only when asked
To advance: one more of your answers needs to clear the bar. You’re one away.
An example debrief. Yours is built from your posting and your answers.
Under the verdict sits your board. The verdict comes from what you said; this part shows what the board covered, as notes for next time rather than a score. Here it is exactly as Calibrd shows it, for the URL shortener example:
- Requirements with numbersScale written down, so the parts had something to answer to.
- API endpoints written downThe calls a client makes are on the board.
- Data model note writtenThe data model note is empty. Say what a stored record looks like and what it is keyed by.
- A full request pathArrows run from the client to where the data lives, so one request can be followed.
- A second copy of the dataOne database and no replica: losing it loses the system.
- Calls named on the arrows3 arrows say what kind of call they are.
- The design moved under questionsYou added to the board as the follow-ups came.
- While answering“Before we design anything: who uses this, and how big does it get?”added Cache, URL store · new arrows API → Cache; API → URL store (on miss)
- While answering“Walk me through what happens when someone clicks a short link.”added Click events, Analytics · new arrows API → Click events (click); Click events → Analytics
100M new links a month 10B redirects a month (~4K/s, peaks 20K/s) Redirect p99 under 50 ms
POST /links {url} → code
GET /{code} → 301The verdict above comes from what you said. The board is the evidence beside it.
The real debrief component, on an example round.
A verdict, and how far you are from the next one
Would they advance you, is it borderline, or not yet. When you fall short, it says exactly how many more answers need to clear the bar.
Each part of your design, judged
Which areas landed and which didn’t, with a note on each, so you know whether it was your data model or your failure story that cost you.
The one fix, and what good sounds like
The change that would help most, with an example of how a strong answer to that same question could sound, built on your own design. One tap takes you to practising it.
Your board, played back
The board as it ended, with notes on what it covers, from numbers in the requirements to a second copy of the data, and how it changed as each question came in. Pointers for next time, not a second score.
Progress from round to round
What you fixed since last time and what’s still showing up, so a second “borderline” can still show real progress.
Where you stand
How your round compares with other mock rounds on Calibrd, which is a useful check when you can’t tell whether you’re nearly ready.
Then you run the round again, and the next debrief tells you whether the fix held.
Getting the most from Calibrd
The mock works best as part of a routine rather than a one-off. This is the order we’d suggest:
- 1
Start from the real posting
Paste the job you're interviewing for. The report predicts each round of the loop and the questions it's likely to ask, including the design round, pitched at the posting's level.
- 2
Warm up on single questions
Before a full round, answer one design question at a time by voice in Questions. Each answer is graded on its own, which is a gentler way to find your weak spots.
- 3
Run it coached, then for real
Start with a coached round to learn how it flows, with feedback after each part. Once that feels comfortable, switch to a real one, where nothing is said until the end, and see how you hold up.
- 4
Work on one thing, then run it again
The debrief names the one fix that matters most. Practise only that, run the round again, and check whether that area lands this time.
- 5
Tell Calibrd when the interview is
Set the date and you'll get an email two days before with the one thing worth rehearsing.
What it costs
Your first mock is free. After that you buy time rather than a subscription, so there’s nothing to cancel.
Every pass also includes unlimited reports and CV exports.
FAQ, sources and further reading
What is a system design mock interview?
It's a practice run of the system design round. You get an open problem, usually a service to build, and you scope it, design it, go deep on one part and defend your choices out loud while an interviewer asks follow-ups. Calibrd's is an AI system design mock interview: the interviewer is an AI that speaks, leads the round one area at a time, reads your whiteboard, and gives you a graded debrief at the end.
How do I prepare for a system design interview?
Learn the common building blocks and what each one costs, then practise designing out loud in the order the round runs. Start with the requirements and a few numbers, walk a request through your design, cover the data and the API, go deep on one part, talk through a failure, and pick a side on a trade-off. Finish with a few full mocks, fixing one weak area each time.
Is my drawing graded?
Not as a drawing. Your verdict comes from your answers, and nobody marks you on tidy boxes or straight arrows. What's on the board counts as part of what you said: if you wrote a number or drew a cache, you don't have to say it again, and if what you say and what you drew disagree, what you said wins. Separately, the debrief notes what your board covers, such as numbers in the requirements or a second copy of the data. Those notes are pointers for next time, not a second score.
Where does the design problem come from?
If you paste the job you're interviewing for, the problem is set in that company's domain and pitched at the level the posting asks for, so a Staff role gets a harder problem than a mid-level one. Without a posting, pick your role and you get the kind of problem that role is usually asked, such as designing a feed or a chat service.
How long is the round?
It's paced for about 45 minutes, like the design round in a real loop. You can pause, and it saves as you go.
What's the difference between a coached and a real round?
A coached round gives you a verdict and one fix after each part of the design, a second go at any part that misses, and a worked example if you get stuck. It's for learning how the round works, and it's kept apart from your record. A real round holds every note until the end, with no second tries, so you can see how you do under pressure. We suggest starting coached and moving to real once the round feels familiar.
What do I need?
A laptop or desktop browser and a microphone. You can type an answer instead of speaking if you'd rather. On a phone the round runs by voice without the board, because a design board needs the room.
Can I do a free system design mock interview?
Yes. Your first mock is free with a free account, and no card. You can set the round up before signing up; the account is asked for when you start. After that, a pass buys time rather than a subscription: 7 days for $9.99 includes 5 mocks.
Is my audio kept?
No. Your speech is transcribed so the interviewer can respond, then the audio is gone. The transcript, your board and the debrief stay in your account, encrypted at rest, and you can delete them whenever you like.
- 01Fahim ul Haq, Common mistakes in system design interviewsan interviewer’s list, from hundreds of interviews at Microsoft and Meta
- 02Hemant Pandey, Lessons after failing 10+ system design interviewsa candidate’s side, after rounds at Meta, Stripe, Uber and Google
- 03Educative, Six common system design interview mistakesthe mistakes that most often lead to down-levelling
- 04Designing Data-Intensive Applications, Martin Kleppmannstorage, replication and the trade-offs behind most deep dives
- 05Site Reliability Engineering, Googlefree to read online; how real systems fail and recover
- 06System Design Interview, Alex Xu (ByteByteGo)worked designs of the classic problems
Rehearse the design round
Say the design out loud before the day you have to
Pick your role or paste the job, and the interviewer will take you through the design round with the board beside you. Afterwards you’ll know which areas held up and the one thing to work on.
Free to start · No card · Encrypted at rest, never used to train AI, remove anytime