Practical system design guides with visual diagrams. Built for engineers who want to understand distributed systems deeply, not just memorize interview patterns.
IP addresses, OSI model layers, TCP vs UDP, and DNS resolution — the networking foundation every system designer needs.
Load balancing algorithms, L4 vs L7 balancers, health checks, sticky sessions, and when to use each strategy in production systems.
How server clusters work, active-passive vs active-active modes, leader election, quorum, and coordination services like ZooKeeper and etcd.
Cache types, eviction policies, write strategies, cache invalidation, and distributed caching with Redis and Memcached.
How CDNs work, push vs pull models, caching at the edge, and when to use a CDN in system design.
How forward and reverse proxies work, their differences, and how to apply them for security, load balancing, and caching.
How to measure availability with nines, eliminate single points of failure, design for redundancy and failover, and reason about the consistency trade-off.
Vertical vs horizontal scaling, stateless design, database scaling strategies, and how to design systems that handle 10x traffic without rewriting everything.
Block, file, and object storage explained. RAID levels, NAS vs SAN, HDFS, and how to choose the right storage type for your system design.
What databases and database management systems actually do, the components under the hood, common database types, and the key challenges you face designing data layers at scale.
How relational databases work: ACID guarantees, schema design, indexes, query planning, and when SQL is the right choice for your system.
Document, key-value, wide-column, and graph databases explained. When NoSQL outperforms SQL, what you give up, and how to pick the right type for your workload.
A direct comparison across consistency, scalability, schema flexibility, and query power. How to choose the right model for your system.
Primary-replica topology, synchronous vs asynchronous replication, replication lag, multi-primary conflicts, and automated failover strategies.
B-tree and hash indexes, composite index column ordering, covering indexes, partial indexes, write overhead, and how to read EXPLAIN output to diagnose slow queries.
Normal forms 1NF through BCNF, how redundancy causes update anomalies, and when to deliberately denormalize with materialized views and embedded documents for read performance.
ACID transaction guarantees — atomicity, isolation levels, durability via WAL — and the BASE model of eventual consistency for distributed systems.
Consistency, Availability, and Partition Tolerance: why distributed systems can guarantee only two, CP vs AP system trade-offs, and real-world implications.
How PACELC extends CAP by adding the latency vs consistency trade-off that governs every request during normal operation — PA/EL, PC/EC, and tunable systems.
What database transactions are, how ACID properties are enforced, isolation levels, concurrency anomalies, and how WAL and MVCC make atomicity and durability possible.
Two-phase commit, the Saga pattern, choreography vs orchestration, and the outbox pattern — how to achieve atomicity across multiple services without a global lock.
How to partition a database horizontally across multiple servers: choosing a shard key, range vs hash sharding, avoiding hot spots, cross-shard queries, and resharding.
The hash ring, virtual nodes, and why consistent hashing remaps only 1/N keys when a node is added — used in Cassandra, DynamoDB, Memcached, and distributed load balancers.
How to split a monolithic database by function — independent schemas, autonomous teams, and the trade-offs around cross-database joins and distributed transactions.
Common architectural patterns for structuring distributed systems — from foundational N-tier layering to event-driven and microservice designs.
Reliability, observability, and operational patterns that keep distributed systems running in production — logging, monitoring, rate limiting, and more.
Guides covering logging, monitoring, alerting, rate limiting, circuit breakers, and other production reliability patterns are on the way.
End-to-end system design walkthroughs — designing systems like URL shorteners, social feeds, ride-sharing platforms, and video streaming services from scratch.
End-to-end case studies applying every concept from the curriculum to real-world system design problems are on the way.
