Question 1

How many core system design patterns are there?

Accepted Answer

There are roughly 50 system design patterns that recombine in different ways to solve nearly every problem you encounter in interviews or production. They fall into 10 categories: storage, caching, communication, reliability, scaling, data processing, API design, infrastructure, consistency, and observability. Knowing the patterns beats memorizing specific company architectures.

Question 2

What is the primary-replica (leader-follower) pattern?

Accepted Answer

One database server (the primary) handles all writes while one or more replicas receive copies and serve reads. If the primary fails, a replica is promoted. It is used wherever reads vastly outnumber writes, since you scale reads by adding replicas. The trade-off is replication lag: asynchronous replicas can return stale data, while synchronous replication removes lag but slows writes.

Question 3

When should you shard a database?

Accepted Answer

Shard when a single database can no longer handle the write throughput or storage volume, such as a billion-row table taking 100,000 writes per second. Sharding splits data across servers using a shard key. The trade-offs are expensive cross-shard scatter-gather queries, hot spots from a poorly chosen shard key, and painful resharding that often requires downtime.

Question 4

What is consistent hashing used for?

Accepted Answer

Consistent hashing places servers and keys on a virtual ring so adding or removing a server only remaps a small fraction of keys instead of reshuffling everything. It is used in distributed caches like Redis Cluster, databases like DynamoDB and Cassandra, and CDN routing. It is more complex than modular hashing and needs virtual nodes to avoid uneven key distribution.

Question 5

What is the difference between cache-aside and write-through caching?

Accepted Answer

Cache-aside has the application check the cache first and load from the database on a miss, making it the default strategy for read-heavy workloads, though the first request is always slow. Write-through writes to both cache and database at once, keeping the cache fresh for read-after-write consistency, but every write is slower and unread cached data wastes space.

Question 6

How do you prevent a cache stampede?

Accepted Answer

A cache stampede happens when a popular entry expires and thousands of requests hit the database simultaneously. Prevention techniques include request coalescing (one request loads while others wait), probabilistic early expiration (refresh entries randomly before they expire), and lock-based loading (the first request acquires a lock). Each adds complexity but protects the database from thundering herds.

Question 7

How does a message queue differ from pub/sub?

Accepted Answer

A message queue delivers each message to a single consumer that processes it at its own pace, decoupling producers from consumers for tasks like sending emails or processing uploads. Pub/sub broadcasts each message to a topic so every subscriber gets a copy, which suits event-driven systems where many services react to one event. Pub/sub subscribers must handle duplicate messages idempotently.

Question 8

What is the circuit breaker pattern?

Accepted Answer

When a downstream service fails repeatedly, the circuit breaker stops calling it and returns a fallback response immediately, then periodically tests whether the service has recovered. It prevents a failing dependency from taking down its callers. The trade-offs are that the fallback may be degraded (stale or generic data) and you must tune the failure threshold and recovery timeout carefully.

Question 9

Why is idempotency important in distributed systems?

Accepted Answer

Idempotency means executing an operation multiple times yields the same result as executing it once, so a retried payment is not charged twice. It matters on every write API because network failures leave the client unsure whether the server processed the request. The cost is storing idempotency keys and checking for duplicates, which adds a database lookup to the write path.

Question 10

What is the difference between horizontal and vertical scaling?

Accepted Answer

Horizontal scaling adds more machines and suits stateless services, but it requires a load balancer and external session storage and does not help a single-database bottleneck. Vertical scaling upgrades to a more powerful machine and is simple for databases and single-threaded workloads, but it has a finite hardware ceiling, remains a single point of failure, and gets expensive at the top end.

Question 11

What is the difference between MapReduce and stream processing?

Accepted Answer

MapReduce splits a large dataset across machines (map phase), processes each part independently, and combines results (reduce phase); it is the foundation of batch processing but has high latency of minutes to hours. Stream processing handles data event by event with sub-second latency for real-time analytics, fraud detection, and live recommendations, though it is more complex and harder to debug.

Question 12

What does an API gateway do?

Accepted Answer

An API gateway is a single entry point that routes, authenticates, rate-limits, and transforms requests before forwarding them to backend services, so clients call one gateway instead of knowing about many internal services. It is standard in microservices architectures. The trade-off is that the gateway is a single point of failure (mitigated with redundancy) and can become a bottleneck if it is not scaled.

Question 13

How does two-phase commit compare to the saga pattern?

Accepted Answer

