Naming the bottleneck first
Saying which limit makes a system hard (a hot key, a fan-out, a lock, a single writer) before naming the component that relieves it. It shows that each piece of your design answers a specific problem.
What it is
A bottleneck is the place where ordinary components stop being enough: a key that a large share of traffic hits, a write that becomes millions of writes, a lock or a single writer that each request passes through. Naming it first means saying where that place is and why, in terms of load or contention, before you name the cache, queue or shard that relieves it. Meta's guide to its engineering interviews advises finding the interesting and hard problems and focusing the discussion on them, since there isn't time to cover each detail of a design, and says that anticipating the typical problems of large systems is part of what the interviewer is trying to learn about you.
| Limit | What it looks like | Clue in the requirements | Usual relief |
|---|---|---|---|
Hot key or hot partition | One key or partition takes a share of traffic out of proportion to the rest. In DynamoDB, a partition key that doesn't spread requests produces hot partitions, which are throttled when their traffic passes what one partition can take; AWS's example is a key made from the creation date, so a whole day's writes land on one key value. | A celebrity, a date or status field used as a key, a counter many users increment | Spread the key across more values, cache the hot item, or absorb the writes in memory and flush |
Fan-out | One action produces work for many recipients: a post, a message to a large group, a mailing list with a long recipient list. The cost grows with the audience, not with the sender's effort. | Followers, group members, subscribers, broadcast | Precompute for the common case, handle the heaviest senders differently |
Lock or single writer | The design routes requests that need ordering or uniqueness through one place, so throughput there is bounded by how fast that one place can process them. | "Exactly once", strict ordering, a shared counter, a single row for an item's stock | Partition the thing being ordered, use optimistic checks, or size for the limit and say so |
Exhausted server resource | A server runs out of CPU, memory, threads or file descriptors, and the SRE book lists each with its own symptoms: slower requests, dying tasks, failed health checks. | A single service on the path of each request, a tier with little headroom | Load test to learn which resource goes first, then shed load before that point |
Why the order matters. A component named without the limit it answers reads as a pattern you remembered rather than a decision you made. The same cache is designed differently depending on whether it relieves read volume, a single hot item or tail latency: the key it uses and what happens on a miss depend on which limit it answers. A good solution is judged on how it compares approaches and reasons about their trade-offs, and the limit is what that reasoning is about. Say it, and the component's design has something to be judged against.
What breaks first is a prediction, so present it as one. The Google SRE book's chapter on cascading failures says that without a realistic load test it's hard to know which resource will run out first or how that will show up. Its example chain starts with a frontend whose garbage collection eats CPU; requests slow, in-flight requests hold more memory, the cache shrinks, misses rise, and a backend further down the chain runs out of CPU or threads and fails its health checks. If you have no load test to point to in the round, give the prediction with its reason: "the first place I'd expect to saturate is X, because it sees all of Y; a load test would confirm that."
When to use it
Use it at the moment you move from requirements and estimates to the drawing. Once the numbers are on the board, say which of them a plain design would struggle with and where, then let that drive which part of the diagram gets the time. Meta's guide suggests this ordering: start with requirements such as how many people, how many messages sent and read, and the latency the delivery path needs, then focus on the hard problems those numbers expose.
Use it again when the interviewer asks what happens at ten times the load. Capacity belongs to each component, and the one that passes its breaking point first can pull the rest down: the SRE book's example has a cluster that handles 1,000 requests per second taking on a failed neighbor's traffic, reaching 1,200, and then doing less useful work than before as it runs out of resources. So the question is about headroom relative to the load each component receives, and the biggest box on the diagram isn't automatically the answer.
What a stronger answer adds, in rough order: a reason for each component; the limit, with a number, stated before the component; the component's design (its key, how long entries live, how it's partitioned) tied to that limit; what breaks next at ten times the load; and finally, the limit separated from its symptoms, with the measurement that would confirm the prediction and the fallback if it's wrong.
When not to
When the system as posed has no capacity bottleneck worth the name, inventing one costs time you need elsewhere.
- The stated scale is small. An internal tool with a few requests per second is unlikely to be limited by load. Say so plainly and look for the hard part elsewhere: permissions, correctness, an awkward integration. The advice to find the hard problem still applies; the hard problem just isn't load.
- You haven't estimated yet. A bottleneck named before the numbers is a guess dressed as analysis. Do the estimate first, even roughly, then name what it points at.
- The interviewer has set the focus. If they've said to assume storage is solved and they want to see the API, pulling the discussion back to a storage limit works against their plan for the hour.
- The hard part is correctness, not throughput. Ordering, idempotency and consistency are real hard parts, but they aren't bottlenecks in the capacity sense. Name them as what makes the system hard, and don't force a throughput story onto them.
Compared
| Situation | Component first | Limit first | When component-first is fine |
|---|---|---|---|
Reads outnumber writes | "I'll put a cache in front of the database." | "If the estimates show reads far outnumber writes and concentrate on a small set of popular items, a cache keyed by item ID in front of the primary takes most of the read load." | The interviewer has asked for a sketch of the boxes and will return to each one. |
A few accounts have huge audiences | "I'll use a queue to fan out posts." | "A post from an account with tens of millions of followers becomes that many timeline writes, so I'd fan out on write for ordinary accounts and pull at read time for the heavy ones." | The audience per sender is capped at a small size, so no single send produces a large fan-out. |
A counter many users update | "I'll shard the database." | "Each like increments the same row, so that row becomes the contention point as the rate climbs. I'd split the counter into slots and sum them on read." | The write rate to that row sits comfortably inside what a single row can take. |
Ten times the load | "Add more servers to each tier." | "The app tier is stateless and scales out. The first thing to reach a limit is the single primary that takes all writes, so that's where I'd split." | Each tier is already stateless or partitioned, and scaling out really is the answer. |