You can usually tell in the first 90 seconds of a deep dive whether it will land. The test is simple: is the candidate going deeper on the right component?
The pattern in deep dives that miss
When the deep dive starts, most candidates go deeper on the component they know best. Not the component that's hardest to get right, and not the one the interviewer most wants to probe. The comfortable one.
That's the wrong choice. The deep dive exists to show whether you can reason through the genuinely hard problem at the centre of the question.
WhatsApp: the hard part is delivery under failure, not setting up the WebSocket connection.
Netflix: the hard part is getting popular content to the edge before it's requested, not the storage bucket layout.
Stripe Payments: the hard part is idempotency when the network drops mid-request, not the REST API design.
Uber Dispatch: the hard part is a geo index that keeps up with every driver's location update, not the booking state machine.
If you catch yourself explaining REST conventions during the deep dive, you've drifted to comfortable ground. Move.
Find the hard part before you start
The hard part is usually the one with no obvious standard answer. REST API design has one: follow the conventions. "What happens when 50 million people start the same episode at 9 pm?" doesn't. It needs you to reason about caching at the edge, warming those caches, and what happens on a miss.
Before the deep dive, take 30 seconds and name the three places in your design where the answer isn't obvious. Then pick the hardest.
Watch for one phrase in your own answer: "that's handled by the infrastructure". It's almost always the component the interviewer wants to open up. "The CDN handles it" isn't a design. Which CDN, caching what, warmed how, falling back to what?
How to recover mid-answer
If you realise halfway through that you're deep in the wrong component, stop and say so:
"I've spent time on the API, but the harder problem is delivery when the recipient is offline. Let me go there."
That isn't a sign of confusion. It's the same scoping skill interviewers look for at the start, used again under pressure.
What a deep dive that lands looks like
It has four parts, in this order:
The problem, stated precisely. Not "what if things fail", but "a worker crashes after taking a task and before acknowledging it. The visibility timeout brings the task back, so how long should that timeout be?"
Two or three real options and their costs. Not "add retries", but "fixed-interval retries line every client up to hit the server at the same moment when it recovers; exponential backoff with jitter spreads them out."
A recommendation with a reason. "Exponential backoff from 10 seconds, doubling to a one-hour cap, with about 20% jitter. The cap stops a broken task from retrying forever."
A signal you'd watch. "Alert on dead-letter queue depth growing. That's the first sign the retry policy isn't working."
Problem, options, recommendation, signal. Practise those four on every question until it's automatic.
The deep dive isn't hard because the content is hard. It's hard because it means going to the part you're least sure of and reasoning through it out loud anyway.
Next up
This week's paid walkthrough, Design a Notification System, is a full deep dive on the hard part of a common question: fan-out to push, email and SMS without spamming anyone twice. Next Sunday: the mock interview mistakes that are easiest to see from the outside.


"The CDN handles it" isn't a design. This is the single most common miss I see when candidates walk through their answers. Naming the three non-obvious parts of your design before the deep dive is great advice, because it forces you to find the hard part instead of defaulting to the comfortable one. It's the same way we frame deep dives in Grokking the System Design Interview: the interviewer is grading how you handle the hardest component, not how complete your box diagram looks.