Two-phase commit coordinates an atomic transaction across participants by asking everyone to commit, then committing or rolling back; it guarantees atomicity but blocks on coordinator failure and scales poorly. The saga pattern uses a sequence of local transactions with compensating transactions to undo failed steps, which suits long-running distributed workflows but allows temporary inconsistency and needs careful compensation logic.

Question 14

What is a quorum and how does the W + R > N rule work?

Accepted Answer

In a system with N replicas, a quorum requires W replicas to acknowledge a write and R replicas to agree on a read. When W + R > N, any read is guaranteed to see the latest write. Tunable-consistency databases like DynamoDB and Cassandra use this to trade consistency for performance: higher W slows writes and higher R slows reads. Strong consistency typically uses W = N/2 + 1 and R = N/2 + 1.

Question 15

How should you approach an open-ended system design question?

Accepted Answer

Ask five questions in order: how does data flow (communication patterns), how is data stored (storage patterns), how is data accessed quickly (caching patterns), how does the system survive failures (reliability patterns), and how does the system grow (scaling patterns). These generate the skeleton of any design answer. You do not need all 50 patterns memorized, just the ability to recognize which apply.

Data Storage Patterns(6 questions)

What is the primary-replica (leader-follower) pattern and when would you use it?

What is sharding (horizontal partitioning), and what are its main pitfalls?

What problem does consistent hashing solve, and where is it used?

What is a write-ahead log (WAL) and why do databases rely on it?

What is event sourcing, and when is it the right choice?

What is CQRS (Command Query Responsibility Segregation)?

Caching Patterns(5 questions)

How does the cache-aside (lazy loading) pattern work?

What is the write-through caching strategy?

What is write-behind (write-back) caching, and what is its main risk?

How does read-through caching differ from cache-aside?

What is a cache stampede, and how can you prevent it?

Communication Patterns(7 questions)

What is the request-response (synchronous) communication pattern?

When would you use a message queue for asynchronous communication?

How does publish-subscribe (pub/sub) differ from a message queue?

What is event-driven architecture, and what makes it harder to operate?

What are webhooks, and when are they appropriate?

What are Server-Sent Events (SSE), and how do they compare to WebSockets?

When would you choose bidirectional streaming (WebSockets / gRPC streaming)?

Reliability Patterns(7 questions)

What is the circuit breaker pattern?

Why use retry with exponential backoff, and why add jitter?

What is the bulkhead pattern, and where does its name come from?

Why is setting a timeout on every external call important?

What does it mean for an operation to be idempotent, and why does it matter in distributed systems?

What is a dead letter queue (DLQ) and what problem does it solve?

What is graceful degradation, and how do you decide what to degrade?

Scaling Patterns(5 questions)

What is horizontal scaling, and what does it require?

When is vertical scaling the right choice over horizontal scaling?

What role does a load balancer play, and what are its trade-offs?

How does auto-scaling work, and what makes it tricky to tune?

Why is database connection pooling important?

Data Processing Patterns(4 questions)

What is MapReduce and what is it suited for?

How does stream processing differ from batch processing?

What is the Lambda architecture?

What is Change Data Capture (CDC) and what is it used for?

API Design Patterns(5 questions)

What is an API gateway and why is it central to microservices?

What is the Backend for Frontend (BFF) pattern?

What is rate limiting, and what algorithms are commonly used?

How does cursor-based pagination work, and how does it compare to offset-based?

Why and when do you need API versioning?

Infrastructure Patterns(4 questions)

What is a CDN and how does it reduce latency?

What is a reverse proxy and what concerns does it handle?

What is a service mesh, and when is it worth the complexity?

What is the sidecar pattern?

Consistency Patterns(4 questions)

How does two-phase commit (2PC) work, and what are its weaknesses?

What is the saga pattern, and when is it preferable to two-phase commit?

What is a quorum, and how does the W + R > N rule work?

What problem do vector clocks solve in distributed systems?

Observability and Operations Patterns(3 questions)

What is a health check endpoint, and what is the difference between shallow and deep checks?

What is distributed tracing and why is it essential in microservices?

What is a canary deployment and how does it reduce release risk?

Applying Patterns in Interviews(5 questions)

Why focus on learning patterns rather than memorizing the architectures of companies like Twitter, Uber, and Netflix?

When an interviewer says “design X,” what five questions should you ask yourself to structure your answer?

If you only had time to study 15 patterns before an interview, which ones do interviewers test most often?

How are the 50 system design patterns organized into categories?

How should you demonstrate that you actually understand a pattern during an interview?