Learnings

System design, part 12 of 12

Senior Interview Playbook

How senior and staff backend loops are usually run and scored, how to drive an HLD or LLD round minute by minute, which questions come up and what each one really tests, where to steer the deep dive, and a six-week plan over this path. The 45-minute framework, estimation tables and core trade-offs are in System Design Foundations; this page assumes them.

How senior loops work

Part 1 of 8 · the rounds and the bar at each level

Loops differ by company and change over time, so treat this as the typical shape and ask your recruiter for the exact list of rounds before you prepare.

Typical loop composition

How senior loops work

A common senior backend loop is one or two screens followed by four to six onsite (or virtual onsite) rounds. Design carries more weight as the level rises: at staff, a weak design round is rarely offset by strong coding.

The onsite rounds are scored independently and merged in a debrief; the level decision is made there, not in any single round.
RoundTypical lengthWhat it assessesWeight at senior / staff
Coding (DSA)45 to 60 minProblem solving, clean correct code, complexity, testingGate: must pass; rarely decides the level
HLD (system design)45 to 60 minScoping, architecture, depth, trade-offs, scale and failureOften the main levelling signal; staff loops may have two
LLD / machine coding45 to 120 minObject modelling, patterns, extensibility, working code, concurrencyCommon for backend roles at many companies, especially product companies in India
Behavioural / leadership45 to 60 minOwnership, conflict, influence, mentoring, delivery under ambiguityHigh; at staff it often carries equal weight with design
Project or domain deep dive45 to 60 minReal depth on a system you built; judgement; honesty about trade-offsSometimes; more common at staff and for specialist roles
Hiring manager30 to 45 minTeam fit, motivation, scope you have ownedVaries; can include a light design or behavioural part

Interview tip: ask the recruiter three things: which rounds, whether LLD means "class diagram" or "running code", and the target level. Each changes what you practise.

Mid vs senior vs staff

How senior loops work

The same question is asked at every level; the bar moves. The difference is less about knowing more components and more about scope, initiative and judgement.

Each level widens the unit of design: a component, then a whole system with its failure modes, then several systems over time and across teams.
DimensionMid-levelSeniorStaff
ScopeDesigns the boxes asked forDesigns the end-to-end system, including data, APIs, failure and operationsPlaces the system among others: ownership boundaries, migration path, platform reuse
AmbiguityWaits for requirements or asks many unfocused questionsAsks the few questions that change the design, assumes the rest out loudReframes the problem: "the real requirement is X, so Y is out of scope"
DepthCorrect at the box levelImplementation depth in 1 to 2 areas (schema, algorithm, protocol)Depth where the risk is, plus second-order effects (cost, team load, evolution)
Trade-offsNames one optionCompares 2 options with gain, cost and the condition that would flip the choiceTies trade-offs to business and organisational constraints; knows when to defer a decision
DrivingFollows the interviewerDrives the agenda, checkpoints, manages timeDrives and adapts; treats the interviewer as a stakeholder
Failure and opsMentions replicationDetection, blast radius, degradation, recovery, rolloutSLOs, on-call cost, incident history, safe evolution of schemas and APIs

Senior signal: you finish a decision without being asked "why?". The "why", the cost and the alternative come in the same sentence as the choice.

How feedback becomes a decision

How senior loops work

A common process: each interviewer writes notes against a rubric and a hire / no-hire recommendation with a level, then a debrief or hiring committee reads them together. Evidence in the notes counts; impressions do not.

The interviewer can only report what you said or drew. A good idea you did not voice does not exist in the debrief.
  • Consistency matters: four "lean hire at senior" often beats two "strong hire" plus two "no hire".
  • Down-levelling is a common outcome: a pass at senior with staff-level coding but mid-level design scope.
  • Make evidence easy to write down: say the decision, the reason and the cost as one sentence the interviewer can quote.

What interviewers score

Part 2 of 8 · the rubric and how points are lost

Rubrics differ in wording but cover the same eight dimensions. Know them, and make sure each one gets at least one clear piece of evidence during the round.

The design rubric

What interviewers score

