Question 1

How do distributed systems detect node failures?

Accepted Answer

**Target Audience:** Beginners who know a cluster is several servers working together and want to understand how the cluster notices when one of them stops, and why it sometimes gets it wrong.
**Difficulty:** Medium
**Verified with:** Node 22.22 and Python 3.12 (both print identical output). The FLP result is from Fischer, Lynch and Paterson (JACM, 1985); Kubernetes lease behaviour from the Kubernetes node-status documentation; memberlist and Lifeguard from HashiCorp's "Making Gossip More Robust

Question 2

How do you approach back-of-the-envelope capacity estimation?

Accepted Answer

**Target Audience:** Beginners to system design — you can multiply and divide; nothing else assumed.
**Difficulty:** Medium
**Verified with:** Node 22.22 and Python 3.12 (the calculator prints the same output in both).

> **How to read this doc:** Every idea is explained in plain language first, then tagged with `📌 Interview term:` so you also learn the exact words an interviewer expects. Every number in the worked example was computed by the example program; the **Verified** section quotes its

Question 3

When do you use a read replica vs a cache?

Accepted Answer

**Target Audience:** Beginners to system design — you know what a database and a query are; replication and caching are explained here.
**Difficulty:** Medium
**Verified with:** Node 22.22 and Python 3.12 (both print identical output).

> **How to read this doc:** Every idea is explained in plain language first, then tagged with `📌 Interview term:` so you also learn the exact words an interviewer expects. Behaviour claims (stale reads, counts) come from running the example; the **Verified** sec

Question 4

How do you choose between SQL and NoSQL and scale each (replication, sharding, federation)?

Accepted Answer

## Step 1: Use Cases, Constraints, Assumptions, Back-of-Envelope

### Use cases
We'll scope to handle only the core flows that expose the bottlenecks; everything else is deferred.

- **User** needs strong transactions — SQL (ACID, joins) for orders, payments, friendships.
- **Service** needs massive write scale — NoSQL (Cassandra/Dynamo wide-column/KV) for timelines, metrics, crawl frontier.
- **Service** scales reads — add read replicas (async), measure lag.
- **Service** scales writes — shard

Question 5

What is database replication?

Accepted Answer

**Target Audience:** Beginners to distributed data — you know what a database server is; no prior knowledge of replication assumed.
**Difficulty:** Medium
**Verified with:** Node 22.22 and Python 3.12 (both print identical output).

> **How to read this doc:** Every idea is explained in plain language first, then tagged with `📌 Interview term:` so you also learn the exact words an interviewer expects. Behaviour shown comes from running the example; the **Verified** section quotes the full outpu

Question 6

What is a write-ahead log (WAL)?

Accepted Answer

**Target Audience:** Beginners to database internals — you know a database stores data on disk and that a server can crash; everything else is defined as we go.
**Difficulty:** Medium
**Verified with:** Node 22.22 and Python 3.12 (both print identical output). PostgreSQL settings were read with `SHOW` on a local PostgreSQL 16.15 server; SQLite behaviour was checked with SQLite 3.45.1 from Python.

> **How to read this doc:** Every idea is explained in plain language first, then tagged with `📌 I

Question 7

What is the difference between strong and eventual consistency?

Accepted Answer

**Target Audience:** Beginners to distributed systems — you know what a database and a replica copy are; everything else is defined as we go.
**Difficulty:** Medium
**Verified with:** Node 22.22 and Python 3.12 (both print identical output).

> **How to read this doc:** Every idea is explained in plain language first, then tagged with `📌 Interview term:` so you also learn the exact words an interviewer expects. Stale-read rates and timings come from the example program; the **Verified** section

Question 8

How would you design a distributed cache?

Accepted Answer

**Target Audience:** Intermediate — you know what a cache is and what a hash function does; distributed-systems vocabulary is defined as it appears.
**Difficulty:** Hard
**Verified with:** Node 22.22, Python 3.12, Go 1.24 and Java 21 (all four print identical output).

> **How to read this doc:** Every idea is explained in plain language first, then tagged with `📌 Interview term:` so you also learn the exact words an interviewer expects. Slot numbers, key movements and node loads come from runn

Question 9

How would you design a system that scales to millions of users on AWS?

Accepted Answer

## Step 1: Use Cases, Constraints, Assumptions, Back-of-Envelope

### Use cases
We'll scope to handle only the core flows that expose the bottlenecks; everything else is deferred.

- **User** signs up / logs in — auth on stateless API, session in Redis, email verify async.
- **User** reads feed/profile — cache-first, CDN for assets, read replicas for DB.
- **User** writes (post/like) — write to master, async fan-out, eventual read visibility.
- **Service** scales — milestone Users+ → Users+++++,

Question 10

How would you design a distributed key-value store?

Accepted Answer

**Target Audience:** Engineers preparing for the classic "design a key-value store" round, which tests whether you can combine partitioning, replication, consistency and storage into one coherent system.
**Difficulty:** Hard
**Verified with:** Node 22.22, Python 3.12, Go 1.24 and Java 21 for the cluster example (identical output); Node 22.22 and Python 3.12 for the storage-engine example. The design follows the Dynamo paper (DeCandia et al., SOSP 2007); the DynamoDB 400 KB item limit is from the

SYSTEM DESIGNDECODED.

Medium

How do distributed systems detect node failures?

How do you approach back-of-the-envelope capacity estimation?

When do you use a read replica vs a cache?

How do you choose between SQL and NoSQL and scale each (replication, sharding, federation)?

What is database replication?

What is a write-ahead log (WAL)?

What is the difference between strong and eventual consistency?

Hard

How would you design a distributed cache?

How would you design a system that scales to millions of users on AWS?

How would you design a distributed key-value store?

How does CDC with Debezium keep search and cache in sync with Postgres?

How would you design a distributed message queue?

How would you design a metrics monitoring and alerting system?

How would you design S3-like object storage?