System Design Mock Interviews: A 45-Minute Drill, a Scoring Rubric and a Feedback Loop (2026)

Reading a solution feels like learning. The room asks for something else: produce a design from a blank board, on a clock, while someone interrupts. Reading rehearses none of that.

A mock interview rehearses exactly that skill. It also fails in quiet ways: a kind friend who scores everything high, a favourite prompt repeated until it is memorised, a solo run nobody checks. This lesson gives a protocol, a rubric that resists inflation, and a loop that turns each mock into a fix. The sibling prep-plan lesson turns it into a calendar.

Why Does a Mock Beat Another Read-Through?#

Two research results support the method. Both have limits.

In a 2006 study, students read prose passages, then took free-recall tests without feedback or restudied the same passages (Roediger and Karpicke):

• Five minutes later, restudying gave better recall.
• Two days and one week later, the tested students remembered substantially more.
• Restudying had made students more confident they would remember.

Pulling an answer out of memory is the testing effectthe finding that taking a memory test improves later retention more than rereading the same material, and a mock does exactly that. The study used students and prose, not engineers and designs.

A 1993 paper links differences among elite performers to the amount of deliberate practiceeffortful practice activity designed to optimise improvement, as the paper's abstract describes it (Ericsson, Krampe and Tesch-Römer). A 2019 replication of its violin study did not reproduce the main result: practice explained about 26% of the performance variance, against 48% in the original (Macnamara and Maitra).

The 45-Minute Protocol#

Every mock uses the framework’s clock, so a score today compares with a score next week. The box lengths are this course’s recommendation. A real loop may differ: Amazon’s page for SDE II candidates describes four 55-minute interviews (Amazon). If yours is 55, keep the table and give the extra ten minutes to the deep dives. Microsoft’s hiring tips tell candidates to ask clarifying questions and plan before implementing (Microsoft), which is the first half of this clock.

Three roles:

• The candidate draws and talks.
• The interviewer follows the script below and says as little as possible.
• The observer is optional. They hold the clock, tally nudges and fill in the rubric silently. With only two people, the interviewer scores afterwards from notes.

The interviewer script#

Opening line: “Design a URL shortener. You have 45 minutes. Ask me questions, talk while you draw, and I may interrupt.” Before the session, write a one-page answer sheet with every number you will give if asked (writes per month, read ratio, latency target).

Withhold these until the candidate asks or earns them:

• Scale numbers, so asking for them is visible.
• Which deep dive to take. Mid-level candidates may be offered a choice; senior candidates choose.
• Any verdict on the design. Say “okay, go on”, never “good” or “that’s wrong”.

Nudge in four steps and tally each one: wait 20 seconds (an assumption), then ask “which requirement does this serve?”, then give a hint (“consider a cache miss”), then name the direction. A design reached only at step three or four scores 2 at most on that dimension.

The probe bank for the deep dive#

For prompt-specific probes use the follow-ups companions listed in the prompt bank below. Ask three to four probes, not all of them. Depth on two beats a survey of ten.

The Scoring Rubric#

Each dimension scores 1 to 4. A 1 means missing, wrong, or reached only after a direct hint. A 2 matches the mid-level anchor, a 3 the senior anchor and a 4 the staff anchor. Score the lowest anchor you fully hit, never a half point, and write down one quote or timestamp as evidence.

Total the seven scores: 7 to 28. Then apply the readiness test below. Evidence matters because confidence is a poor guide: in the testing study above, the students who reread felt surer and remembered less.

What does “ready” look like?#

This is judgement, not an employer standard. No company publishes numeric cut-offs that this lesson found.

Check the arithmetic: seven 2s make 14; five 3s and two 2s make 19; three 4s and four 3s make 24. At least two of the three mocks should be scored by someone other than you.

The Feedback Loop#

The second. A new mock before the debrief repeats the gap and teaches nothing. The order is debrief, log, redo, then re-test.

The 10-minute debrief#

Feedback speaks in evidence: “at 0:19 you chose a queue without saying why”, not “you seemed unsure”.

The error log#

One entry per gap. The root cause decides the fix, so name it:

Date: 2026-10-24
Prompt: URL shortener
Dimension: estimation
What happened:
  sized storage, never used it
Root cause:
  knowledge | process | delivery
Fix:
  redo estimation, 15 min
Redo by: 2026-10-26
Re-test: rate limiter, 10-31
Status: open

