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
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.
| Round | Typical length | What it assesses | Weight at senior / staff |
|---|---|---|---|
| Coding (DSA) | 45 to 60 min | Problem solving, clean correct code, complexity, testing | Gate: must pass; rarely decides the level |
| HLD (system design) | 45 to 60 min | Scoping, architecture, depth, trade-offs, scale and failure | Often the main levelling signal; staff loops may have two |
| LLD / machine coding | 45 to 120 min | Object modelling, patterns, extensibility, working code, concurrency | Common for backend roles at many companies, especially product companies in India |
| Behavioural / leadership | 45 to 60 min | Ownership, conflict, influence, mentoring, delivery under ambiguity | High; at staff it often carries equal weight with design |
| Project or domain deep dive | 45 to 60 min | Real depth on a system you built; judgement; honesty about trade-offs | Sometimes; more common at staff and for specialist roles |
| Hiring manager | 30 to 45 min | Team fit, motivation, scope you have owned | Varies; 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
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.
| Dimension | Mid-level | Senior | Staff |
|---|---|---|---|
| Scope | Designs the boxes asked for | Designs the end-to-end system, including data, APIs, failure and operations | Places the system among others: ownership boundaries, migration path, platform reuse |
| Ambiguity | Waits for requirements or asks many unfocused questions | Asks the few questions that change the design, assumes the rest out loud | Reframes the problem: "the real requirement is X, so Y is out of scope" |
| Depth | Correct at the box level | Implementation depth in 1 to 2 areas (schema, algorithm, protocol) | Depth where the risk is, plus second-order effects (cost, team load, evolution) |
| Trade-offs | Names one option | Compares 2 options with gain, cost and the condition that would flip the choice | Ties trade-offs to business and organisational constraints; knows when to defer a decision |
| Driving | Follows the interviewer | Drives the agenda, checkpoints, manages time | Drives and adapts; treats the interviewer as a stakeholder |
| Failure and ops | Mentions replication | Detection, blast radius, degradation, recovery, rollout | SLOs, 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
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.
- 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
| Dimension | What "strong" looks like | Commonest way to lose points |
|---|---|---|
| Problem exploration | 3 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 design | A working end-to-end path for every core use case; each box justified by a requirement | Boxes with no data flow; a favourite stack drawn before the requirements |
| Depth in 1 to 2 areas | Schema with keys and indexes, an algorithm, a protocol or a consistency mechanism taken to implementation level | Breadth only: everything mentioned, nothing explained |
| Trade-offs | Two 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 failure | Finds hot keys and SPOFs unprompted; describes degradation and recovery, not only redundancy | "Add more servers" and "replicate it" as the only answers |
| Communication | Signposts ("two parts: write path, then read path"), checkpoints, concise | Monologue for 10 minutes; ignoring the interviewer's hints |
| Estimation | Few numbers, each ending in a design consequence | No numbers at all, or 5 minutes of arithmetic with no conclusion |
| Operational maturity | Metrics and alerts that matter, safe rollout, backfills, migrations, on-call cost | A 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
- 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
- LLD and machine coding, minute by minute
- Driving: assume, checkpoint, propose, deepen
- Trade-off phrasing templates
- "What if this fails?"
- "Scale it 100x"
- Drawing order on the whiteboard
- When you are stuck
- Flowchart: choosing a database
- Flowchart: sync vs async, queue vs stream
HLD round, minute by minute
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 min | 60 min | You drive | Checkpoint with the interviewer |
|---|---|---|---|
| 0 to 5 | 0 to 6 | Requirements and out-of-scope list | "These are the core use cases; anything you want added or dropped?" |
| 5 to 9 | 6 to 10 | Scale numbers, one design consequence | "So it is read-heavy at about 50k reads/s; I'll optimise for that." |
| 9 to 15 | 10 to 17 | API and data model, briefly | "Good enough to move to the architecture?" |
| 15 to 25 | 17 to 30 | Diagram; walk the write path then the read path | "This works end to end. Where would you like me to go deep?" |
| 25 to 37 | 30 to 48 | One deep dive (two in 60 min) | "I'd pick X because it is the riskiest part; or would you prefer Y?" |
| 37 to 42 | 48 to 56 | Failures, hot spots, scale-up | "Let me walk through what breaks first." |
| 42 to 45 | 56 to 60 | Recap against requirements; next steps | Leave the last 2 to 3 minutes for their questions if they ask. |
LLD and machine coding, minute by minute
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 min | Machine coding 90 min | Do | Avoid |
|---|---|---|---|
| 0 to 5 | 0 to 8 | Requirements, actors, use cases; agree the 3 to 4 that must work | Building every feature in the prompt |
| 5 to 15 | 8 to 20 | Entities, relationships, interfaces; name the 1 to 2 patterns and why | Patterns for their own sake |
| 15 to 35 | 20 to 65 | Core classes and the main flow; code the happy path end to end first | Perfecting one class while the flow does not run |
| 35 to 40 | 65 to 75 | Edge cases, validation, concurrency (locks, atomic updates) | Ignoring two users booking the same seat |
| 40 to 45 | 75 to 90 | Demo or walkthrough; show one extension needs a new class, not edits | Leaving no time to run 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
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.
- 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
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.
| Situation | Template | Example |
|---|---|---|
| Making a choice | I'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 option | Y 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 simple | Start 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." |
| Uncertainty | It 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 split | For operation 1, X; for operation 2, Y. | "Seat reservation is strongly consistent; seat-map browsing is cached and may lag a few seconds." |
| Accepting pushback | Good 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 position | I 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?"
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.
| Component lost | A strong first answer |
|---|---|
| Cache cluster | Database sees the full read load: protect it with request coalescing, rate limits and a warm-up path; serve stale where allowed |
| Primary database | Promote 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 broker | Producers buffer or fail fast; replicated broker keeps acknowledged messages; consumers are idempotent so redelivery is safe |
| Downstream dependency | Timeout, bounded retries with jitter, circuit breaker, fallback response; never let it exhaust your threads |
| Whole availability zone | Instances spread over 3 AZs with headroom to lose one; quorum stores keep a majority |
| A bad deploy | Canary, automatic rollback on error-rate SLO breach, feature flag to switch off |
"Scale it 100x"
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.
| Multiplier | What usually breaks | Typical change |
|---|---|---|
| 10x | App CPU, database reads, connection counts | More stateless instances, replicas, a cache, connection pooling |
| 100x | Database writes and size, hot keys, fan-out cost, single-broker throughput | Sharding, hot-key splitting, async fan-out, partitioned streams, precomputation |
| 1000x | One region, cost, operational toil, global coordination | Multi-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
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.
- Clients and edge, services, stores: the minimum end-to-end path.
- Trace the write path with arrows, then the read path; label arrows with the call, not with protocol trivia.
- Add queues and workers for anything the user does not wait for.
- Add caches and replicas where your numbers said reads dominate.
- 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
Silence is the expensive part, not being stuck. Narrate and fall back to something that is known to work.
- "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
Start from the access pattern and the invariants, never from the product. Comparison detail is in Data Systems.
- 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
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.
| Work queue (RabbitMQ / SQS-like) | Log / stream (Kafka-like) | |
|---|---|---|
| Message after consumption | Deleted once acknowledged | Retained for a period; consumers track offsets |
| Consumers | Competing workers share the work | Many independent consumer groups each see everything |
| Ordering | Weak or per-group (FIFO variants) | Strict within a partition |
| Good for | Jobs, emails, retries with delay, dead-lettering | Event 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
HLD questions
| Question | What it is really testing | Worked on |
|---|---|---|
| URL shortener | Key generation without collisions; read-heavy caching; redirect latency | HLD Cases: Core |
| Rate limiter | Algorithm choice (token bucket, sliding window); atomic counters in a shared store; fail-open vs fail-closed | HLD Cases: Core |
| Key-value store | Partitioning with consistent hashing; replication and quorums; failure detection and repair | HLD Cases: Core |
| Unique ID generator | Coordination-free uniqueness; time ordering; clock skew | HLD Cases: Core |
| Notification system | Fan-out through queues; per-channel providers and retries; dedup and user preferences | HLD Cases: Core |
| News feed | Fan-out on write vs read; celebrity hybrid; feed storage and ranking hook | HLD Cases: Core |
| Chat / messaging | Stateful connection gateways; per-conversation ordering; delivery receipts and offline sync | HLD Cases: Core |
| Typeahead / autocomplete | Prefix structures and precomputed top-k; update pipeline; latency at the edge | HLD Cases: Core |
| Payment system / wallet | Idempotency; double-entry ledger; reconciliation and exactly-once effects across external providers | HLD Cases: Advanced |
| Ticket booking | Contention on the same seat; holds with expiry; fairness under flash-sale load | HLD Cases: Advanced |
| Ride hailing | Geo indexing of moving objects; high-rate location writes; matching and trip state machine | HLD Cases: Advanced |
| Video streaming | Upload and transcoding pipeline; adaptive bitrate; CDN cost and placement | HLD Cases: Advanced |
| File sync (Dropbox-like) | Chunking and dedup; metadata vs blob separation; conflict handling across devices | HLD Cases: Advanced |
| Web crawler | URL frontier with politeness; dedup at scale; fault-tolerant distributed workers | HLD Cases: Advanced |
| Distributed job scheduler | Exactly-once triggering in practice (leases, idempotent jobs); time-bucketed storage; retries | HLD Cases: Advanced |
| Metrics / ad-click aggregation | Stream windowing and late events; pre-aggregation; reconciliation with a batch path | HLD 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 | What it is really testing | Worked on |
|---|---|---|
| Parking lot | Entity modelling; strategy for spot allocation and pricing; concurrent allocation | LLD Case Studies |
| LRU cache | Hash map plus doubly linked list for O(1); thread safety; eviction policy as an interface | LLD Case Studies |
| Elevator | State machine per car; scheduling strategy; handling concurrent requests | LLD Case Studies |
| Vending machine | State pattern; invalid transitions; money handling and refunds | LLD Case Studies |
| Splitwise | Split strategies (equal, exact, percent); balance simplification; money as integers | LLD Case Studies |
| Movie ticket booking | Seat locking with expiry; avoiding double booking; booking state transitions | LLD Case Studies |
| Rate limiter library | Pluggable algorithms behind one interface; per-key state; thread-safe counters and time source injection | LLD Case Studies |
| Logging framework | Chain of responsibility for levels; pluggable sinks and formatters; async buffering | LLD Case Studies |
| Tic-tac-toe / snake and ladder | Clean game loop; O(1) win check; extensible rules and players | LLD Case Studies |
| In-memory pub-sub | Observer; per-subscriber offsets; delivery on separate threads without blocking publishers | LLD Case Studies |
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.
How to steer
- 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
| Mistake | What it looks like | Why experienced people do it | Fix |
|---|---|---|---|
| Jumping to a favourite stack | "Kafka, Cassandra, Redis" drawn before requirements | It is what worked at their company | Requirements and access patterns first; name the product only after the property you need |
| Over-engineering | Microservices, multi-region and sharding for 1k QPS | Wanting to show breadth | Start 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 work | Two or three numbers, each ending in a consequence |
| Ignoring failure and operations | Happy path only; no metrics, rollout or migration | Treating it as a whiteboard puzzle | Reserve 5 minutes; use the failure sequence |
| Monologuing | 10 minutes of talk without a question | Used to presenting to their own team | Checkpoint every 5 to 8 minutes; watch for hints |
| Not prioritising | Equal time on login, profile and the hard part | Completeness habits from real projects | Name the hard part out loud and spend the time there |
| Arguing on pushback | Defending a choice the interviewer has broken | Seniority pride | "Good point; that changes X, so I'd do Y" |
| Hand-waving in the deep dive | "We'd use consistent hashing" with no detail | Knowing the term, not the mechanism | Explain one level deeper than the buzzword: virtual nodes, rebalancing, what moves |
The component filter
Before adding any box, run it through two questions. This single habit fixes both over-engineering and favourite-stack answers.
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.
| Beat | Say | Time |
|---|---|---|
| Context | Business problem, users, scale, team size, your role | 1 min |
| Constraints | Latency, consistency, deadline, legacy, budget, team skills | 1 min |
| Your decisions | 2 to 3 decisions you drove, with the alternatives you rejected; use "I" for yours, "we" for the team's | 3 min |
| Trade-offs | What each decision cost, and how you mitigated it | 2 min |
| Outcome | Measured results: p99, cost, incidents, adoption, delivery date | 1 min |
| What you would change | One or two honest corrections and why | 1 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.
- 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
| Letter | Content | Share of the answer | Senior twist |
|---|---|---|---|
| S: Situation | Context in two sentences | About 10% | Make the stakes clear: who was affected, how much |
| T: Task | Your responsibility | About 10% | Show you took it on, not that it was assigned |
| A: Action | What you did, step by step | About 60% | Influence, trade-offs, how you brought others along |
| R: Result | Measured outcome | About 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.
| Theme | Typical prompt | What 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
| Week | Pages | Practice | Done when |
|---|---|---|---|
| 1 | 1 Foundations, 2 Building Blocks | Estimation drills; draw the scaling steps from memory | You can size any prompt in 4 minutes |
| 2 | 3 Data Systems, 4 Distributed Systems Patterns | For 5 products, pick a store and a shard key and defend them | You can explain replication, quorums and idempotency without notes |
| 3 | 5 API Design, 6 Architecture Styles, 7 Reliability | Write the API for 3 systems; answer "what if this fails" for each component | Failure answers follow the six-step order |
| 4 | 8 HLD Cases: Core, 10 Low-Level Design | 4 timed HLDs (45 min each); 2 class diagrams | End-to-end design by minute 25, every time |
| 5 | 9 HLD Cases: Advanced, 11 LLD Cases | 4 timed HLDs; 2 machine-coding rounds with running code in 90 min | Code runs and extends cleanly within the time |
| 6 | 12 this page; revisit weak pages | 3 to 4 mock interviews with a peer; project deep dive rehearsed out loud; stories mapped | Mock 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
- 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
One page to read before the round. Full number tables are in System Design Foundations.
| Topic | Remember |
|---|---|
| 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 control | Assume out loud, propose, checkpoint every 5 to 8 min, offer two deep-dive options, reserve 5 min for failures |
| Trade-off sentence | I'd choose X because ..., the cost is ..., I'd revisit if ... |
| Failure answer | Detect, blast radius, degrade, recover, data loss, prevent |
| Scale 100x | Multiply numbers, first limit, fix, repeat; mention cost; say what stays the same |
| Database | Invariants: SQL (shard or distributed SQL when outgrown). Else by access pattern: KV / wide-column, document, search, time-series, object storage |
| Async | Sync only if the caller must wait; queue for tasks; stream for many consumers, replay, per-key order |
| Read-heavy | Cache, replicas, CDN, precomputed read models |
| Write-heavy | Append, batch, partition, LSM, backpressure |
| Correctness | Idempotency keys, outbox, ledger, sagas, reconciliation |
| LLD | Use cases, entities, interfaces, happy path running, edge cases and locks, extension demo |
| Behavioural | STAR, 60% action, numbers in the result, what you would change |
| Avoid | Favourite 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.