System Design Courses

What system design is, why it matters, how to think about trade-offs, and the core vocabulary you will use throughout this course.

How browsers talk to servers, the request-response cycle, stateless vs. stateful communication, and the foundational model behind every web application.

DNS resolution, TCP/IP, HTTP/HTTPS, WebSockets, and the network layers that connect every component in a distributed system.

Relational vs. non-relational databases, ACID properties, indexing strategies, and choosing the right storage engine for your data model.

Cache layers from browser to CDN to application to database. Eviction policies, cache invalidation, write-through vs. write-back, and why it is called one of the hardest problems in computer science.

Layer-4 vs. Layer-7 balancing, round-robin, least connections, consistent hashing, health checks, and how to distribute traffic across a fleet.

Vertical vs. horizontal scaling, read replicas, leader-follower replication, partitioning, sharding strategies, and handling data growth at scale.

Decoupling producers from consumers, pub/sub patterns, exactly-once delivery, backpressure, dead-letter queues, and event-driven architecture.

Monolith vs. microservices, domain boundaries, service discovery, inter-service communication, data ownership, and the real cost of distribution.

REST conventions, GraphQL query language, gRPC and protocol buffers, API versioning, pagination, idempotency, and contract-first development.

Hash rings, virtual nodes, minimal disruption on node addition or removal, and how distributed caches and databases use consistent hashing under the hood.

Consistency, availability, and partition tolerance. PACELC, eventual consistency, consensus algorithms, vector clocks, and the realities of distributed computing.

Token bucket, leaky bucket, sliding window algorithms. Distributed rate limiting, API gateway integration, and protecting services from abuse.

Content delivery networks, PoP architecture, cache hierarchies, edge functions, origin shielding, and minimizing latency for global users.

Metrics, logs, and traces. SLIs, SLOs, SLAs, alerting strategies, distributed tracing, and building systems you can actually debug in production.

End-to-end design of a URL shortening service. Requirements gathering, encoding strategy, database design, redirect flow, and analytics at scale.

Real-time messaging architecture. Connection management, message delivery guarantees, presence, group chats, push notifications, and offline sync.

Fan-out strategies, feed ranking, content storage, timeline generation, celebrity problem, and building a feed that scales to millions of users.

Relational, document, and graph models. When to use each, hybrid approaches with PostgreSQL JSONB, and multi-model databases.

LSM trees vs. B-trees, SSTables, column-oriented storage, in-memory databases, and the trade-offs between write amplification, read amplification, and space amplification.

JSON, Protocol Buffers, Avro, Thrift. Forward and backward compatibility, schema registries, and contract-first development for evolving systems.

Single-leader, multi-leader, and leaderless replication. Quorums, CRDTs, conflict resolution, replication lag, and consistency guarantees.

Key-range vs. hash partitioning, local and global secondary indexes, rebalancing strategies, request routing, and handling hot spots.

ACID in practice, read committed, snapshot isolation, serializability, write skew, 2PC, saga pattern, and exactly-once processing.

Raft, Paxos, ZooKeeper, etcd. Leader election, FLP impossibility, linearizability vs. serializability, fencing tokens, and distributed locks.

MapReduce, Spark, Kafka internals, event sourcing, CQRS, change data capture, stream joins, windowing, and exactly-once semantics.

ER diagrams, normalization through BCNF, strategic denormalization, NoSQL schema patterns, index design, and zero-downtime migrations.

Key numbers every engineer should know, DAU to QPS formulas, storage and bandwidth estimation, the 80/20 caching rule, and worked examples.

UUID, Snowflake, ULID, ticket servers, and database auto-increment. Trade-offs between sortability, uniqueness, size, and scalability.

Password hashing, JWT, OAuth 2.0, SSO, TLS handshakes, encryption at rest and in transit, API security, CORS, and CSRF protection.

Push, SMS, email, and in-app notifications. Provider adapters, preference management, rate limiting, retry logic, and delivery analytics.

Chunked uploads, transcoding pipelines, adaptive bitrate streaming (HLS/DASH), CDN distribution, recommendation engines, and cost optimization.

Test your understanding of chapters 1-4: system design basics, client-server model, networking, and databases.

Validate your knowledge of caching, load balancing, database scaling, and message queues.

Microservices, APIs, consistent hashing, and the CAP theorem: prove you understand the design patterns.

Rate limiting, CDNs, monitoring, and everything you need to run reliable systems in production.

Apply everything you have learned to real-world design scenarios covering URL shorteners, chat systems, and social feeds.

Covers chapters 19-23: data models, storage engines, schema evolution, replication, and partitioning.

Test chapters 24-26: transactions, consensus, and stream processing consistency trade-offs.

Validate chapters 27-30: schema design, estimation, unique IDs, and security/auth patterns.

Challenge yourself with chapters 31-32: notification and video streaming architecture.