Most system design practice looks like this: watch a video, nod along, read a solution, feel ready. Then the real interview starts, someone asks "okay, what happens when this node dies?", and the whole design wobbles.
Reading teaches you designs. A mock interview teaches you to defend one, live, while someone pushes back. That second skill is what the interview actually measures.
Here's how to run a system design mock with a friend or a peer so it feels close to the real thing, plus a simple rubric to score it.
The format: 60 minutes
- 5 minutes of setup. The candidate reads the prompt. Nothing else.
- 45 minutes of design.
- 10 minutes of feedback.
The interviewer prepares beforehand: reads the question, knows what a strong answer covers, and has three or four follow-ups ready. Without that, it turns into two people designing together, which is pleasant and nearly useless.
The candidate's 45 minutes
A structure that holds up for almost any prompt:
- Requirements (5 to 7 min). What must it do? How many users? Read-heavy or write-heavy? How fresh does the data need to be? What can never be lost?
- Estimates (2 to 3 min). Requests per second, storage per year. Rough numbers are fine. The point is that numbers drive your choices.
- API and data model (5 min). A few endpoints and the main entities.
- High-level design (10 min). Only the boxes you need, with one sentence on why each exists.
- Deep dive (15 min). Pick the hardest part yourself: the hot path, consistency, the fan-out.
- Trade-offs and failure (5 min). What breaks at 10x? What if a cache node dies? What would you change with more time?
Step 5 is where levels separate. Strong candidates choose the deep dive themselves instead of waiting to be asked where the hard part is.
The interviewer's job
- Stay mostly quiet for the first 15 minutes. Let the candidate drive.
- Interrupt like a real interviewer would. "Why that database?" "What's the read/write ratio?" "This region just went down. Now what?"
- Watch the clock. Note how long each step takes. Twelve minutes on the API surface is one of the most common pacing problems.
- Write down moments, not vibes. "Didn't mention idempotency for payments" is useful feedback. "Seemed a bit unsure" isn't.
The rubric
Score each area from 1 to 4:
| Area | 1 looks like | 4 looks like |
|---|---|---|
| Requirements and scope | Jumped straight into boxes | Pinned down users, scale and constraints first |
| High-level design | Core pieces missing | Clear components, each one justified |
| Data and storage | Database picked by habit | Choice tied to the access patterns |
| Scale and trade-offs | Only when prompted | Named trade-offs unprompted |
| Communication | Hard to follow | Drove the discussion, easy to follow |
Then give a hire signal (no, lean no, lean hire, hire) and two or three specific things to fix first. Not ten. Two or three.
Questions to practise with
Start with the classics: URL shortener, rate limiter, news feed, chat app, notification service.
Then move to questions that force a specific trade-off:
- Ticket booking system: consistency and locking
- Ride-hailing backend: location indexing and matching
- Metrics pipeline: very write-heavy, with aggregation
- Payment system: idempotency, audit trails, exactly-once thinking
How often
One mock a week while you prepare, and swap roles every time. The interviewer's chair is underrated: watching someone else rush into boxes is the fastest way to stop doing it yourself.
If you don't have a regular partner, I built Practick for exactly this. It runs free system design mock interviews with other engineers, and every question comes with an interviewer guide and a scoring rubric. A friend with this post open on their second screen works just as well.
Top comments (0)