System Design Interview Structure for Senior+ Engineers

The five sections that score

A 45-minute system design round breaks into five sections: clarifying questions (5 min), functional and non-functional requirements (5 min), high-level design (10 min), drill-down on one bottleneck (15 min), and scale or extension discussion (10 min). The interviewer is grading each section separately; skipping any of them costs you.

Most candidates spend 25 minutes on high-level design and rush the rest. The bar for senior+ levels is the drill-down: the interviewer wants to see you pick a real bottleneck and reason about it in detail. The high-level is the setup for the drill-down, not the main event.

Section 1 — Clarifying questions (5 min)

The most common failure mode is starting to draw boxes before you have scoped the problem. Senior engineers earn the round in the first three minutes by anchoring scope: what are we building, for whom, at what scale, under what constraints.

Useful clarifying questions: 'Read-heavy or write-heavy?' 'What is the expected request rate at launch and at 100x scale?' 'Do we need strong consistency or is eventual fine?' 'Is this user-facing latency-sensitive or a batch pipeline?' 'What is the durability requirement — can we lose 1% of writes during a regional outage?'

Two to four clarifying questions is the right number. More than that and you are stalling; fewer and you are guessing.

Section 2 — Functional and non-functional requirements (5 min)

Out loud, list the functional requirements (what the system does) and the non-functional requirements (how well it does it). Functional: 'users can post, follow, see a feed.' Non-functional: 'p99 latency under 200ms for feed read, 99.95% availability, durability sufficient that we never lose a post.'

The NFRs are what drive the design. A 'feed system' with no latency target can be a Postgres query; a 'feed system at 100K reads/sec with p99 under 100ms' is a different architecture entirely. Make the targets explicit so the interviewer agrees with your design constraints.

Section 3 — High-level design (10 min)

Now draw boxes. Client → load balancer → app servers → cache → primary database → async queue → workers → secondary store as needed. Talk through each box: what it does, what it talks to, what it is the bottleneck for. Keep it shallow.

Resist the urge to go deep on any one component in this section. The interviewer will pick the component to drill into; you are setting up the menu. If you go deep on caching here, you may not get to talk about the queue, and the interviewer wanted to talk about the queue.

Section 4 — Drill-down on one bottleneck (15 min)

The interviewer picks a component and asks you to go deep. This is the section that separates senior from staff: the depth and specificity of your reasoning here is what you are being graded on.

For a write-heavy feed system, drill into the queue: which queue (Kafka, SQS, Pub/Sub), partitioning strategy, consumer model, dead-letter handling, exactly-once vs at-least-once semantics, what happens during a consumer outage. Name specific technologies; explain why you would pick one over another in this context.

Talk about tradeoffs explicitly. 'I'd pick Kafka here because partitions give us ordered processing per user, but the operational cost is higher than SQS — if the team is small I'd start with SQS and migrate when partition-ordering becomes load-bearing.' That sentence is the kind of reasoning staff interviewers are looking for.

Section 5 — Scale or extension (10 min)

The interviewer extends the scenario: '10x the traffic,' 'add international users,' 'support delete-with-tombstone for GDPR.' Walk through which parts of your design break first, in what order, and what you would change.

Show the order of bottlenecks: cache hit rate degrades, then DB connections saturate, then the queue fanout costs spike. Naming the order is the senior-vs-staff distinction; both can name the bottlenecks, but staff can predict which one fires first.

Time budget you should actually run

Minutes 0-5: clarifying questions. Minutes 5-10: functional + NFR. Minutes 10-20: high-level design. Minutes 20-35: drill-down. Minutes 35-45: scale + wrap. If you find yourself at minute 25 still on high-level, abandon depth and move on; the drill-down is what gets graded.

Keep an eye on the clock visibly. Saying "let me check time — okay, 12 minutes left, let me move to the bottleneck" is a positive signal, not a negative one. It shows you are managing the round actively.

Further reading

• System Design Primer — canonical GitHub reference for system design interviews
• Apple — ScreenCaptureKit framework documentation
• Interview Cheat — open-source desktop app on GitHub