System design mock interview: how to prepare, and how to practise it out loud.

Updated

Most people who struggle in the system design round know the material. What goes wrong is how they run the 45 minutes: they draw too early, skip the numbers, or never say what their choices cost. The first part of this page is about the round itself and how to prepare for it. The second is about practising it on Calibrd, where an AI interviewer runs the round with you out loud and reads your whiteboard as you go.

First mock free · free account, no card

Rehearse the design round for the job you’re going for.

Run a free system design mock →Or try the whiteboard first ↓

Pick your role and the System design round is set up for you. You’ll need a free account, a laptop or desktop, and a microphone.

Part 1

How to do well in the system design round

01

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.

02

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.

03

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 →

04

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. 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. 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. 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. 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. 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. 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. 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.

05

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.

  1. 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.

  2. 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.

  3. 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.

  4. 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

06

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.

Example board · Design a URL shortenerEditable
GET /{code}on missclick
Client
Client
Load balancer
Load balancer
Service
API
stateless
×3
The interviewer is asking about this
Cache
Cache
Redis, 24h TTL
Database
URL store
key: short code
Queue
Click events
Kafka
Object storage
Analytics
daily rollups

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.

07

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:

There are also guides to the AI system design interview and the mobile system design interview, company by company.

08

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:

System design · Senior Backend · second round44 min
Borderline

“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.

RequirementsLanded it
High levelLanded it
Data and APILanded it
Deep diveLanded it
Load and failureNot yet
FixWhen a part goes down, say what users see first, then how the system recovers.
Sounds like“If the cache goes down, redirects fall through to the URL store. Nothing breaks, but latency jumps, so I’d cap traffic to the store while a standby cache warms up.”
Drill nextRun the round again and bring up the cache failing before they do.

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:

5 of 7 things the board shows · 7 parts · 6 arrows
GET /{code}on missclick
Client
Client
Load balancer
Load balancer
Service
API
stateless
×3
Cache
Cache
Redis, 24h TTL
Database
URL store
key: short code
Queue
Click events
Kafka
Object storage
Analytics
daily rollups
What the board shows
  • Shown: Requirements with numbersScale written down, so the parts had something to answer to.
  • Shown: API endpoints written downThe calls a client makes are on the board.
  • Missing: Data model note writtenThe data model note is empty. Say what a stored record looks like and what it is keyed by.
  • Shown: A full request pathArrows run from the client to where the data lives, so one request can be followed.
  • Missing: A second copy of the dataOne database and no replica: losing it loses the system.
  • Shown: Calls named on the arrows3 arrows say what kind of call they are.
  • Shown: The design moved under questionsYou added to the board as the follow-ups came.
How your design changed
  • 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
Requirements
100M new links a month
10B redirects a month (~4K/s, peaks 20K/s)
Redirect p99 under 50 ms
API
POST /links {url} → code
GET /{code} → 301

The 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.

09

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. 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. 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. 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. 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. 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.

10

What it costs

Your first mock is free. After that you buy time rather than a subscription, so there’s nothing to cancel.

Free1 mockyour first, on us
7 days$9.995 mocks
30 days$19.9915 mocks
90 days$39.9945 mocks

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.

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

System Design Mock Interview: How to Prepare — Calibrd