DimensionWhat "strong" looks likeCommonest way to lose points
Problem exploration3 to 5 functional and non-functional requirements in 5 minutes; explicit out-of-scope list; asks the one question that changes the design (consistency, scale, latency)Starting to draw at minute 1, or 12 minutes of questions with no decisions
High-level designA working end-to-end path for every core use case; each box justified by a requirementBoxes with no data flow; a favourite stack drawn before the requirements
Depth in 1 to 2 areasSchema with keys and indexes, an algorithm, a protocol or a consistency mechanism taken to implementation levelBreadth only: everything mentioned, nothing explained
Trade-offsTwo options compared on the axis that matters, with the condition that would change the choice"It depends" with no answer, or one option presented as obvious
Scalability and failureFinds hot keys and SPOFs unprompted; describes degradation and recovery, not only redundancy"Add more servers" and "replicate it" as the only answers
CommunicationSignposts ("two parts: write path, then read path"), checkpoints, conciseMonologue for 10 minutes; ignoring the interviewer's hints
EstimationFew numbers, each ending in a design consequenceNo numbers at all, or 5 minutes of arithmetic with no conclusion
Operational maturityMetrics and alerts that matter, safe rollout, backfills, migrations, on-call costA design that cannot be deployed, observed or migrated

Senior signal: operational maturity is where years of experience show most cheaply. One sentence on how you would roll it out and what alert would wake you up is often more convincing than another component.

Where each signal is earned

What interviewers score

Each phase feeds mainly one rubric line. Running out of time before the failure phase leaves a whole dimension empty; communication is scored across all of them.
  • If the interviewer takes over a phase (for example "skip estimates"), that dimension is not lost; say your assumed scale in one sentence and move on.
  • Plan to reach failures and scale with at least 5 minutes left; it is the dimension most often left blank.

Running the session

Part 3 of 8 · time plans, phrasing, follow-ups and decision charts

The step-by-step framework and its outputs are in System Design Foundations. This part is about control: who speaks when, what to check with the interviewer, and how to answer the standard follow-ups.

HLD round, minute by minute

Running the session

The same plan for a 45- and a 60-minute slot. The extra 15 minutes go to a second deep dive and to failures, not to a longer opening. The right-hand column is the checkpoint you say out loud.

45 min60 minYou driveCheckpoint with the interviewer
0 to 50 to 6Requirements and out-of-scope list"These are the core use cases; anything you want added or dropped?"
5 to 96 to 10Scale numbers, one design consequence"So it is read-heavy at about 50k reads/s; I'll optimise for that."
9 to 1510 to 17API and data model, briefly"Good enough to move to the architecture?"
15 to 2517 to 30Diagram; walk the write path then the read path"This works end to end. Where would you like me to go deep?"
25 to 3730 to 48One deep dive (two in 60 min)"I'd pick X because it is the riskiest part; or would you prefer Y?"
37 to 4248 to 56Failures, hot spots, scale-up"Let me walk through what breaks first."
42 to 4556 to 60Recap against requirements; next stepsLeave the last 2 to 3 minutes for their questions if they ask.
Four explicit hand-backs to the interviewer. Between them the candidate drives; the interviewer's replies are where the hints are.

LLD and machine coding, minute by minute

Running the session

Two variants: a 45-minute LLD discussion (class diagram, key methods, maybe pseudo-code) and a 90-minute machine-coding round (running code, often with a demo and an extension). Detail on modelling is in Low-Level Design.

LLD 45 minMachine coding 90 minDoAvoid
0 to 50 to 8Requirements, actors, use cases; agree the 3 to 4 that must workBuilding every feature in the prompt
5 to 158 to 20Entities, relationships, interfaces; name the 1 to 2 patterns and whyPatterns for their own sake
15 to 3520 to 65Core classes and the main flow; code the happy path end to end firstPerfecting one class while the flow does not run
35 to 4065 to 75Edge cases, validation, concurrency (locks, atomic updates)Ignoring two users booking the same seat
40 to 4575 to 90Demo or walkthrough; show one extension needs a new class, not editsLeaving no time to run it
Working code first. If time runs short, skip from the happy path straight to explaining how you would extend it.
  • Keep storage in memory behind a repository interface; say you would swap it for a database.
  • Write a small driver (main or test) early so the code runs at every step.

