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.

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.

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.

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.

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.

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 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.

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 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.