Skip to content
learn
  1. Learn
  2. High Level System Design
  3. The System Design Interview Framework

System Design HLD-18.05

Common mistakes

The mistakes that sink system design answers: naming tools before requirements, skipping estimates, happy-path-only designs and complexity without a reason.

Beginner 8 min Last reviewed

The big idea

Most weak system design answers do not fail because the candidate lacks knowledge. They fail because of a handful of habits: naming technologies before understanding the problem, skipping the numbers, designing only for the case where nothing goes wrong, adding complexity nobody asked for, and running out of time before the interesting part.

The good news is that these are habits, so they can be unlearned. Each one has a simple replacement, and the replacements are exactly the steps of the framework you already know. A steady, well-reasoned design with a plain architecture beats a flashy one every time.

Think of a builder who starts pouring concrete before asking how many floors the house will have. The concrete might be excellent; the house is still wrong.

How it works

Step 1: The five mistakes and their fixes

Five common mistakes and the habit that replaces each Five red boxes on the left list mistakes: tech names first, no estimates, happy path only, complexity without a reason, and no time left for failures. Arrows lead to five green boxes on the right with the fix for each: requirements first, numbers that drive choices, failure walk-through, simplest design that meets the numbers, and a time-boxed plan. Tech names first "we'll use Kafka and Cassandra" No estimates or numbers never used again Happy path only nothing ever fails Complexity without a reason microservices for 100 users Out of time deep dives never reached Requirements first features, scale, out of scope Numbers drive choices QPS, storage, peak Walk through failures what dies, what happens Simplest design that fits add parts when numbers demand Time-boxed plan reach deep dives by minute 25 Figure 1. Every common mistake is a step of the framework skipped. The fix is the step itself, done briefly and on purpose.

Step 2: Jumping to technology names

"I'd put Kafka in front of Cassandra with Redis on top" sounds confident but says nothing about the problem. Every tool is an answer to some question, and if you have not asked the question the interviewer cannot tell whether you chose the tool or just remembered it. Start with what the system must do and how big it is ( Functional and non-functional requirements ). Then describe components by role first, such as "a durable log for click events", and name a product only when it helps: "a durable log, for example Kafka, because we need replay".

Step 3: Ignoring estimates

Skipping the arithmetic means every later choice is a guess. Doing the arithmetic and then never using it is almost as bad. The point of estimating ( Back-of-the-envelope estimation ) is to make decisions: 1,200 writes per second fits on one database leader; 200,000 reads per second needs a cache; 5 PB of video needs object storage and a CDN. Say the number when you make the decision.

Step 4: Designing only the happy path

A diagram where every box always works is a diagram of a system that does not exist. Interviewers want to hear what happens when the cache node dies, when the queue backs up, when a payment provider times out, when a whole availability zone goes away. For each critical component, ask three questions: how do we notice it failed, what do users see while it is down, and how does it recover? Retries with backoff, replicas, timeouts and idempotency ( Timeouts, retries, backoff and jitter ) are the usual answers.

Step 5: Overengineering

The opposite of "no design" is "every design pattern at once": twelve microservices, an event bus, a service mesh and three databases for a product with a few thousand users. Complexity has a cost in latency, operations and failure modes, so each part has to earn its place. A strong answer starts simple and adds a component only when a requirement or a number demands it, saying so out loud: "at this write rate one leader is not enough, so now we shard".

Step 6: Running out of time

The deep dives and the failure discussion are where most of the signal is, and they come last. Candidates who spend fifteen minutes on requirements or redraw the diagram three times reach minute forty with nothing deep said. Keep a rough clock: clarify and estimate in about ten minutes, have the high-level design up by about minute twenty, then go deep.

Try it

Each line is something a candidate might say. Sort it into a red flag or a strong signal.

Show answers
  • Let's start with microservices for users, posts, likes and comments.: Red flag. Architecture before requirements, and splitting services adds network hops and failure modes that nothing has justified yet.
  • Before I draw anything: is this read-heavy, and roughly how many daily users?: Strong signal. Scale and read/write ratio decide caching, storage and sharding, so asking first is exactly right.
  • 100 million reads a day is about 1,200 per second, so a single cached tier handles it.: Strong signal. The estimate is used to make a decision, and the decision is stated.
  • We'll use Kafka, Cassandra and Redis.: Red flag. Tool names with no problem attached. What is each one for, and why that one?
  • If the cache cluster goes down, all reads hit the database. Let's check it can survive that.: Strong signal. A failure walk-through with its impact, which is what most answers skip.
  • I'll come back to failures if we have time.: Red flag. Failures are core, not optional. Plan time for them instead of hoping.
  • One Postgres leader handles this write rate; I'd shard only past about ten times today's load.: Strong signal. Starts simple, says when complexity becomes necessary, and ties it to a number.

Try this:

  1. Sort all seven lines, then press Check. Read the reason for any you got wrong.
  2. For each red flag, rewrite it as a strong signal. Most need only a requirement or a number added.
  3. Record yourself answering "design a URL shortener" ( Design a URL shortener ) for ten minutes and count how many red-flag sentences you said.

Going deeper

Silence and monologue

Two softer mistakes are just as costly. Silence, thinking for minutes without speaking, leaves the interviewer with nothing to evaluate; think out loud, even when unsure. Monologue, talking for twenty minutes without checking in, means you may be deep in a direction the interviewer does not care about. Pause at each transition: "does this scope look right before I estimate?"

Treating hints as attacks

When the interviewer says "what if this node fails?" or "is that cache really needed?", they are steering you toward something they want to see, not catching you out. Treat the question as new information, reason with it openly, and change the design if the reasoning says so. Defending a weak choice to the end is a much worse signal than changing your mind for a good reason.

Trade-offs

OptionWins whenLoses when
Start simple, add parts when numbers demand Almost always: every part is justified and the design stays explainable Only if the interviewer explicitly wants the full-scale design from the start
Start with the full-scale architecture When the prompt itself says 'at Google scale' and requirements are given Usually: parts look memorized, and you spend time on boxes nobody questioned

Common mistakes

  • Naming databases and queues before stating what the system must do.
  • Calculating QPS and storage, then never referring to them again.
  • Drawing a design where nothing ever fails.
  • Adding microservices, event buses or extra databases with no requirement behind them.
  • Spending so long on setup that there is no time for deep dives.

Check yourself

  1. A candidate opens with 'I'd use Kafka and Cassandra'. What is the main problem?

    Show answer

    B. Tools are named before the problem and scale are understood Without requirements, the interviewer cannot tell whether the tools are a reasoned choice or a memorized answer.

  2. You estimated 1,200 writes per second. How should that number be used?

    Show answer

    B. To decide, for example, that one database leader is enough for writes Estimates exist to drive decisions. A few thousand writes per second fits a single well-provisioned leader.

  3. Which question best checks for happy-path thinking?

    Show answer

    B. What do users see while this component is down, and how does it recover? Failure impact and recovery are what a happy-path design leaves out.

  4. The interviewer asks 'is that cache really needed?'. What is the best response?

    Show answer

    C. Reason with the numbers: what load reaches the database without it? Hints are steers. Answer with the read rate and database capacity, then keep or drop the cache based on that.

Recap

  • Requirements before technology; describe parts by role before naming products.
  • Estimate, then use the numbers to make and justify decisions.
  • Walk through failures: how you notice, what users see, how it recovers.
  • Start simple and add complexity only when a requirement or number demands it.
  • Keep a clock so the deep dives and failure discussion actually happen.

Get new lessons by email

Get new posts on backend and AI internals. No spam, unsubscribe anytime.

Your email is only used to send new posts. Privacy

Next up