Common Mistakes

Updated Nov 16, 2026 · 4 min read
On this page

    Most system design rejections are not about missing knowledge. Interviewer feedback tends to say things like "never clarified scale", "couldn't explain why", "ran out of time before the interesting part" or "didn't respond to hints". The candidate usually knew enough; the way they spent the 50 minutes hid it.

    The good news is that these mistakes are predictable, and each one has a simple habit that prevents it. This page lists the ones that cost the most, with the fix for each.

    How it works

    Where the time goes

    Two candidates, same 50 minutes: the weak one spends almost all the time drawing boxes and debating a database, with no requirements, numbers, deep dive or wrap-up; the strong one moves through requir
    Two candidates, same 50 minutes: the weak one spends almost all the time drawing boxes and debating a database, with no requirements, numbers, deep dive or wrap-up; the strong one moves through requirements, API, a simple design, two deep dives and a recap.

    Most mistakes show up as bad time use. The weak timeline above is common: a quick start, a long middle of drawing and debating, and no deep dive. The strong timeline uses the 50-minute framework: every phase builds on the previous one and the deep dives get half the time.

    Every component needs a reason

    Component first versus requirement first: listing Kafka, Redis, Cassandra, Elasticsearch and Kubernetes leads to silence when asked why; mapping 50,000 writes per second, a 50 ms read target and text
    Component first versus requirement first: listing Kafka, Redis, Cassandra, Elasticsearch and Kubernetes leads to silence when asked why; mapping 50,000 writes per second, a 50 ms read target and text search to a log, a cache and a search index gives each part a reason.

    The second-biggest pattern is naming technology instead of solving problems. Interviewers will ask "why?" about any component. If the answer is not a requirement or a number you already stated, the component looks copied from somewhere.

    The mistakes, one by one

    MistakeWhat it looks likeFix
    Designing before askingDrawing boxes in minute oneSpend the first 5 minutes on use cases and scale
    No numbers"It needs to scale"State assumptions: "10,000 writes per second at peak" and what they imply
    Component without a reason"We'll add Kafka"Tie every part to a requirement: "writes are spiky, so a log absorbs bursts"
    Over-engineering earlyMicroservices, multi-region and sharding in the first designStart with the simplest design that works; add parts to fix named bottlenecks
    Never reaching depthStill on the high-level design at minute 35Checkpoints: design by 12, first deep dive by 22
    No trade-offsEvery choice presented as obviously rightSay the cost: "this adds staleness up to the TTL"
    Ignoring failureNothing ever goes downAsk yourself "what if this box dies or slows down?" for each key part
    Going silentLong pauses while thinkingThink out loud, even when unsure: "I'm deciding between X and Y because…"
    Fighting hintsDefending the first idea when the interviewer probes itTreat a question as a hint; explore it
    Vague data model"We store the data in a database"Name the key tables, the primary key and the index behind each main query

    Trade-offs and costs

    Some fixes can be overdone:

    • Too many questions: 10 minutes of clarifying looks like stalling. Ask the questions that change the design, then state assumptions for the rest.
    • Too much math: long estimates waste time. Round numbers, and only calculate what drives a decision.
    • Too many trade-offs: listing five options for every choice is slow. Give two, pick one, move on.
    • Too rigid a plan: if the interviewer wants to go somewhere else, follow them.

    When to reach for it

    Use this list as a checklist after every practice session. Record yourself (or ask your mock partner) and mark which mistakes happened. Most people have one or two habitual ones; fix those first.

    Example

    The same prompt, "Design a news feed", answered two ways in the first 15 minutes.

    Weak: "We'll have a feed service with Kafka and Cassandra, Redis for caching, and Elasticsearch for search." Draws eight boxes. When asked about scale: "It should handle millions of users." When asked why Cassandra: "It scales well."

    Strong: "Core use cases: post, follow, read the home feed. I'll assume 200 million daily users, about 1 billion feed reads and 50 million posts a day, so reads dominate about 20 to 1. That suggests precomputing feeds. First a simple design: client → API gateway → Post Service and Feed Service → posts table and a feed cache. Then I'd like to deep dive into fanout, especially for accounts with millions of followers, and into feed read latency."

    Same knowledge. The second answer shows the reasoning the interviewer is scoring.

    Common mistakes

    The table above is the list. The meta-mistake is practising only by reading. You can't notice your own silent pauses, missing numbers or time drift unless you practise out loud, timed, and review it.

    Say this in the interview

    When you notice yourself slipping, recover out loud:

    "Let me step back: I've spent a while on the database choice. The bigger risk here is fanout for popular accounts, so let me move to that, and I can come back to storage if we have time."

    Used in