The system design interview format
There is no answer key
Every other round has a right answer hiding in it. The coding round has a passing test suite. The debugging round has a bug. Even the behavioral round has a story shape the interviewer recognizes.
The design round has none of that. Two strong candidates can produce completely different architectures for the same prompt and both get hired. A candidate can also produce the architecture the interviewer uses at work and still fail.
The design itself isn't what's scored. What's scored is whether your reasoning is legible, quantified and honest about its own costs.
The shape of the hour
Most sessions run 45 to 60 minutes. This pacing guide shows up again and again, and it's worth carrying in your head as a budget rather than a law:
| Phase | Minutes | What it produces |
|---|---|---|
| Requirements | ~5 | A scoped problem with explicit assumptions |
| Estimation | ~3 | Numbers that justify the component choices |
| High-level design | ~15 | Boxes, arrows, and the data that flows |
| Deep dive | ~15 | One component at three layers down |
| Trade-offs and wrap | ~5 | What it costs, what would change it |
The two phases people get wrong are the first and the last. Candidates spend one minute on requirements because they're eager to draw. Then they run out of clock before the trade-off discussion, which is the most heavily scored part of the round.
If you're 30 minutes in and haven't said a single number, you're behind, however good the diagram looks.
The interviewer is a collaborator
This is the biggest behavioral difference from the coding round, and it's the one that sinks otherwise strong engineers.
The interviewer isn't an examiner waiting for you to finish. They're playing a stakeholder who knows the answer they want you to discover, and they'll steer if you let them. Ask "does this need to handle uploads, or is it text only?" and you get a real answer that saves you five minutes of designing the wrong thing.
Silence is the top failure mode. A candidate who thinks for ninety seconds and then presents a finished idea has given the interviewer nothing to score, because the thinking is what's scored. Narrate the dead ends too: "I considered putting this in the request path, but a 300 ms external call there would blow the latency target, so it goes in a job."
Four ways qualified people lose this round
The first is designing before scoping. The prompt is deliberately underspecified. Drawing first means you're designing for an imagined problem, and every later answer inherits the mistake.
The second is naming products instead of components. "I'd use Kafka and Redis and Elasticsearch" is a shopping list. "I need an append-only log with replay, so a durable message log, Kafka or equivalent" is a design. The second one survives the follow-up "why not just Postgres?", and the first one doesn't.
The third is going deep where it's comfortable instead of where it matters. If the hard part of the system is the fan-out and you spend your deep dive on the login flow, you've shown you can't find the hard part.
The fourth is never mentioning failure. A design where nothing crashes, no network call times out and no queue backs up reads as a design that has never been operated. What happens when the third-party provider is down for six hours is a question you should raise before they do.
Being a Rails engineer in this room
Two failure modes sit on either side of this, and both are avoidable.
The first is hiding it. Rails experience is evidence that you've run a real system with a real database under real load, and that's the experience the round is testing. "In practice I've seen this pattern hold to about a million rows before the index stops fitting in memory" is worth more than any amount of vocabulary.
The second is answering architecture questions with framework features. "How would you handle a million writes a second?" isn't a question about Active Record. Reach for the framework when it's the answer. For example, when Solid Queue shares your primary database, job state sits in the same PostgreSQL transaction as your business rows, and that's a correctness argument. But a design round wants the mechanism first and the library second.
Most interviewers don't care whether your answer is implementable in Rails. They care whether you know what you're choosing.
The whiteboard is usually not a whiteboard
Almost every one of these rounds is now remote, which changes the mechanics enough to rehearse.
You'll get a shared drawing tool, a shared document or a blank screen and the instruction to share yours. All three reward the same preparation: decide in advance what your boxes look like, and stop making that decision during the round. Use a rectangle for a service, a cylinder for a datastore and a labeled arrow for the direction data moves, and nothing else. Candidates lose minutes choosing shapes.
Two practical habits are worth more than drawing skill. First, write the requirements in a corner and leave them visible. At minute thirty you can then point at the constraint you're satisfying rather than recalling it. Second, label every arrow with what flows along it, such as "invoice id" rather than an unlabeled line. An unlabeled arrow hides the coupling the interviewer wants to ask about.
If the tool fights you, say so and keep talking. Nobody has ever failed this round for an ugly diagram, and plenty have failed it by going quiet while fixing one.
What you'll design here
Lessons 2 through 4 build one prompt end to end: invoice delivery for Meridian, the Rails 8 invoicing system from the previous course. It has four thousand accounts and invoices generated nightly. Each invoice has to reach the customer by email, by webhook and through the API, reliably, without duplicates and without the monthly close taking the whole thing down.
That prompt was chosen because it contains every primitive the round tests: a fan-out, a third-party dependency that fails, a retry story, a burst and a correctness requirement that can't be hand-waved.
What this course covers
- The system design interview format: this lesson
- Requirements and capacity estimation: turning a vague prompt into numbers
- Data modeling at scale: keys, indexes, partitioning and the constraint that surprises people
- Caching, queues and read replicas: the three primitives, and when each is the wrong one
- Rate limiters and LRU caches in Ruby: with a challenge where you build one
- Classic prompts, URL shortener, feed and notifications: the three you're most likely to be asked
- Whiteboard session, putting it all together: a full scored run
Start where the round starts, and where most of it is won: refuse to draw anything until you know what you're building.
Keep going with lesson 2
Requirements and capacity estimation
Turning a vague prompt into functional and non-functional requirements, then estimating rates and finding the peak that breaks a limit.
A free account also gives you the quizzes, your progress and notes, and the discussion.