Driving: assume, checkpoint, propose, deepen

Running the session

Driving means the interviewer never has to ask "what next?". Use the same small loop at every step: state an assumption, propose a concrete option, check in, then deepen or switch.

Each pass through the loop leaves a decision on the board. Pushback is information, not failure: revise or defend with a reason.
  • Assume out loud: "I'll assume 10M DAU and that a few seconds of staleness on counts is fine."
  • Signpost: "Three things to cover: the write path, the read path, then the hot-key problem."
  • Checkpoint briefly: "Does that match what you had in mind?" every 5 to 8 minutes, not after every sentence.
  • Propose, do not ask open questions: "I'd use X. Shall I go on?" beats "What database should I use?".
  • Take hints: a question like "how would this behave if one user had 50M followers?" is a direction, not small talk.

Trade-off phrasing templates

Running the session

The core template: "I'd choose X because ..., the cost is ..., I'd revisit if ...". The third clause is what separates senior from mid-level: it shows you know the boundary of your own decision.

SituationTemplateExample
Making a choiceI'd choose X because R; the cost is C; I'd revisit if T."Fan-out on write, because reads outnumber writes 100:1; the cost is write amplification for big accounts; I'd revisit for users above about 100k followers."
Rejecting an optionY would also work, but it pays C for a benefit we do not need."Multi-leader would give local writes in each region, but we have no regional write requirement, and conflicts are expensive."
Starting simpleStart with X; switch to Y when metric M passes N."One Postgres primary; shard by user_id when writes pass about 5k/s or data passes a few TB."
UncertaintyIt depends on A; if A, then X; otherwise Y. Which is closer?"If balances must never be stale, a leader read; if seconds are fine, a replica. Which do you need?"
Per-operation splitFor operation 1, X; for operation 2, Y."Seat reservation is strongly consistent; seat-map browsing is cached and may lag a few seconds."
Accepting pushbackGood point: that breaks assumption A. Then I'd change to Y, which costs C."Right, ordering per chat matters; I'd partition the stream by chat_id."
Holding a positionI considered that; I still prefer X because R, unless T."I still prefer a queue here because consumers do not need replay, unless we add analytics consumers."

Interview tip: avoid "it depends" as an ending. It is fine as a beginning only if the next words name what it depends on and what you would pick for each case.

"What if this fails?"

Running the session

Answer in a fixed order so nothing is missed: how it is detected, what the blast radius is, what users see, how it recovers, whether data is lost, and how recurrence is prevented. Mechanisms are in Reliability and Operations.

Six steps in one breath. Most candidates stop at "recover"; degradation and data loss are where the senior signal is.
Component lostA strong first answer
Cache clusterDatabase sees the full read load: protect it with request coalescing, rate limits and a warm-up path; serve stale where allowed
Primary databasePromote a replica (seconds to a minute); async replication may lose the last writes; writes fail fast meanwhile; idempotency keys make client retries safe
Queue or brokerProducers buffer or fail fast; replicated broker keeps acknowledged messages; consumers are idempotent so redelivery is safe
Downstream dependencyTimeout, bounded retries with jitter, circuit breaker, fallback response; never let it exhaust your threads
Whole availability zoneInstances spread over 3 AZs with headroom to lose one; quorum stores keep a majority
A bad deployCanary, automatic rollback on error-rate SLO breach, feature flag to switch off

"Scale it 100x"

Running the session

Do not add boxes at random. Multiply the numbers, find the first resource to hit its limit, fix that, and repeat. Say which parts of the design do not change.

An iterative bottleneck hunt. The interviewer is checking that you re-derive limits, not that you know a bigger architecture by heart.
MultiplierWhat usually breaksTypical change
10xApp CPU, database reads, connection countsMore stateless instances, replicas, a cache, connection pooling
100xDatabase writes and size, hot keys, fan-out cost, single-broker throughputSharding, hot-key splitting, async fan-out, partitioned streams, precomputation
1000xOne region, cost, operational toil, global coordinationMulti-region, cell-based architecture, tiered storage, automation; avoid any global lock or counter

