Ace the System Design Interview: Concepts and Case Studies

Explore high-level system design concepts and practical interview strategies, using Instagram and Google Drive as examples, and learn to defend design choices with basic principles.

Clarify requirements with the interviewer before designing, focusing on concrete features and scale, then perform capacity calculations, e.g., transactions per second, and iteratively adjust the design.

Design systems must be scalable, handling rising user loads with minimal changes, as illustrated by an Instagram-style example where a simple architecture fails under heavy demand.

Define availability as system uptime, link it to scalability and fault tolerance, and explain targets from two to five nines with their downtime and SLA implications.

Explore decoupling to achieve fault tolerance and prevent tight coupling, so components like YouTube uploads and streaming, Twitter reading and reacting, and Gmail stay resilient when one part fails.

Explore latency and throughput, defining latency as the time a server takes to process a request and throughput as requests per second, with examples like url shorteners and Google search.

Explain scalability and vertical scaling by upgrading a single server to increase throughput and reduce latency, and outline limits when capacity upgrades reach hardware constraints.

Discover how horizontal scalability adds multiple servers behind a load balancer to increase throughput and distribute requests across A, B, and C.

Distribute load with a load balancer to enable horizontal scalability, so the client sees a single entry point while the system scales out or descales using cloud providers.

Increase availability by reducing single points of failure through redundancy, such as load balancers and multiple servers, while recognizing database single points require distributed data stores and syncing.

Load balancers can run on the same machine or a separate one; most mid-size apps use Nginx, Apache, or an http accelerator, identifiable by response headers.

Explore common load balancing policies, round robin, load-based, weighted, and by number of connections, and how servers report status to the load balancer and handle failures.

Leverage stickiness in load balancing to route consecutive requests from the same user to the same server, preserving cache and preventing failures, using sticky sessions via IP or headers.

Contrast synchronous and asynchronous communication between microservices, where a blocking REST call to encrypt a file contrasts with a decoupled workflow using a messaging queue.

Differentiate relational sql databases from non-relational no sql options. Explore examples like mysql, postgres, oracle, mariadb, mongo, neo4j, memcache, and hbase, and learn to use databases for different use cases.

Learn how relational databases organize data in tables, compare row-wise and columnar storage, and understand normalization and denormalization to balance redundancy and query efficiency.

Understand how database indexes, often built as B+ trees, speed reads by targeting columns, while adding slower writes; learn multi-column and sorted indexes and prefix queries.

Learn how database query planners choose which index to use, when multiple indexes exist, and how to read an explain plan to verify index usage and optimize performance.

Explore how distributed data stores use sharding to scale relational databases, partitioning data by country, by name ranges, or hashing, while preserving ACID properties and noting drawbacks.

Explore non-relational NoSQL databases with denormalized data, focusing on document-based stores like MongoDB and DynamoDB and key-value stores like Memcache.

Explore key-value based databases like memcache and their caching role, emphasizing fast access to simple key-value pairs, with the option to store json as strings, unlike document-based databases.

Explore NoSQL document database limits, such as 16 MB document size, and the denormalization approach, with insights on keys, indexes, and varying transaction support.

Learn how NoSQL handles extra load through replicas and distributed sharding, including hash-based distribution like DynamoDB, and explore challenges of node addition, removal, and data consistency.

Explore CAP theorem in distributed data stores, showing how consistency, availability, and partition tolerance trade off; use replication across multiple DB servers and load balancers to illustrate two-of-three choices.

Explore how the CAP theorem guides database choices by weighing availability, consistency, and partition tolerance, with examples from MongoDB and MySQL, and lessons from banking versus social media applications.

Caching accelerates data access by storing frequently used data closer to the processor, bridging disk and RAM, with hardware caches and software caches across client, database, and server levels.

Local caches fail under scaling; distributed global caches provide a shared cache between the load balancer and servers, with consistent hashing and memcache as an example.

Explore cache write policies, including right through, right back, and right around, and assess their impact on consistency, availability, and handling of stale data in cache systems.

Explore cache eviction policies such as least recently used and least frequently used, and see how LRU, LFU, and MRU govern which items to evict when the cache is full.

Explore how a content delivery network uses geographically distributed servers and caching to speed media delivery, reduce latency, and improve reliability, with examples from Google, Netflix, and major providers.

Explore how web notifications work and how the client-initiated polling approach delivers updates. Identify why polling wastes bandwidth, increases server load, and introduces latency in frequent information updates.

Long polling keeps the client request open until the server has data, then responds, with a timeout that prompts the client to re-initiate a new connection.

Establish a lightweight, full-duplex web socket connection between client and server to create a continuous pipeline with no handshake overhead. Enable server-initiated, two-way communication for web notifications.