DEV Community

Aditya Shukla
Aditya Shukla

Posted on

How to Run a System Design Mock Interview That Actually Prepares You

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:

  1. 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?
  2. Estimates (2 to 3 min). Requests per second, storage per year. Rough numbers are fine. The point is that numbers drive your choices.
  3. API and data model (5 min). A few endpoints and the main entities.
  4. High-level design (10 min). Only the boxes you need, with one sentence on why each exists.
  5. Deep dive (15 min). Pick the hardest part yourself: the hot path, consistency, the fan-out.
  6. 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)