Interview guide

System Design Interview Questions (2026)

Senior system design rounds rarely start with 'design Twitter' and no context. They probe specific fundamentals. This guide shows the questions that interviewers ask, and how to answer them.

Last updated: August 2026

From the outside, system design interviews look unstructured: an open-ended prompt and a whiteboard. But interviewers score against specific fundamentals. Know these fundamentals and how they combine. That is more useful prep than a memorized template for "design X."

This guide covers the framework that interviewers expect and the fundamentals that every prompt uses. It also covers the systems that interviewers most frequently ask you to design, and the questions that candidates most frequently answer incorrectly.

The framework interviewers expect

Strong answers follow a sequence, also when the interviewer does not ask for one. Clarify requirements and scale, and do a back-of-envelope estimate. Sketch the API, select a data model, and draw the high-level components. Then go deep on the hardest part. Candidates most frequently lose control of the round when they go directly to boxes and arrows. Then the tradeoff discussion has no anchor.

The design round itself explains each step of that sequence with a worked example. Senior Loop's Design It problems divide the same sequence into 7 graded parts. Thus you practice it end to end, and you do not only read about it.

The fundamentals that every question uses

Almost every "design X" prompt tests a small, recurring set of fundamentals. Learn these fundamentals deeply. Then most prompts only need a new combination of what you already know.

Estimation and scale

  • "How would you estimate the read and write QPS for this system?"
  • "At what scale is a single database not sufficient?"

Interviewers want a defensible back-of-envelope number, not precision. They want to see you use that number to justify later design choices. Do not only state it and continue. See back-of-envelope estimation.

Databases and data modeling

  • "Would you use SQL or NoSQL here, and why?"
  • "What is your schema, and which primary access pattern is it optimized for?"

The strongest answers start from the read/write pattern, not from a preference for a specific database. See databases 101.

Caching

  • "Where would you add a cache, and why in that specific location?"
  • "How do you invalidate this cache when the underlying data changes?"
  • "What occurs on a cache stampede?"

See caching basics for the fundamentals. See caching at scale with Redis for invalidation and failure modes at production scale.

Consistency and CAP

  • "Does this system need strong consistency, or is eventual consistency acceptable?"
  • "What occurs to writes during a network partition?"

The strongest answers connect the choice to a concrete user-facing consequence (a stale balance, a duplicate order). They do not recite the CAP theorem abstractly. See consistency models and CAP.

Replication, partitioning, and sharding

  • "How would you shard this dataset, and what is your partition key?"
  • "What occurs when a replica has lag?"

See replication and partitioning and consistent hashing and sharding to learn why a bad partition key is the most common reason that a design fails under the follow-up questions of the interviewer.

Queues, async messaging, and idempotency

  • "Why add a queue here instead of a synchronous call?"
  • "How do you handle a poison message that fails again and again?"
  • "How do you guarantee that the system does not apply this operation twice?"

See queues and async messaging, Kafka internals, and idempotency and exactly-once effects.

Distributed locking and consensus

  • "Two workers can take the same job. How do you prevent that?"
  • "After a failure, how does the system agree on the leader?"

See distributed locking, leader election with Raft, and two-phase commit. Most candidates can name these patterns. Few can explain what occurs when the coordinator itself fails during the commit.

Failures, timeouts, retries, and resilience

  • "What occurs when this downstream service times out?"
  • "How do you prevent a retry storm from making an outage worse?"

See failures, timeouts, and retries and resilience patterns (circuit breakers, bulkheads, and backpressure).

Observability

  • "How would you know that this system is degraded before customers report it?"
  • "What would you alert on, and why not on everything?"

See observability basics.

Questions that interviewers ask

In addition to fundamentals, most loops take their prompt from a small pool of systems. Each system tests several fundamentals at the same time. This section shows what makes each one hard, and where interviewers usually push:

"Design a URL shortener"

It looks trivial, but it is not. The real questions are about ID generation at scale without collisions, read-heavy caching, and what occurs when a short link goes viral. See the full URL shortener at scale breakdown.

"Design a chat system" (like WhatsApp or Slack)

It tests real-time delivery, message ordering, and offline sync at the same time. See chat systems at scale.

"Design a push notification system"

It fans out to millions of devices through third-party gateways that you do not control. If your backoff is wrong, the retries can become a self-inflicted DDoS. See push notifications at scale.

"Design a matching engine or order book"

This is the financial-systems prompt: strict ordering, low latency, and correctness guarantees. A typical CRUD service can relax these guarantees, but this system cannot. See matching engine and order book.

How senior expectations differ

The prompts often look the same across levels. The difference is whether you control the round. You select a sensible deep dive without a prompt. You find the failure modes of your own design before the interviewer shows them. You justify tradeoffs with a concrete consequence, not a definition. For more depth on that difference, see the senior backend engineer interview prep guide.

How to prepare, fundamental by fundamental

Every design question uses the same pieces: caching, consistency, queues, replication, observability, idempotency. If your knowledge of these pieces is weak, many full mock interviews are inefficient. Senior Loop's Deep Dives divide system design into exactly these fundamentals. Each one has the tradeoffs that interviewers probe. A free set is available with no card required.

Frequently asked questions

The questions that candidates ask most often about system design interviews.

What is a system design interview?+

It is a 45-60 minute round with an open-ended prompt, for example "design a URL shortener" or "design a rate limiter." You architect a system from scratch: requirements, scale estimates, API, data model, high-level components. Then you do a deep dive into the hardest part. There is no single correct answer. The interviewer scores how you reason through tradeoffs.

How do I prepare for a system design interview in a short amount of time?+

If you have only 1-2 weeks, do not do full mock interviews. Practice fundamentals instead: estimation, caching, consistency and CAP, replication, queues, and failure handling. Every "design X" prompt uses these seven topics. When you can explain the tradeoffs of each topic without preparation, mock interviews become much more valuable.

What's the difference between system design and low-level design (LLD) interviews?+

System design (HLD) is about services, data stores, and scale: how components communicate. LLD is one level lower: the classes, interfaces, and object interactions inside a single service. The LLD vs HLD guide gives the full breakdown.

Do senior candidates get harder system design questions than mid-level candidates?+

The prompts often look similar ("design a chat app"), but the bar is different. Senior loops expect you to control the conversation and to select a sensible deep dive without a prompt. They also expect you to justify each tradeoff with a concrete consequence (a stale balance, a duplicate charge), not with textbook definitions.

What system design topics occur most often in interviews?+

Almost every prompt includes caching (invalidation and stampedes), consistency and CAP tradeoffs, sharding and replication, queues and idempotency, and failure handling (timeouts, retries, circuit breakers). Deep, specific knowledge of these seven fundamentals covers more of the interview than ten memorized system templates.

Related reading

Ready to practice?

Try Design It (7-part graded system design problems, both free), or start the free system design roadmap to learn the fundamentals first. Neither option needs a card.

Start free →