Q: What is the difference between horizontal and vertical scaling?

## Two ways to add capacity - **Vertical scaling (scale up):** make one machine more powerful — more CPU, RAM, faster disk/NVMe. - **Horizontal scaling (scale out):** add more machines and spread load across them, usually behind a **load balancer**. <path class='d-arrow' d='M0,0 L8,4 L0,8 Z'

Q: When would you choose SQL vs NoSQL?

## SQL vs NoSQL It comes down to your **data shape**, **consistency needs**, and **scale/access pattern** — not fashion. - **SQL (relational):** a fixed schema of tables with relationships, **ACID** transactions, rich joins and ad-hoc queries. Scales **up** easily; scaling **out** (sharding) takes work. - **NoSQL:** a family of stores — **document** (Mongo), **key-value** (Redis, DynamoDB), **wide-column** (Cassandra), **graph** (Neo4j). Flexible/!schema, built to scale **out**, high write thr

Q: What is idempotency and why does it matter?

## Idempotency An operation is **idempotent** if performing it **many times has the same effect as performing it once**. `GET`, `PUT`, and `DELETE` are idempotent; **`POST` is not** (two POSTs = two resources). It matters because the network is unreliable: a client times out and **retries**, or a queue delivers **at-least-once**. Without idempotency a retry double-charges a card or creates duplicate orders. The fix is an **idempotency key**: the client sends a unique key per logical operation;

Q: How do distributed systems detect node failures?

## Failure detection Nodes signal liveness with **heartbeats**: each node periodically says 'I'm alive'. If a node misses heartbeats for longer than a **timeout**, it's marked **suspect**, then **dead**. The fundamental catch: you **cannot distinguish a slow node from a dead one** over an unreliable network — so detectors trade off **speed vs false positives**. <svg class='iq-diagram' viewBox='0 0 480 180' role='img' aria-label='Nodes send heartbeats to a monitor; a silent node is marked dead'

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

## Back-of-the-envelope estimation The goal isn't precision — it's an **order-of-magnitude** sanity check that tells you whether you need one box or a thousand, and where the bottleneck is. Work top-down from users to load: <rect class='d-box' x='1

Q: What is database connection pooling?

## Connection pooling Opening a database connection is **expensive** — TCP handshake, TLS, and auth round trips — and databases cap how many connections they can handle. A **connection pool** keeps a fixed set of connections **open and reusable**: a request **borrows** one, runs its query, and **returns** it. If all are busy, requests **queue** until one frees up. <de

Q: What is the publish-subscribe pattern?

## Publish-subscribe In **pub/sub**, publishers send messages to a **topic**, and the broker **fans out** a copy to **every** subscriber of that topic. Publishers and subscribers never reference each other — they're fully **decoupled**, and you can add subscribers without touching the publisher. <marker id='ah-ps' markerWidth='9' markerHeight='9' refX='7' refY=

Q: What are the three pillars of observability?

## The three pillars of observability Observability is being able to **ask new questions about your system from the outside** without shipping new code. The three classic signal types: - **Metrics** — cheap numeric time series (QPS, latency p99, error rate, CPU). Best for **dashboards and alerting**; aggregate, low cardinality. - **Logs** — timestamped, detailed event records. Best for **debugging the specifics** of what happened; high volume, searchable. - **Traces** — the path of a **single

Q: What is consistent hashing?

## The problem it solves If you place keys with `hash(key) % N` across N servers, then **changing N** (adding/removing a server) remaps **almost every key** — catastrophic for a cache or sharded store. **Consistent hashing** fixes this: adding/removing a node only moves about **K/N** keys. ## How it works Map both **nodes and keys** onto a circular hash space (the *ring*). A key is owned by the **first node clockwise** from its position. Remove a node and only its keys move to the next node;

Question 1

What is the difference between REST and GraphQL?

Accepted Answer

## REST vs GraphQL

- **REST:** resources exposed as multiple endpoints, manipulated with HTTP verbs. Simple and cacheable, but a screen often needs **several round trips**, and each endpoint returns a fixed shape (**over- or under-fetching**).
- **GraphQL:** a **single endpoint** with a typed schema. The client sends a query describing **exactly** the fields it wants, and gets them back in **one round trip** — great for nested data and varied clients.

Question 2

What is the difference between horizontal and vertical scaling?

Accepted Answer

## Two ways to add capacity - **Vertical scaling (scale up):** make one machine more powerful — more CPU, RAM, faster disk/NVMe. - **Horizontal scaling (scale out):** add more machines and spread load across them, usually behind a **load balancer**.

Question 3

When would you choose SQL vs NoSQL?

Accepted Answer

## SQL vs NoSQL

It comes down to your **data shape**, **consistency needs**, and **scale/access pattern** — not fashion.

