Guide: Last-Minute System Design Review Checklist

Who this is for

A senior engineer with a system design interview tomorrow or the day after. You’ve done some prep — maybe two months, maybe two weeks, maybe two weekends. You’re now staring at the calendar trying to decide what to do with the remaining 8–24 hours of useful study time. You’re tempted to open a new pattern (Bigtable! consensus algorithms! the Raft paper!) and you suspect this might be a bad idea.

It is. This guide is the structure for the last 24 hours, calibrated to the senior+ bar where the round is about demonstrated judgment, not memorized patterns.

The core insight

Most last-minute system design prep is counterproductive — and not in the soft “you should rest more” sense. In the adding-information-now-actively-hurts-tomorrow sense.

Three reasons cramming fails for system design specifically:

1. Patterns intake at T-24 lands shallow. The information goes into a fragile working-memory state, not into the procedural knowledge that survives social pressure. In the room, you’ll reach for the well-rehearsed patterns; the ones you read last night won’t be retrievable.
2. Confidence is a load-bearing signal at senior level. The round is being scored on how you reason, not just what you know. Cramming creates more hesitation, not less, because the half-remembered pattern competes with the well-known one.
3. Energy depletion outweighs marginal information. A 5-hour study session at T-24 trades approximately 4% knowledge gain for 20% loop-day depletion. (See Managing Energy During Interview Loops for the energy-budget model.) The trade is bad.

The reframe: the last 24 hours are retrieval practice and taper, not study. You’re not loading new patterns; you’re warming the patterns you have. The checklist below is what that actually looks like.

The 24-hour checklist

The day-before window splits into four blocks. Each block has a defined purpose and a hard time budget. Discipline matters more than volume.

Block 1 (60–90 min): Re-read your three strongest walkthroughs

Pick three system design topics you know cold — your best three, not your weakest. Re-read each at the level of the diagram and the three or four design decisions, not the full piece. The goal is to refresh the shape of a walkthrough in your head: how to move from clarifying questions → estimation → high-level design → deep dives → tradeoffs.

Good candidates for the three:

• One read-heavy system (news feed, search, recommendations)
• One write-heavy system (chat, notification, ad-click aggregation)
• One stateful system (rate limiter, distributed cache, URL shortener)

The point of three is coverage of motion, not coverage of topics. Three different shapes refresh three different reasoning patterns. Reading five articles in this block undoes the benefit — the brain needs depth, not breadth, in the warm-up.

For each walkthrough, recite out loud (or write down) in 60 seconds what the clarifying questions were and why. This is the most load-bearing part of the round and the most under-rehearsed.

Block 2 (45–60 min): Run one full mock — solo, with a timer

Pick a topic you’ve designed before and run a 45-minute mock yourself. Stand at a whiteboard or open a virtual whiteboard. Talk out loud as if the interviewer were there. Set a timer.

The structure to hit, per Designing an Ad Click Aggregation System:

The point is not to produce a perfect design. The point is to re-execute the motion of running the round on a clock. You will notice where you stall, where you over-elaborate, where you skip estimation, where you forget tradeoffs. Those notes are the most useful information you’ll generate in the last 24 hours.

The mock is a do-once exercise. Don’t run two mocks. The second one’s depletion outweighs its information.

Block 3 (30–45 min): Drill the four moves you keep forgetting

By T-24, you know which moves you don’t run reliably. Pick four and drill them — short, focused, repeated.

Common candidates:

• Estimation. Run capacity math out loud, in your head, on three different prompts (“100M DAU, 5 posts each, 20 reads/post” → produce QPS, storage, bandwidth). Most candidates skip estimation under pressure; drilling makes it automatic.
• The clarifying-questions opener. Recite five questions you’d ask for an unfamiliar prompt. (“What’s the read-write ratio? What’s the latency bar? What’s the consistency requirement? Single region or multi? What’s the auth model?”) Make these the spine of how you start every round, regardless of topic.
• The “tell me how this fails” pivot. For two systems you know, rehearse 60 seconds on failure modes — what breaks, how you detect it, how you recover. Most candidates lose 15% of the round here.
• The “scale this 10x” move. Pick one system and walk through what changes at 10x load. Which component bottlenecks first? What’s the cheapest mitigation? What’s the expensive one? Senior+ rounds always probe this.