Senior signal: mention cost. At 100x, storage and egress bills are often the real constraint, and tiering cold data or compressing is a design change, not an afterthought.

Drawing order on the whiteboard

Running the session

Draw left to right in the order a request travels, then add the asynchronous and caching layers once the basic path works. The board then reads like the walkthrough you give.

Numbers are the order to draw. Client, edge, services and stores first; async and caching only after the synchronous path is traced.
  1. Clients and edge, services, stores: the minimum end-to-end path.
  2. Trace the write path with arrows, then the read path; label arrows with the call, not with protocol trivia.
  3. Add queues and workers for anything the user does not wait for.
  4. Add caches and replicas where your numbers said reads dominate.
  5. Annotate key numbers next to the boxes (QPS, size) and the data model next to the stores.

Interview tip: in a virtual round, use a simple tool you have practised with. Boxes and arrows drawn quickly beat a pretty diagram finished at minute 30.

When you are stuck

Running the session

Silence is the expensive part, not being stuck. Narrate and fall back to something that is known to work.

Fall back to the naive design and improve it. A correct simple version followed by a reasoned improvement scores well.
  • "Let me first do the simple version: one service and one table. Then I'll fix what breaks."
  • "I haven't used X in production; my understanding is ..., which matters here because ..." Honest and still useful.
  • If you made a mistake earlier, say so and correct it. Self-correction is a positive signal.

Flowchart: choosing a database

Running the session

Start from the access pattern and the invariants, never from the product. Comparison detail is in Data Systems.

Transactions and invariants push to SQL first. Search and caches are almost always secondary copies fed from the source of truth, not the source itself.
  • Polyglot is normal: a relational source of truth plus a search index plus a cache, kept in sync through change data capture or events.
  • Say the shard or partition key in the same breath as the store: it is the choice that is hard to undo.

Flowchart: sync vs async, queue vs stream

Running the session

Synchronous only for what the caller must wait for. Behind the async boundary, a work queue distributes tasks; a log or stream keeps an ordered, replayable history for many consumers. Detail in Building Blocks and API and Communication Design.

Two questions decide sync vs async; a third picks queue (task distribution, per-message ack) vs stream (retained log, independent consumer offsets).
 Work queue (RabbitMQ / SQS-like)Log / stream (Kafka-like)
Message after consumptionDeleted once acknowledgedRetained for a period; consumers track offsets
ConsumersCompeting workers share the workMany independent consumer groups each see everything
OrderingWeak or per-group (FIFO variants)Strict within a partition
Good forJobs, emails, retries with delay, dead-letteringEvent sourcing, CDC, analytics fan-out, replay after a bug

Question bank

Part 4 of 8 · the most asked questions and what each really tests

Most questions are one of a handful of core problems wearing a product name. Recognise the core problem and you know where the deep dive will go.

Question families

Question bank

Six families cover nearly all the common HLD prompts. Practise one per family deeply before practising breadth.

HLD questions

Question bank

QuestionWhat it is really testingWorked on
URL shortenerKey generation without collisions; read-heavy caching; redirect latencyHLD Cases: Core
Rate limiterAlgorithm choice (token bucket, sliding window); atomic counters in a shared store; fail-open vs fail-closedHLD Cases: Core
Key-value storePartitioning with consistent hashing; replication and quorums; failure detection and repairHLD Cases: Core
Unique ID generatorCoordination-free uniqueness; time ordering; clock skewHLD Cases: Core
Notification systemFan-out through queues; per-channel providers and retries; dedup and user preferencesHLD Cases: Core
News feedFan-out on write vs read; celebrity hybrid; feed storage and ranking hookHLD Cases: Core
Chat / messagingStateful connection gateways; per-conversation ordering; delivery receipts and offline syncHLD Cases: Core
Typeahead / autocompletePrefix structures and precomputed top-k; update pipeline; latency at the edgeHLD Cases: Core
Payment system / walletIdempotency; double-entry ledger; reconciliation and exactly-once effects across external providersHLD Cases: Advanced
Ticket bookingContention on the same seat; holds with expiry; fairness under flash-sale loadHLD Cases: Advanced
Ride hailingGeo indexing of moving objects; high-rate location writes; matching and trip state machineHLD Cases: Advanced
Video streamingUpload and transcoding pipeline; adaptive bitrate; CDN cost and placementHLD Cases: Advanced
File sync (Dropbox-like)Chunking and dedup; metadata vs blob separation; conflict handling across devicesHLD Cases: Advanced
Web crawlerURL frontier with politeness; dedup at scale; fault-tolerant distributed workersHLD Cases: Advanced
Distributed job schedulerExactly-once triggering in practice (leases, idempotent jobs); time-bucketed storage; retriesHLD Cases: Advanced
Metrics / ad-click aggregationStream windowing and late events; pre-aggregation; reconciliation with a batch pathHLD Cases: Advanced

