The whole course ▾
System Design · Lesson 39 of 39 · Week 8
Thinking like a senior engineer
Two candidates draw the same boxes. One gets a senior offer. The difference isn't the boxes. Today: thinking like a senior engineer.
New System Design videos go up at 6 pm. Subscribe on YouTube so you don't miss it.
Got a doubt? Ask in the comments under the video.Subscribe
QuickBite, from day one
This is the last lesson. Before talking about how seniors think, look at how far QuickBite has come: from one phone, one server and one database, in lesson one.
The customer app finds its nearest region through Geo DNS, from lesson thirty-eight. Photos and videos come from the CDN, lesson nine. Requests pass an API gateway that checks identity and rate limits, lessons nineteen and twenty, on their way to separate services for orders, menus and payments. And hot reads come from Redis, the cache from lessons seven and eight.
Underneath: sharded Postgres, indexed and replicated, lessons ten to fourteen. Every important change becomes an event in Kafka, lesson sixteen, feeding workers for slow jobs, lessons fifteen and twenty-nine, and keeping search in sync, lesson twenty-six. And connection servers push live rider positions back to the phone, lesson eighteen. Every box on this board is here because a real problem forced it in. That's the first senior idea.
What makes an answer senior
So what separates a senior answer from a good one? It's rarely knowing more boxes. It's five habits.
One: requirements before boxes, and checked with the interviewer, as every mock in this course began. Two: numbers as a habit, each one deciding something, like seven characters for a short link. Three: every trade-off said out loud, with what you give up. Four: depth where it matters: not every box, but the one or two hardest parts, like conflicting writes in mock three. And five: operations and cost: how it fails, how you'll know, and what it costs to run.
Here's a simple test for your own answers. Point at any box you drew, and ask: because? Then ask: and what does it cost? If you can answer both for every box, in one sentence each, you're giving a senior answer, whatever your current title says.
Trade-offs out loud
The third habit is the one interviewers notice fastest. Listen to the same three decisions, said two ways.
A mid-level answer says: use Kafka, add a cache, make it scalable. A senior answer says: Kafka, because three teams need the same events, and the ability to replay them. Cache the menus, because each is read a hundred times per change, and a minute of staleness is fine. Shard orders by customer ID, because at thirty terabytes a year, one machine won't last. Same boxes. Each one now has a reason, and a limit.
And add the cost, in this shape: we gain X, we give up Y, and Y is acceptable because Z. We gain fast reads, we give up a minute of freshness, and that's acceptable because menus rarely change mid-meal. That one sentence pattern, used three or four times in an interview, does more than any diagram.
Operations and cost
The fifth habit is the one most candidates forget completely, which makes it the easiest way to stand out.
Ask four questions of every box. How does it fail: slowly, suddenly, or by giving wrong answers? How will we know: which metric, which alert, lesson twenty-four. How do we change it safely: deploy a little at a time, and roll back fast. And what does it cost: three regions are three times the machines, so is that speed worth that money?
And the senior instinct underneath all of it: the simplest system that meets the requirements wins. Every box you add has to be built, monitored, upgraded and understood at three in the morning. That's why lesson twenty said start with a monolith, and mock five said six hundred payments a second fits on one database. Knowing when not to add something is a senior skill.
Your forty-five minutes
Now, the interview itself. Every mock in this course followed the same clock, from lesson four. Here it is, one last time.
Minutes zero to five: requirements, then check them with the interviewer. Five to nine: only the numbers that decide something. Nine to fourteen: the API and data model. Fourteen to twenty-four: the high-level design, one request at a time. Twenty-four to forty-one: deep dives, where you adapt when pushed, instead of defending. And the last four minutes: name your own weak spots, before the interviewer does.
And when you get stuck, which everyone does, don't go quiet. Say what you're thinking, name two options, and ask which one the interviewer would like you to explore. Interviews are conversations. Silence is the only answer that can't be scored.
After this course
Thirty-nine lessons and eight mock interviews are a strong foundation. Here's how to keep it growing.
Redo each mock interview, with a forty-five minute timer, out loud, before watching it again. Read one real design a week from company engineering blogs, and spot the lessons in it. Explain a design to a friend: the parts you can't explain simply are the parts you haven't understood yet. And build a tiny version of one system, like a URL shortener, because building teaches what diagrams can't.
And the course doesn't stop here. After the final mock interview this Sunday, twelve more mock interviews follow, every Sunday and Wednesday: Yelp, a distributed cache, Spotify, an online judge, live streaming, Google Maps, a stock exchange, and more, ending with designing ChatGPT itself. Same format, same clock, new problems.
Quick check
The interviewer asks: why Kafka? What makes an answer senior?
Show the answer
A reason tied to the requirements, and a cost: replay for three teams, at the price of running Kafka.
Ten minutes left, and you haven't discussed failures. What do you do?
Show the answer
Name the weak spots yourself: what fails, how you'd notice, and how you'd fix it.
Remember: every box has a because, and a cost you can name. Go deep where it matters, and remember that simple wins. And keep the clock, and adapt when pushed. Thank you for learning with QuickBite, all thirty-nine lessons of it. Tomorrow, the final revision, and on Sunday, the final mock: design QuickBite itself.
Lessons on weekdays, the week's revision on Saturday, a mock interview on Sunday.