System Design (High-Level Design) Module 30 – Interview practice and study plans
Running a timed self-mock interview
How to run a 45-minute system design mock on your own, with a timer, a notes template, interruption cards and a recording, then score it and pick a drill.
What you will learn
- Run a 45-minute self-mock with a timer, a notes template, interruption cards and a recording
- Assess the recording from logged evidence before reading any sample answer
- Choose one strength, one gap and one drill from each review
- Distinguish real progress from scoring noise in a log of mocks
Before you start
What you’ll learn · Before you start
What you will learn
- Run a 45-minute self-mock with a timer, a notes template, interruption cards and a recording
- Assess the recording from logged evidence before reading any sample answer
- Choose one strength, one gap and one drill from each review
- Distinguish real progress from scoring noise in a log of mocks
Before you start
On this page
A self-mock is a practice design round that you run on your own, under the conditions of a real one. Choose a prompt you have not studied, start a 45-minute timer split into the seven steps of a round, and design aloud while you draw and take notes, with a recording running. When the timer ends, stop. Hours later, score the recording against a written rubric before you read any sample answer, and leave with one strength, one gap and one drill for the week. Reading case studies shows what a good design contains; only a timed round shows whether you can produce one in 45 minutes, on a problem you have not met, while you explain it. One cycle takes about an hour and a half: 5 minutes to set up, 45 for the round and about 40 for the review.
A self-mock keeps the round and loses the interviewer
A self-mock shows what a round shows: whether you ask the questions that change the design, reach a design that works end to end, choose the risky parts and say what fails, and keep the discussion clear, all inside the time.
What it lacks is the interviewer, and that costs three things. Nobody interrupts, so you never practise being steered. Nobody answers your questions, so you must answer them yourself. And nobody scores you, while people judge their own work poorly. A review of research on self-assessment found that people’s views of their abilities are only weakly to modestly related to how they actually perform (Dunning, Heath and Suls). The protocol replaces each missing part, one job at a time:
The drawing shows the whole scene; its 5 steps are listed below.
Every step as text
- What goes missing. In a real round the interviewer does three jobs besides listening. They steer you, they answer your questions, and they score the round. Practising alone takes all three away.
- Nobody steers. Nobody interrupts, so you never practise being steered. Three cards written before the round and opened at minutes 20, 32 and 38 bring the interruptions in from outside.
- Nobody answers. Nobody answers your questions. Ask each one aloud anyway, give the answer you will assume, and write it down, so the design rests on assumptions anyone can check.
- Nobody scores. Nobody scores you, and people judge their own work poorly. A recording scored hours later against written descriptions, before any sample answer is read, stands in for the score.
- The round, kept. With the three stand-ins in place, the self-mock keeps what the round tests, a problem you have not met inside 45 minutes, and leaves evidence a rubric can score.
Checkpoint
Check: What practising alone loses
The protocol: five minutes before, 45 during, 40 after
One cycle of a self-mock, from the set-up to the next prompt
Text description of the diagram
The diagram is a column of boxes joined by arrows, from top to bottom:
- Set up, 5 minutes: an unseen prompt, a seven-step timer, notes, a recording and three cards.
- The round, 45 minutes: design aloud, and open the cards at minutes 20, 32 and 38.
- Stop at 45:00 and note where you stopped.
- Hours later, score the recording from the evidence you logged.
- Then read a sample answer and note what yours lacks.
- One strength, one gap and one drill for the week.
- A decision: the next mock.
From the decision, an arrow labelled "usually" leads to "A new prompt: counts towards readiness", and an arrow labelled "now and then" leads to "The same prompt again: shows whether the drill worked".
Before, 5 minutes. Choose a prompt you have not studied, such as the title of a case study in this track that you will read only after scoring. Set a timer to seven intervals of 5, 5, 5, 5, 10, 12 and 3 minutes, the steps of the round framework. Open a blank page and the notes template, start a recording (audio is enough), and write three A question written before a self-mock and opened at a fixed minute of the round. It stands in for an interviewer who steers and interrupts. to open at minutes 20, 32 and 38:
- “Traffic will be ten times higher next month. What changes?”
- “The part you are working on stops. What do users see, and how does the system recover?”
- “Reverse the assumption you are least sure of. What in your design changes?”
During, 45 minutes. Speak the whole time, as you would to an interviewer. When you would ask a question, ask it aloud, give the answer you will assume, and write it down. When an interval ends, say where you are and move on; when a card comes up, read it aloud, answer it, and go back to your plan. At 45:00, stop, even mid-sentence. Walk through the 45 minutes:
- Minute 0
Requirements, 5 minutes
The timer starts with the recording. Ask aloud the questions that would change the design, and say the answer you will assume for each.
- Minute 5
Estimates, 5 minutes
Work out the numbers at the peak, and give each one an arrow to what it decides.
- Minute 10
API, 5 minutes
The main operations with their inputs and what each returns, one for every functional requirement.
- Minute 15
Data model, 5 minutes
Each entity with its key, how it is read and where it lives.
- Minute 20
Diagram, 10 minutes, and card 1 card
Card 1 opens as the diagram starts: "Traffic will be ten times higher next month. What changes?" Read it aloud, answer it, and go back to the plan.
- Minute 30
Deep dives, 12 minutes
Two or three risky parts, each worked through with numbers and what fails.
- Minute 32
Card 2 card
"The part you are working on stops. What do users see, and how does the system recover?" It lands inside a deep dive, which is where a real interviewer would push.
- Minute 38
Card 3 card
"Reverse the assumption you are least sure of. What in your design changes?" Answering it means going back to the requirements and the decisions that rest on them.
- Minute 42
Wrap-up, 3 minutes
The first bottleneck, the first failure you would test and what you would build next.
- Minute 45
Stop
Stop when the timer ends, even mid-sentence, and note where you stopped. Where you stopped is evidence for the review.
The timeline has 10 events, from Minute 0 to Minute 45.
After, about 40 minutes, hours later. Score the recording with a timed log of evidence, as in How design rounds are assessed. Only then read a sample answer and note what yours lacks. The order matters: once you have read a good answer, its points start to sound like your own, and you score yourself too high. Finish with one strength, one gap and one drill. The next mock uses a new prompt; the same prompt a week later shows whether a drill closed its gap, but it never counts towards readiness.
Interval Timer Set seven intervals of 5, 5, 5, 5, 10, 12 and 3 minutes, with a sound at each change.Checkpoint
Check: The protocol of a self-mock
Notes in the template can be checked by a program
The template has one section for each step and three running lists. Replace each planned minute with the minute you actually started the step:
Prompt:
Clock time at the start:
## Requirements [00:00]
- Functional:
- Non-functional, with a number each:
- Non-goal:
- Assumption:
## Estimates [05:00]
- number -> what it decides
## API [10:00]
- operation with its inputs -> what it returns
## Data model [15:00]
- entity: key, how it is read, where it lives
## Diagram [20:00]
- path walked: one line for each main operation
## Deep dives [30:00]
- Risk: | fix: | fails:
## Decisions
- Decision: | because: | cost:
## Interruptions
- [mm:ss] card: | answer:
## Wrap-up [42:00]
- First bottleneck:
- First failure I would test:
- What I would build next:Two conventions make the notes checkable. Each number in the estimates is followed by an arrow and what it decides. Each decision is one line with its reason and its cost, the smallest useful version of an architectural decision record: the record of a single design choice and the reasoning behind it. This program checks the notes of a first self-mock, on a paste service, against the template:
# Checks the notes of one self-mock against the template of this lesson: the minutes each step took against the
# 45-minute plan, steps left empty, numbers that decide nothing, decisions without a cost, deep dives that never say
# what fails, and interruption cards left unanswered. Press Edit, paste your own notes into NOTES and run it again.
NOTES = """
Prompt: design a paste service
## Requirements [00:00]
- Functional: paste text of up to 1 MB and get a short link; anyone with the link can read it
- Functional: a paste expires after an hour, a day, a week or never
- Non-functional: 99 % of reads within 200 ms
- Assumption: 1 million new pastes a day, 10 reads each
- Non-goal: accounts and search
## Estimates [09:30]
- 12 writes a second on average, 58 at the peak -> one database takes the writes
- 3.65 TB of new text a year
- 116 reads a second on average
## API [13:00]
- POST /pastes with the text and an expiry -> 201 with the id and the link
- GET /p/{id} -> the text, 404 for an unknown id, 410 once it has expired
## Data model [17:30]
- pastes: id, created, expires, size, where the text is stored
## Diagram [21:00]
- path walked: create, from the client to the database and the object store
- path walked: read, through the cache
## Deep dives [35:00]
- Risk: two pastes get the same id | fix: insert only if the id is new, else draw again
- Risk: one paste goes viral | fix: the cache takes the reads
## Decisions
- Decision: the text lives in an object store | because: 3.65 TB a year | cost: two stores to keep in step
- Decision: random ids of 8 characters | because: nothing to coordinate between servers
## Interruptions
- [20:10] card: ten times the traffic | answer: more API servers; the cache takes the extra reads
- [32:00] card: the part you are working on stops | answer:
- [38:40] card: reverse the least certain assumption | answer: pastes can be edited, so cached copies must be deleted
## Wrap-up [44:20]
"""
# The plan of a 45-minute round: each step and the minutes of its time box.
PLAN = {"Requirements": 5, "Estimates": 5, "API": 5, "Data model": 5, "Diagram": 10, "Deep dives": 12, "Wrap-up": 3}
END = 45 * 60 # the round stops at 45:00
def seconds(stamp):
""" "09:30" -> 570; anything else (a heading without a minute) -> None."""
minutes, _, secs = stamp.strip().partition(":")
if not (minutes.isdigit() and secs.isdigit()):
return None
return int(minutes) * 60 + int(secs)
def sections(notes):
"""Each "## Name [mm:ss]" heading with the minute it started and the "- " lines under it."""
found, current = [], None
for line in notes.strip().splitlines():
line = line.strip()
if line.startswith("## "):
name, _, rest = line[3:].partition(" [")
current = {"name": name.strip(), "start": seconds(rest.rstrip("]")) if rest else None, "lines": []}
found.append(current)
elif line.startswith("- ") and current is not None:
current["lines"].append(line[2:])
return found
def count(n, word):
return f"{n} {word}{'' if n == 1 else 's'}"
def verb(n, one, many):
return one if n == 1 else many
def check(notes):
parts = sections(notes)
steps = [p for p in parts if p["name"] in PLAN and p["start"] is not None]
by_name = {p["name"]: p for p in parts}
findings = []
unstamped = [p["name"] for p in parts if p["name"] in PLAN and p["start"] is None]
if unstamped:
findings.append(f"No start minute, so left out of the times: {', '.join(unstamped)}")
print(f"{'Step':<14}{'Started':>8}{'Plan':>6}{'Used':>6}")
over = []
for i, step in enumerate(steps):
end = steps[i + 1]["start"] if i + 1 < len(steps) else END
used = (end - step["start"]) / 60
plan = PLAN[step["name"]]
note = ""
if used - plan >= 2:
note = f" {used - plan:.1f} over"
over.append(step["name"])
elif plan - used >= 2:
note = f" {plan - used:.1f} short"
if not step["lines"]:
note += ", empty" if note else " empty"
start = f"{step['start'] // 60:02d}:{step['start'] % 60:02d}"
print(f"{step['name']:<14}{start:>8}{plan:>6}{used:>6.1f}{note}")
if over:
findings.append(f"{count(len(over), 'step')} ran 2 minutes or more over the box: {', '.join(over)}")
empty = [s["name"] for s in steps if not s["lines"]]
if empty:
findings.append(f"Empty: {', '.join(empty)}")
estimates = by_name.get("Estimates", {"lines": []})["lines"]
idle = [line for line in estimates if "->" not in line]
if idle:
findings.append(f"{len(idle)} of {count(len(estimates), 'estimate')} {verb(len(idle), 'decides', 'decide')} nothing (no '->'): " + "; ".join(idle))
decisions = by_name.get("Decisions", {"lines": []})["lines"]
no_cost = [d for d in decisions if "cost:" not in d or not d.split("cost:")[1].strip()]
if no_cost:
names = [d.split("|")[0].removeprefix("Decision:").strip() for d in no_cost]
findings.append(f"{len(no_cost)} of {count(len(decisions), 'decision')} {verb(len(no_cost), 'has', 'have')} no cost: " + "; ".join(names))
dives = by_name.get("Deep dives", {"lines": []})["lines"]
failing = [d for d in dives if "fails:" in d and d.split("fails:")[1].strip()]
findings.append(f"{len(failing)} of {count(len(dives), 'deep dive')} {verb(len(failing), 'says', 'say')} what fails")
cards = by_name.get("Interruptions", {"lines": []})["lines"]
unanswered = [c.split("]")[0] + "]" for c in cards if not c.split("answer:")[-1].strip()]
if unanswered:
findings.append(f"{len(unanswered)} of {count(len(cards), 'card')} {verb(len(unanswered), 'has', 'have')} no answer: {', '.join(unanswered)}")
print("\nFindings:")
for f in findings:
print(f"- {f}")
check(NOTES)Output
Step Started Plan Used Requirements 00:00 5 9.5 4.5 over Estimates 09:30 5 3.5 API 13:00 5 4.5 Data model 17:30 5 3.5 Diagram 21:00 10 14.0 4.0 over Deep dives 35:00 12 9.3 2.7 short Wrap-up 44:20 3 0.7 2.3 short, empty Findings: - 2 steps ran 2 minutes or more over the box: Requirements, Diagram - Empty: Wrap-up - 2 of 3 estimates decide nothing (no '->'): 3.65 TB of new text a year; 116 reads a second on average - 1 of 2 decisions has no cost: random ids of 8 characters - 0 of 2 deep dives say what fails - 1 of 3 cards has no answer: [32:00]
Recorded with Python 3.14.8 on macOS 26 arm64. To run it yourself: mise exec python@3.14.8 -- python3 notes_check.py
Runs on this device, in your browser. The first run downloads Python (about 13.5 MB), which is kept for the next runs.
Your run, in this browser
The findings are typical of a first mock. Requirements ran four and a half minutes over, the diagram four more, so
the deep dives got 9.3 minutes instead of 12 and the wrap-up never happened. Press Edit, paste your own
notes into NOTES and run it.
Checkpoint
Check: Notes that can be checked
Practise: a self-mock on parcel lockers
Run a self-mock on this prompt before you look at any answer to it:
The prompt
Design the system behind a network of parcel lockers in one city. Couriers put parcels into empty compartments of lockers in metro stations and shops. Each recipient gets a code and has three days to collect; after that, the parcel goes back to the courier.
If you ask about scale, the answer is 2,000 lockers of 60 compartments and 100,000 parcels a day, half of them collected within 8 hours. Everything else is yours to ask aloud and assume. Then check what you know about running one.
Practice that adapts to you
Practise this lesson
9 questions about 7 ideas of this lesson. Each answer is explained at once, and what you get right is kept in this browser.
Reviewing a recording twice, with a worked score Pro: opens with a Pro, Premium or Ultimate pass
A recording only helps if you review it with a method; without one, you remember the good minutes and miss the rest. This part reviews the paste-service round from its recording, scores it from the evidence, and corrects the three ways self-scoring goes wrong.
In this part:
- The first listen: the clock, the silences and the cards
- The second listen: evidence against each description, scored
- Three ways self-scoring goes wrong, and the fix for each
1 diagram · 1 runnable example (Python) · about 6 minutes
Opening this part with your pass…
This part opens with any MySmartCoPilot pass.
- Pro pass · 1 week₹79$2.99
- 30 days₹179$5.99
- 1 year₹1,699$45
One payment; a pass never renews. The price shown is the total you pay: no fees or charges are added at checkout.
Passes can’t be bought right now, so this part can’t be opened at the moment. The free part above stands on its own. If you have a pass, enter your licence key.
It also opens every other in-depth part in Learn and every Pro tool. Sales are final, except where the law gives you a right to withdraw, for example in the EU and the UK (refund policy).
Read a complete sample first: Design a real-time leaderboard
A sample answer to the parcel locker prompt, scored by level Pro: opens with a Pro, Premium or Ultimate pass
Read this answer only after you have scored your own mock. It is one answer that meets this track’s senior bar, not the only good one, and each moment is labelled with the dimension it shows.
In this part:
- The estimates, and the number that decides the design
- The answer, moment by moment, with the dimension each shows
- What each level’s answer adds
1 diagram · 1 runnable example (Python) · about 7 minutes
Opening this part with your pass…Pro part. It opens with the same pass as the part above.
From review to drill, and progress you can trust Pro: opens with a Pro, Premium or Ultimate pass
A review pays off only when it changes the next mock. This part turns one review into one drill, gives a drill for each dimension with something to count, and reads a log of six mocks to tell real progress from a lucky score.
In this part:
- One strength, one gap and one drill per review
- A drill for each dimension, with what to count
- Reading a log of six mocks, repeats included
- Spacing the drills between mocks
- Key takeaways from the review and the drills
1 diagram · 1 runnable example (Python) · about 7 minutes
Opening this part with your pass…Pro part. It opens with the same pass as the part above.
Interview questions
-
Fresher to mid · Warm-up
Why should you score a practice round before you read a sample answer to its prompt?
Because a sample answer changes how you hear your own. Once people know how something turned out, they tend to feel they knew it all along, so after reading a good answer its points sound like ones you made or were about to make, and you score yourself too high. Score first, from the recording and against written descriptions, so that each score rests on what you actually said. Then read the sample to find what your answer lacked, and turn the biggest gap into the next drill.
-
Fresher to mid
Your last three self-mocks ran out of time before the deep dives. The recordings show 11 to 13 minutes on requirements and about 15 on the diagram. What do you change before the next mock, and how will the next recording show whether it worked?
-
Mid to senior
You scored your self-mock 3, 3, 3 and 3, which meets the senior bar. A friend scored the same recording 3, 2, 2 and 3. How do you settle the difference, and what does it tell you about your next drill?
-
Mid to senior
Real interviewers interrupt and steer; in a self-mock nobody does. How do you practise being steered on your own, and how do you tell from the recording whether you handled a steer well?
Key takeaways
- A self-mock is a 45-minute round on your own: a new prompt, seven timed steps, spoken aloud and recorded.
- Interruption cards, assumptions said aloud and a recording stand in for the interviewer you do not have.
- Score from the recording before you read any sample answer, and leave with one strength, one gap and one drill.
- New prompts measure readiness; the same prompt repeated shows only whether a drill worked.
References
- Architectural Decision Records (motivation and definitions) (ADR GitHub organization)
- Flawed Self-Assessment: Implications for Health, Education, and the Workplace (Psychological Science in the Public Interest (PubMed record))
- Hindsight Bias (Perspectives on Psychological Science (PubMed record))
- Deliberate practice and acquisition of expert performance: a general overview (Academic Emergency Medicine (PubMed record))
- Distributed practice in verbal recall tasks: A review and quantitative synthesis (Psychological Bulletin (PubMed record))
Related tools
Report a problem with this lesson
Kept only in this browser. Your Learn progress