Interview tip: if you have practised a question, do not recite the remembered answer. Interviewers often change one requirement mid-way precisely to see whether you re-derive.

LLD questions

Question bank

QuestionWhat it is really testingWorked on
Parking lotEntity modelling; strategy for spot allocation and pricing; concurrent allocationLLD Case Studies
LRU cacheHash map plus doubly linked list for O(1); thread safety; eviction policy as an interfaceLLD Case Studies
ElevatorState machine per car; scheduling strategy; handling concurrent requestsLLD Case Studies
Vending machineState pattern; invalid transitions; money handling and refundsLLD Case Studies
SplitwiseSplit strategies (equal, exact, percent); balance simplification; money as integersLLD Case Studies
Movie ticket bookingSeat locking with expiry; avoiding double booking; booking state transitionsLLD Case Studies
Rate limiter libraryPluggable algorithms behind one interface; per-key state; thread-safe counters and time source injectionLLD Case Studies
Logging frameworkChain of responsibility for levels; pluggable sinks and formatters; async bufferingLLD Case Studies
Tic-tac-toe / snake and ladderClean game loop; O(1) win check; extensible rules and playersLLD Case Studies
In-memory pub-subObserver; per-subscriber offsets; delivery on separate threads without blocking publishersLLD Case Studies
Four ideas recur across the LLD bank. Name the one the question hinges on early; it decides your class structure.

Deep-dive menu

Part 5 of 8 · steer the deep dive to ground you know

The interviewer usually lets you propose the deep dive. Offer two options where the system's risk actually lies, with your preferred one first, and make sure it is one you can take to implementation depth.

What to deep-dive, by system type

Deep-dive menu

If the system is ...Steer the deep dive toWhat to showPrepare from
Read-heavyCaching strategy and read modelsCache-aside vs write-through, invalidation, stampede protection, hot keys, precomputed viewsBuilding Blocks
Write-heavyPartitioning and the write pathShard key choice, LSM storage, batching, backpressure, rebalancingData Systems
Real-timeConnection layer and deliveryWebSocket gateways, presence, ordering per conversation, reconnect and catch-upAPI and Communication Design
FinancialCorrectness under failureIdempotency keys, ledger model, transactions or sagas, outbox, reconciliationDistributed Systems Patterns
Geo / locationSpatial index and update rateGeohash or quadtree cells, in-memory location store, sharding by regionData Systems
MediaUpload and delivery pipelinePre-signed uploads, chunking, async transcoding DAG, CDN and storage tieringArchitecture Styles, Building Blocks
SearchIndexing pipeline and query pathInverted index, CDC into the index, sharding and replicas, freshness vs costData Systems
Any, with strict SLOsFailure handling and operationsTimeouts, retries with budgets, circuit breakers, load shedding, rollout and alertingReliability and Operations

Senior signal: pick the area that is genuinely the riskiest for this system, then justify it: "the hard part of a wallet is not throughput, it is never applying a debit twice".

How to steer

Deep-dive menu

Offer a choice you are happy with either way. If they choose the other one, they wanted to probe it; go there without hesitation.
  • Depth checklist for any area: data model and keys, the algorithm or protocol, concurrency, the failure case, one number.
  • Prepare two "home ground" deep dives from your own experience (for example caching and idempotent payments) and practise steering towards them when they fit.

Common mistakes

Part 6 of 8 · the ones experienced candidates make

Experienced engineers rarely fail on knowledge. They fail on habits that work at the job and hurt in a 45-minute round.

