System Design Interview — Examples & Questions

The foundational properties every distributed system must balance: scalability, reliability, availability, efficiency, and manageability. Understand these before diving into any system design interview.

Load balancers distribute incoming requests across server pools to maximize throughput, minimize latency, and avoid overloading any single server. Covers algorithms, health checks, layer 4 vs layer 7, and session persistence.

Caching stores the results of expensive operations in fast in-memory storage so subsequent requests are served instantly. Covers cache-aside, write-through, eviction policies (LRU), cache stampede prevention, and CDN caching.

Sharding splits a large database into smaller, independently managed pieces (shards) spread across multiple servers. Covers horizontal vs vertical partitioning, consistent hashing, and common sharding problems.

Indexes are data structures that allow the database to find rows without scanning the entire table. Covers B-tree indexes, composite indexes, write overhead, and when NOT to index.

Proxies sit between clients and servers to add filtering, caching, logging, SSL termination, and anonymity. Covers forward proxies, reverse proxies, and open proxies.

Redundancy eliminates single points of failure by having multiple copies of components. Replication keeps those copies in sync. Covers primary-replica replication, synchronous vs asynchronous, and multi-master.

SQL databases offer ACID guarantees and rich query capabilities. NoSQL databases sacrifice some consistency for horizontal scalability and schema flexibility. Know when to use each.

The CAP Theorem states that a distributed system can provide at most two of three guarantees: Consistency, Availability, and Partition Tolerance. Every distributed database is a CAP trade-off.

Consistent hashing distributes keys across servers such that adding or removing a server remaps only K/N keys (where K is keys and N is servers) — not all keys. Essential for distributed caches and databases.

Three techniques for pushing data from server to client in real time: long-polling (oldest), Server-Sent Events (unidirectional push), and WebSockets (full-duplex bidirectional). Know when to use each.

Understand the critical difference between a system that is slow for everyone versus one that breaks under load. Learn how to design for both performance and scalability from the start.

Two fundamental performance metrics that every system designer must understand: how fast a single request completes (latency) and how many requests the system handles per second (throughput).

High availability requires two complementary strategies: failover (detecting failure and switching to a backup) and replication (keeping backup copies of data and services ready). Learn active-passive vs active-active failover and how to measure the nines.

DNS translates human-readable domain names into IP addresses. Understanding DNS hierarchy, record types, TTLs, and routing strategies is fundamental to designing globally distributed, highly available systems.

A CDN caches content at globally distributed edge nodes, reducing latency for users worldwide and offloading traffic from your origin servers. Learn how CDNs work, when to use push vs pull, and how to design around CDN limitations.

A reverse proxy sits in front of your servers, handling SSL termination, caching, compression, and request routing. Understand how reverse proxies differ from load balancers and when to use each.

Microservices decompose a monolith into small, independently deployable services. Learn when microservices make sense, how services find each other via service discovery, and the key tradeoffs of distributed service architectures.

Asynchronous processing decouples the request-response cycle from expensive work, enabling higher throughput, better fault tolerance, and smoother user experiences under load. Learn message queues, task queues, and back pressure.