Each drill is 5–10 minutes. Don’t try to drill everything; pick the four that match your weak surfaces. The senior calibration penalty for missing one of these moves is high, and the moves are fully drillable.

Block 4 (15–20 min): Assemble your “in-room cheat sheet”

Not literally a cheat sheet you bring in — a mental one. Write out, on one side of one page:

• Your default clarifying questions (5–7 of them, copy from block 3).
• Your back-of-envelope multipliers (1B reqs/day ≈ 12K QPS, 1KB × 1B = 1TB, 1ms RTT in-region, 30ms cross-region, 100MB/s per disk write — five or six numbers, no more).
• Your three default tradeoffs to surface in any round (consistency vs. availability, batch vs. stream, push vs. pull).
• Your three default failure modes (what breaks under load, what breaks under partition, what breaks during deploy).

The page is not for memorizing — it’s for consolidating. Writing it forces you to encode the knowledge into a mental script you’ll actually retrieve under pressure. Throw the page away after writing it. The encoding happened during the writing.

This block is non-negotiable. It’s the highest-leverage 20 minutes of the entire 24-hour window. Most candidates skip it because it feels too compressed to matter. The candidates who don’t skip it walk into the room with five rehearsed openings and three rehearsed closings; the ones who do skip it improvise both, badly.

What not to do in the last 24 hours

Equally important. Each of these is a common move that actively costs points.

Don’t open a new system design topic

If you haven’t done a Vector Database walkthrough by T-24, you’re not going to do one well in the round. Reading the walkthrough the night before will give you the illusion of preparation without the procedural memory to retrieve it. If the round draws that topic, you’ll produce a half-remembered version that lands worse than honest “I’d reason about this from first principles — let me ask some clarifying questions”. Trust your existing patterns.

Don’t run a full mock with a real partner

A real mock at T-24 generates two kinds of feedback: things you can fix in 24 hours (a few), and things you can’t (most). The unfixable feedback creates anxiety that costs more than the fixable feedback recovers. Save the partner mock for T-7 or earlier.

(Solo mocks are different — they generate self-observation, not external judgment, and the cognitive cost is lower.)

Don’t read the Raft paper, the Dynamo paper, or any other paper for the first time

This is the canonical T-24 panic move and it’s almost always a mistake. Foundational papers are useful at T-30 days; they’re counterproductive at T-1. The vocabulary loads but the understanding doesn’t, and you’ll feel pressure to use the new vocabulary in the round in ways that don’t fit.

(Re-reading a paper you’ve already read closely, on the other hand, is fine — it’s retrieval practice for an existing schema.)

Don’t memorize numbers you don’t already know

Latency tables, durability multipliers, AWS service tier limits — candidates love memorizing these the night before. They’re high-information, look impressive, and signal preparation. They also sit in fragile working memory and won’t survive the room. The 5–6 numbers from block 4 are the right number; 30 numbers loaded the night before is overload.

Don’t watch system design videos for “review”

Watching is passive. You feel productive; you’re not. Reading is better; doing the mock is best. If you have an hour and a video is the only option, skip the hour entirely.

Don’t drink alcohol or use sleep aids you haven’t tested

Sleep is the highest-leverage resource for tomorrow’s loop, and both the wine and the unfamiliar melatonin dose are common last-minute mistakes. If you’ve used a specific sleep aid before and it works for you, fine. If it’s new at T-24, it’s a coin flip on next-day cognitive function. Don’t gamble.

What to do the morning of the loop

The morning has four jobs and they all matter.

1. Eat protein and fat, not carbs. A blood sugar spike at 8am crashes at 9:30am — right when round 1 begins. Eggs, nuts, cheese. The caffeine is fine if you’re a regular drinker; not the day to discover coffee.