Mistakes and their fixes

Common mistakes

MistakeWhat it looks likeWhy experienced people do itFix
Jumping to a favourite stack"Kafka, Cassandra, Redis" drawn before requirementsIt is what worked at their companyRequirements and access patterns first; name the product only after the property you need
Over-engineeringMicroservices, multi-region and sharding for 1k QPSWanting to show breadthStart simple; state the trigger for each upgrade
No numbers"It's a lot of traffic, so we cache"Capacity planning is done by another team at workTwo or three numbers, each ending in a consequence
Ignoring failure and operationsHappy path only; no metrics, rollout or migrationTreating it as a whiteboard puzzleReserve 5 minutes; use the failure sequence
Monologuing10 minutes of talk without a questionUsed to presenting to their own teamCheckpoint every 5 to 8 minutes; watch for hints
Not prioritisingEqual time on login, profile and the hard partCompleteness habits from real projectsName the hard part out loud and spend the time there
Arguing on pushbackDefending a choice the interviewer has brokenSeniority pride"Good point; that changes X, so I'd do Y"
Hand-waving in the deep dive"We'd use consistent hashing" with no detailKnowing the term, not the mechanismExplain one level deeper than the buzzword: virtual nodes, rebalancing, what moves

The component filter

Common mistakes

Before adding any box, run it through two questions. This single habit fixes both over-engineering and favourite-stack answers.

Every box needs a requirement and a number. "Later step with a trigger" is a strong answer in itself.

Project deep dive and behavioural

Part 7 of 8 · your own system and your own stories

These rounds reward preparation more than any other: you choose the material in advance. Prepare one system to present and eight to ten stories.

Presenting your own system

Project deep dive and behavioural

Pick a system where you made the key decisions, it ran in production, and you can discuss what went wrong. Present it in six beats, about 10 minutes, then expect 30 minutes of probing.

The last beat is the one most candidates skip and the one interviewers value most: it shows judgement that outlived the project.
BeatSayTime
ContextBusiness problem, users, scale, team size, your role1 min
ConstraintsLatency, consistency, deadline, legacy, budget, team skills1 min
Your decisions2 to 3 decisions you drove, with the alternatives you rejected; use "I" for yours, "we" for the team's3 min
Trade-offsWhat each decision cost, and how you mitigated it2 min
OutcomeMeasured results: p99, cost, incidents, adoption, delivery date1 min
What you would changeOne or two honest corrections and why1 min

Interview tip: expect "why not X?" for every major decision and "what was the hardest bug or incident?". Prepare answers for both; vagueness here reads as not having owned it.

The one-diagram template

Project deep dive and behavioural

Practise drawing your system in under three minutes, in this shape: your part in the middle, its neighbours around it, and the one change you drove marked.

Draw the boundary of your ownership explicitly. Interviewers probe the edges: contracts with other teams, the external dependency and what happened when it failed.
  • Annotate two or three numbers on it: request rate, data size, latency target.
  • Mark the component you changed and be ready to draw its internals as a second level.
  • Remove anything confidential; describe the shape, not the employer's internal names.

STAR, briefly

Project deep dive and behavioural

LetterContentShare of the answerSenior twist
S: SituationContext in two sentencesAbout 10%Make the stakes clear: who was affected, how much
T: TaskYour responsibilityAbout 10%Show you took it on, not that it was assigned
A: ActionWhat you did, step by stepAbout 60%Influence, trade-offs, how you brought others along
R: ResultMeasured outcomeAbout 20%Numbers, plus what you learned or would do differently

Keep each story to about 2 to 3 minutes and stop; the follow-up questions are where the evaluation happens.

Stories to prepare

Project deep dive and behavioural

One story can cover several themes. Map 8 to 10 stories to this list so each theme has at least one.