Knowledge gaps send you back to a lesson. Process gaps (you knew it and skipped it) need a checklist on the board. Delivery gaps (you knew it and said it badly) need speaking practice.

Redo and re-test#

Redo rule: repeat only the section that held the lowest score, for 10 to 15 minutes, within about 48 hours (an assumption, so the gap is still fresh). Re-test rule: a gap is closed when its dimension meets the target on two consecutive mocks with different prompts. Two, because one good score on the redone prompt proves memory, not skill.

Practising Alone#

A solo mock gives pacing and structure practice, with no one to withhold information.

1. Set a timer with alarms at 0:06, 0:13, 0:26, 0:39 and 0:44.
2. Draw on the tool you will use in the room. Speak every thought aloud.
3. Record screen and audio. Write the answers to your own clarifying questions on paper before you start, from the prompt-bank lesson.
4. Review the recording once at normal speed, pausing at each section boundary.

Score from the recording, not from memory. Review checklist:

[ ] Requirements done by 0:06
[ ] One number per quality
[ ] Every box tied to an endpoint
[ ] One estimate changed a choice
[ ] A cost said per deep dive
[ ] A failure said per component
[ ] Longest silence under 20 s
[ ] No 3-minute monologue

A solo run cannot test reactions to interruptions or new facts. Cover that with a partner or an LLM.

Finding Partners and Asking for the Rubric#

Good sources, none needing a platform:

• Colleagues who have run interviews.
• A study group of three that rotates candidate, interviewer and observer.
• Local engineering meetups.
• An employer or university alumni mock programme, or a mentor.

Before each session send three things: the rubric, the clock, and the rule that the interviewer withholds numbers. Without the rubric, a friendly partner gives kind, vague feedback. Play the interviewer yourself for about one session in three (judgement): marking someone else against the anchors shows you what a 3 and a 4 sound like. Do not trade questions you agreed to keep confidential with an employer.

Using an LLM as the Interviewer#

An LLM gives unlimited volume at any hour. Use it for probes and pacing, not as the final judge. Paste this prompt with the rubric:

Act as a system design
interviewer for a senior role.
Prompt: design a URL shortener.
Rules:
- Say nothing until I speak.
- Answer in one or two lines.
- Never volunteer numbers.
- Do not praise or correct.
- After each section, ask
  one probe at my level.
- Interrupt if three minutes
  pass with no trade-off.
When I say "debrief":
- Score 1-4 per rubric below,
  each with a quote from me.
- No quote means score 1.
- List my claims that may be
  wrong. Do not fix them.
<paste the rubric here>

Where it fails, and the guard for each (judgement):

The LLM-judge study found strong judges matched human preferences on chat answers. It did not test system design interviews. Whether an assistant is allowed in a real round varies by company, so see the framework lesson and ask your recruiter.

The Practice-Prompt Bank#

Ordered easy to hard, by this course’s judgement of how many moving parts each has. “Study first” is the problem lesson; the companion holds the follow-up probes.

Draw prompts at random once you pass stage two below. For a twist, add one constraint from failure modes or from rate limiting, such as abuse or a region loss.

Cadence and Progression#

Assume 8 to 12 mocks in total, two to three a week for three to four weeks. This is a planning assumption, not a research result. The prep-plan lesson sets the actual schedule. What matters here is the order:

A full loop also has coding and behavioural rounds, which this guide does not cover.

How the Method Fails#

When not to use it: before you have read the framework and the building blocks; in the last day or two before a real round, when rest likely helps more than a new gap (judgement); and for coding or object-oriented design rounds, which need other drills.

Try It: A Scored Solo Mock on the URL Shortener#

What Each Level Should Show in Practice#

In One Picture#

Clock    5 + 2 + 5 + 13 + 13 + 5
Roles    candidate, interviewer,
         observer
Rubric   7 dimensions x 1-4,
         one quote each
Debrief  self-score, evidence,
         top 2 gaps, log
Redo     weakest section, 48 h
Re-test  new prompt, two in a row
Ready    5 of 7 at 3+, none at 1
         (senior, judgement)

Conclusion#

A mock is a measurement, and the loop is the training. Keep the clock fixed, score against anchors with evidence, and spend as long on the fix as on the run. Then the numbers mean something, and the gaps close one at a time.

Which dimension is your lowest right now? Tell us in the comments.