2. Re-read your one-page cheat sheet from block 4 — not the originals, just the consolidated page you wrote. 5 minutes. If you threw it away, write it again. The act of re-encoding is the prep.

3. Run your clarifying-questions opener out loud, twice. Once for a read-heavy system, once for a write-heavy. The verbal warm-up is real. The brain primes the retrieval pathway you’ll use in the room.

4. Skip last-minute new content. The morning is taper, not prep. The temptation to “just look over” something is the strongest at this exact moment; it’s also the most expensive.

In-round, do not improvise the structure. Run the same six-step shape every time:

1. Clarifying questions (5 min)
2. Functional + non-functional requirements (5 min)
3. Estimation (3 min) — only the numbers that drive design
4. High-level design + diagram (10–12 min)
5. Deep dives, interviewer-led (15–20 min)
6. Tradeoffs and extensions (5 min)

Same shape every round. Senior calibration rewards the structure you can repeat over the design you can produce. The 12 minutes you spend on clarifying questions and estimation are not “filler” — they’re the part of the round where most senior calibration actually happens.

Common failure modes in the final 24 hours

Cramming because you “feel unprepared.” The feeling is not diagnostic. By T-24, your knowledge state is what it is. Cramming adds a thin layer that won’t survive contact with the room while costing you the energy and sleep that would have helped. The discipline is to trust the prep you’ve done.

Studying instead of sleeping. Sleep before a senior loop is worth ~10 percentage points of in-round performance. Studying at the cost of sleep loses on the trade. If it’s 11pm and you’re choosing between one more topic and going to bed, go to bed.

Reviewing topics you’re already strong on, ignoring the moves you’re weak on. Studying news-feed-design for the eighth time because it feels comfortable is a procrastination move dressed as prep. The block 3 drills target the moves you don’t run reliably; that’s where the points are.

Walking into the room without a rehearsed opener. The first five minutes of the round set the tone for calibration. The candidate who opens with five rehearsed clarifying questions and a deliberate pause to write them down looks like a senior; the candidate who improvises looks like a first-year mid-level. The opener is fully drillable in 20 minutes; not drilling it is leaving points on the table.

Treating the round as a test instead of a conversation. Senior rounds are graded on how you reason — the conversation is the artifact. If you’re trying to produce a system design, you’re working too hard. The job is to think out loud about a system design with a peer. That mental frame is more valuable than anything you’ll cram in the last 24 hours.

What to do next

If you have 24 hours before the loop:

• Tonight: run blocks 1, 2, and 3 (≈ 3 hours). Sleep at your usual time. Don’t add a fourth block.
• Tomorrow morning: run block 4 + the four-step morning routine (≈ 30 minutes total).
• The afternoon (if the loop is later): one short walk, one re-read of your cheat sheet, no new content.

If you have only the morning of the loop:

• Block 4 (15–20 min) is non-negotiable. Run it before everything else.
• Then run a 30-minute compressed solo mock — clarifying questions through high-level design, no deep dives.
• Then the morning routine. Skip blocks 1–3 entirely.

If you have a week, not a day:

• Spread the four blocks across days T-7 through T-2.
• T-1: light review only — re-read the cheat sheet, walk through one walkthrough you know cold, sleep.
• See Managing Energy During Interview Loops for the full taper.

Related

• Plan: Complete Senior Backend Interview Prep — the multi-week prep plan this checklist tapers off of. If you’re at T-24 and you haven’t been on a plan, the gaps you notice tonight are the gaps to address in your next prep cycle.
• Framework: Thinking About Tradeoffs in System Design — the three default tradeoffs in block 4 are a compressed version of this framework. Re-read the framework if you’re unclear on how to surface tradeoffs in the round.
• Guide: Managing Energy During Interview Loops — the energy-budget model behind the “don’t cram” prescription. The 24-hour checklist is the design-specific application of the taper.