ThemeTypical promptWhat they look for
Hardest technical problem"The most complex system you built"Depth, and that you were the one who solved it
Production incident"A time something broke badly"Calm triage, ownership, blameless follow-up, prevention
Disagreement"You disagreed with a peer or manager"Data over opinion; disagree and commit
Influence without authority"You changed another team's direction"Building consensus, writing proposals, patience
Ambiguity"A project with unclear requirements"Framing the problem, reducing risk early
Failure or mistake"A decision that turned out wrong"Honesty, what you changed afterwards
Prioritisation"Too much to do, what did you drop?"Saying no with reasons; impact over activity
Mentoring and raising the bar"How you grew someone or the team"Specific people, specific results
Speed vs quality"You shipped under a hard deadline"Conscious technical debt, with a plan to repay it
Large migration"You moved a system without downtime"Phasing, dual writes or shadow traffic, rollback plan

Study plan

Part 8 of 8 · six weeks over the twelve pages, then the last week

About 8 to 10 hours a week. Reading is less than half of it; the rest is drawing designs against a timer and mock interviews.

The six-week plan

Study plan

Toolkit first (weeks 1 to 3), then case studies with HLD and LLD in parallel (weeks 4 and 5), then rehearsal.
WeekPagesPracticeDone when
11 Foundations, 2 Building BlocksEstimation drills; draw the scaling steps from memoryYou can size any prompt in 4 minutes
23 Data Systems, 4 Distributed Systems PatternsFor 5 products, pick a store and a shard key and defend themYou can explain replication, quorums and idempotency without notes
35 API Design, 6 Architecture Styles, 7 ReliabilityWrite the API for 3 systems; answer "what if this fails" for each componentFailure answers follow the six-step order
48 HLD Cases: Core, 10 Low-Level Design4 timed HLDs (45 min each); 2 class diagramsEnd-to-end design by minute 25, every time
59 HLD Cases: Advanced, 11 LLD Cases4 timed HLDs; 2 machine-coding rounds with running code in 90 minCode runs and extends cleanly within the time
612 this page; revisit weak pages3 to 4 mock interviews with a peer; project deep dive rehearsed out loud; stories mappedMock feedback has no new themes

Interview tip: record one mock (with permission) and watch it. Monologues, missing checkpoints and unexplained boxes are obvious on replay and invisible in the moment.

Final-week checklist

Study plan

  • Rounds, lengths and level confirmed with the recruiter; LLD format (diagram or running code) known.
  • Drawing tool chosen and practised; for machine coding, IDE and language set up with a project template that runs.
  • One timed HLD per day, a different family each day (question families).
  • The trade-off template and the failure sequence said out loud until automatic.
  • Project deep dive: one diagram, six beats, two "why not X" answers, one incident.
  • 8 to 10 STAR stories mapped to the themes; each under 3 minutes.
  • Key numbers from Foundations reviewed once; no new topics after two days before.
  • Questions for each interviewer prepared (team, on-call, how design decisions get made).

Cheat sheet

Study plan

One page to read before the round. Full number tables are in System Design Foundations.

TopicRemember
Numbers (approx.)Day = 10^5 s; 1M/day = about 10/s; RAM 100 ns, SSD 100 us, DC hop 0.5 ms, cross-continent 100+ ms; app node about 1k rps, SQL about 10k reads/s, Redis-like about 100k ops/s; 99.99% = 53 min/year
Session controlAssume out loud, propose, checkpoint every 5 to 8 min, offer two deep-dive options, reserve 5 min for failures
Trade-off sentenceI'd choose X because ..., the cost is ..., I'd revisit if ...
Failure answerDetect, blast radius, degrade, recover, data loss, prevent
Scale 100xMultiply numbers, first limit, fix, repeat; mention cost; say what stays the same
DatabaseInvariants: SQL (shard or distributed SQL when outgrown). Else by access pattern: KV / wide-column, document, search, time-series, object storage
AsyncSync only if the caller must wait; queue for tasks; stream for many consumers, replay, per-key order
Read-heavyCache, replicas, CDN, precomputed read models
Write-heavyAppend, batch, partition, LSM, backpressure
CorrectnessIdempotency keys, outbox, ledger, sagas, reconciliation
LLDUse cases, entities, interfaces, happy path running, edge cases and locks, extension demo
BehaviouralSTAR, 60% action, numbers in the result, what you would change
AvoidFavourite stack first, over-engineering, no numbers, no failures, monologue, equal time on everything

That is the end of the path: start again from System Design Foundations or return to the System Design index.