- **SQL (relational):** a fixed schema of tables with relationships, **ACID** transactions, rich joins and ad-hoc queries. Scales **up** easily; scaling **out** (sharding) takes work.
- **NoSQL:** a family of stores — **document** (Mongo), **key-value** (Redis, DynamoDB), **wide-column** (Cassandra), **graph** (Neo4j). Flexible/!schema, built to scale **out**, high write thr

Question 4

What is idempotency and why does it matter?

Accepted Answer

## Idempotency

An operation is **idempotent** if performing it **many times has the same effect as performing it once**. `GET`, `PUT`, and `DELETE` are idempotent; **`POST` is not** (two POSTs = two resources).

It matters because the network is unreliable: a client times out and **retries**, or a queue delivers **at-least-once**. Without idempotency a retry double-charges a card or creates duplicate orders. The fix is an **idempotency key**: the client sends a unique key per logical operation;

Question 5

How do distributed systems detect node failures?

Accepted Answer

## Failure detection

Nodes signal liveness with **heartbeats**: each node periodically says 'I'm alive'. If a node misses heartbeats for longer than a **timeout**, it's marked **suspect**, then **dead**. The fundamental catch: you **cannot distinguish a slow node from a dead one** over an unreliable network — so detectors trade off **speed vs false positives**.

Question 6

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

Accepted Answer

## Back-of-the-envelope estimation The goal isn't precision — it's an **order-of-magnitude** sanity check that tells you whether you need one box or a thousand, and where the bottleneck is. Work top-down from users to load:

Question 7

What is database connection pooling?

Accepted Answer

## Connection pooling

Opening a database connection is **expensive** — TCP handshake, TLS, and auth round trips — and databases cap how many connections they can handle. A **connection pool** keeps a fixed set of connections **open and reusable**: a request **borrows** one, runs its query, and **returns** it. If all are busy, requests **queue** until one frees up.

Question 8

What is the publish-subscribe pattern?

Accepted Answer

## Publish-subscribe In **pub/sub**, publishers send messages to a **topic**, and the broker **fans out** a copy to **every** subscriber of that topic. Publishers and subscribers never reference each other — they're fully **decoupled**, and you can add subscribers without touching the publisher.

Question 9

What are the three pillars of observability?

Accepted Answer

## The three pillars of observability

Observability is being able to **ask new questions about your system from the outside** without shipping new code. The three classic signal types:

- **Metrics** — cheap numeric time series (QPS, latency p99, error rate, CPU). Best for **dashboards and alerting**; aggregate, low cardinality.
- **Logs** — timestamped, detailed event records. Best for **debugging the specifics** of what happened; high volume, searchable.
- **Traces** — the path of a **single

Question 10

What is consistent hashing?

Accepted Answer

## The problem it solves

If you place keys with `hash(key) % N` across N servers, then **changing N** (adding/removing a server) remaps **almost every key** — catastrophic for a cache or sharded store. **Consistent hashing** fixes this: adding/removing a node only moves about **K/N** keys.

## How it works

Map both **nodes and keys** onto a circular hash space (the *ring*). A key is owned by the **first node clockwise** from its position. Remove a node and only its keys move to the next node;

System Design Interview Library

Question Catalog

What is the difference between REST and GraphQL?

What is the difference between horizontal and vertical scaling?

When would you choose SQL vs NoSQL?

What is idempotency and why does it matter?

How do distributed systems detect node failures?

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

What is database connection pooling?

What is the publish-subscribe pattern?

What are the three pillars of observability?

What is consistent hashing?

What is an API gateway?

What is a load balancer and what strategies does it use?

When would you use WebSockets vs polling vs SSE?

When do you use a read replica vs a cache?

Why prefer stateless services and how do you handle sessions?

Explain database indexing and B-trees

What is database replication?

What is the difference between optimistic and pessimistic locking?

What is a CDN and how does it work?

What is the difference between throttling and rate limiting?

What are blue-green and canary deployments?

What is a message queue and why use one?

How does caching improve system performance?

What indexing strategies improve database performance?

What is backpressure and how do you handle it?

What is a Bloom filter and when is it useful?

Design a URL shortener (TinyURL)

How do you design for high availability?

What is leader election in distributed systems?

How would you design a news feed system?

How would you design a distributed cache?

How would you design a notification system?

How do you make a payment system reliable against retries?

How would you design a real-time chat system?

How would you design a file storage service like Dropbox?

What are event sourcing and CQRS?

How would you design a 'nearby drivers' / proximity search?

How would you design Twitter's timeline at scale?

What is the CAP theorem?

How would you design a typeahead/autocomplete system?

What is database sharding?

What is two-phase commit and its drawbacks?

How would you design a rate limiter?

How would you design an analytics/metrics pipeline?

How would you design a URL shortener like TinyURL?

What is a write-ahead log (WAL)?

What are the trade-offs of microservices vs a monolith?

What is the circuit breaker pattern?

What is the difference between strong and eventual consistency?

How would you design a distributed key-value store?

What is a read/write quorum?

What is the saga pattern for distributed transactions?

Difficulty Distribution

Hiring Companies

Tested Topics

Study Guide