Ctrl K

Beginner → Advanced

System Design: Basic to Advanced

Every concept explained from zero, with interactive animations of how each piece works in the normal case, under failure and at the edges. Read once, understand fully.

54 modules · 311 lessons · 144.3 h of reading · 25 available now

Start the course

Module 1

Networking Foundations

How computers find each other and talk: clients and servers, what a server is, state, addresses, packets, routing, DNS, TCP/UDP/TLS, network devices, security boundaries, web and app servers, and diagnostics.

  1. 1.1Client–Server Architecture and the Request–Response CycleWho asks, who answers, and exactly what travels in an HTTP request and response. 30 min
  2. 1.2What Is a Server? Hardware, Software and How One Machine Serves ThousandsThe machine and the program: listening on a port, handling many clients at once, the kinds of server, and where servers live. 32 min
  3. 1.3Stateless vs Stateful Servers, Cookies and SessionsHow a stateless protocol remembers you: sessions, cookies, tokens, and what breaks when you scale. 34 min
  4. 1.4Client–Server vs Peer-to-PeerCentralised vs decentralised: control, failure, scaling and security, with BitTorrent and WebRTC. 24 min
  5. 1.5Network Layers and Encapsulation (OSI and TCP/IP)Why networking is built in layers, and how your data gets wrapped in header after header. 35 min
  6. 1.6Addresses: IP, MAC, Ports, ARP and DHCPThe three addresses on every packet, public vs private, subnets, and how a device gets and resolves them. 34 min
  7. 1.7Routing, the Internet Path and NATHop-by-hop forwarding, default gateways, ISPs and BGP, and how NAT lets a whole home share one IP. 42 min
  8. 1.8DNS: The Internet’s PhonebookThe four kinds of DNS server, the full lookup step by step, record types, TTL and caching, and what goes wrong. 42 min
  9. 1.9TCP, UDP, TLS and QUIC: Connections and SecurityReliable vs fast transport, the handshakes, loss and retransmission, encryption, HTTP/3 and HSTS. 38 min
  10. 1.10TCP in Depth: Header, Flow Control and Congestion ControlEvery header field, loss recovery and SACK, the receive window, slow start and AIMD, CUBIC and BBR, the bandwidth-delay product, Nagle and delayed ACK. 45 min
  11. 1.11Hub, Switch, Router and ISPWhat each box in a network does, which layer it works at, and how a switch learns. 36 min
  12. 1.12Firewall, Forward vs Reverse Proxy, and VPNThe guards and go-betweens of a network: what each one hides, allows, blocks and protects. 38 min
  13. 1.13Web Servers and App Servers: Nginx, Apache, Caddy and the RestWhat a web server actually does, how Apache and Nginx work inside, app servers and their interfaces, and how they fit together in production. 42 min
  14. 1.14ICMP, Ping and TracerouteHow engineers test reachability, measure latency and find exactly where a path breaks. 34 min
  15. 1.15Capstone: What Happens When You Open google.comEverything in this module working together, from pressing Enter to pixels on the screen. 36 min

Module 2

HTTP, Real-Time and Data on the Wire

HTTP versions, methods, headers and caching, the real-time options from polling to WebRTC, the cryptography behind TLS, and how data is serialized and evolves.

  1. 2.1HTTP/1.0 to HTTP/3, and the Other Application ProtocolsWhat each version fixed: persistent connections, multiplexing, header compression, QUIC; why server push died; where SMTP, SSH and friends fit. 55 min
  2. 2.2HTTP Methods and Status CodesSafe, idempotent and cacheable methods, and what every status-code family tells the client. 50 min
  3. 2.3Headers, Keep-Alive, Compression and CORSThe headers that matter, reusing connections, gzip vs Brotli vs zstd, and the browser’s cross-origin rules end to end. 40 min
  4. 2.4HTTP Caching: Cache-Control, ETag and ValidationFreshness, revalidation, Vary, shared vs private caches and serving stale content safely. 38 min
  5. 2.5Real-Time I: Short Polling, Long Polling and SSEThree ways for a server to tell a browser something changed, and what each one costs. 45 min
  6. 2.6Real-Time II: WebSockets, WebRTC and Scaling ThemFull-duplex connections, peer-to-peer media, choosing between the five options, and fanning out to millions of sockets. 55 min
  7. 2.7Cryptography for Engineers: Keys, Certificates and CAsSymmetric vs asymmetric encryption, the certificate chain, how a CA vouches for a site, and automated short-lived certificates. 50 min
  8. 2.8TLS 1.2 vs TLS 1.3 Handshakes, and Mutual TLSEvery message of both handshakes, forward secrecy, 0-RTT, and services proving their identity to each other. 45 min
  9. 2.9Serialization: JSON, XML, Protobuf, Avro and ThriftText vs binary formats, their size and speed, and which one to pick for APIs, events and storage. 45 min
  10. 2.10Schema Evolution and CompatibilityChanging a message format without breaking old readers or writers: backward, forward and full compatibility. 40 min

Module 3

Operating System Essentials

What the OS does under every server: processes, threads, scheduling, memory and the I/O models behind Nginx and Node.js.

  1. 3.1Processes and ThreadsWhat a process owns, what threads share, and what each costs to create.Coming soon
  2. 3.2Concurrency vs Parallelism, and Context SwitchingTaking turns vs working at once, and the hidden price of switching between threads.Coming soon
  3. 3.3Thread Pools and DeadlockReusing threads, sizing a pool, the four conditions for deadlock and how to break them.Coming soon
  4. 3.4Virtual Memory, Paging and SwapHow every process gets its own address space, page tables and faults, and why swap is a different thing.Coming soon
  5. 3.5I/O Models: Blocking, Non-Blocking, epoll and io_uringHow one thread can watch ten thousand sockets, from select and poll to epoll and io_uring.Coming soon
  6. 3.6The Event Loop and Virtual ThreadsHow Node.js and Nginx serve many clients on few threads, what blocks the loop, and the virtual-thread alternative.Coming soon

Module 4

Servers, Virtualization and the Cloud

From one app per physical server to virtual machines to renting them by the minute: hypervisors, how hardware is shared, virtual networks, and why the cloud won.

  1. 4.1The Bare-Metal Era and Its ProblemsOne server, one OS, one app: wasted capacity, slow scaling and the cost of running your own machines.Coming soon
  2. 4.2Virtualization and HypervisorsType 1 vs type 2, VT-x and AMD-V, CPU rings, trapping privileged instructions, paravirtualization, and the vCPU, vRAM, vDisk and vNIC a VM sees.Coming soon
  3. 4.3Sharing Hardware: Overcommit, Ballooning and Thin DisksOverprovisioning CPU and RAM, shared vs reserved resources, page sharing, ballooning and swap, passthrough, thick vs thin disks, noisy neighbours and live migration.Coming soon
  4. 4.4Virtual Networking: vSwitch, VLAN, SR-IOV and OverlaysHow two VMs talk on the same host and across hosts, isolating them with VLANs, bypassing the switch with SR-IOV, and VXLAN-style overlays.Coming soon
  5. 4.5Why the Cloud Won: the Technical ViewRenting VMs by the minute, elasticity, global reach, IaaS to SaaS, offload cards, bare-metal instances and micro-VMs.Coming soon

Module 5

Algorithm Complexity

How to measure what code costs in time and memory, read it straight from the code, and reason about averages over many operations.

  1. 5.1Measuring Cost: Time, Space and Big OWhy we count steps instead of seconds, auxiliary vs total space, and what Big O really promises.Coming soon
  2. 5.2The Complexity Classes: O(1) to O(n!)Each class with a real example, and how many operations each needs at n = 10,000.Coming soon
  3. 5.3Reading Complexity from CodeTen rules for loops, nesting and calls, and the simplification rules that drop constants and smaller terms.Coming soon
  4. 5.4Best, Average and Worst Case; O, Ω and Θ; RecursionCases and bounds are different ideas, and how to find the time and stack space of a recursive function.Coming soon
  5. 5.5Amortized AnalysisWhy appending to a dynamic array is O(1) on average, with the aggregate, accounting and potential methods.Coming soon
  6. 5.6Time–Space Trade-offs and Cheat SheetsBuying speed with memory, common misconceptions, and the operation-cost tables worth knowing by heart.Coming soon

Module 6

Linear Data Structures

Arrays, strings, linked lists, stacks, queues, heaps and ring buffers: how each sits in memory, what it costs, and where systems use it.

  1. 6.1Data Structures, ADTs and Memory LayoutThe difference between an abstract type and its implementation, and contiguous vs linked memory.Coming soon
  2. 6.2Arrays and Dynamic ArraysIndex arithmetic, resizing, cache locality and why arrays are faster than their Big O suggests.Coming soon
  3. 6.3Strings and Character EncodingsImmutability, building strings efficiently, and ASCII vs UTF-8 vs UTF-16.Coming soon
  4. 6.4Linked ListsSingly, doubly and circular lists, the pointer tricks interviews love, and when a list beats an array.Coming soon
  5. 6.5Stacks and the Call StackLast in, first out: undo, bracket matching, expression evaluation and how function calls use a stack.Coming soon
  6. 6.6Queues and DequesFirst in, first out, double-ended queues, and bounded queues as the first taste of backpressure.Coming soon
  7. 6.7Priority Queues and Binary HeapsSift-up, sift-down, heapify in O(n), and heaps behind schedulers and timer queues.Coming soon
  8. 6.8Ring BuffersA fixed array that wraps around: logs, audio, network cards and lock-free producer–consumer queues.Coming soon
  9. 6.9Choosing a Linear StructureAll eight side by side, real-world picks, and an interview drill.Coming soon

Module 7

Trees and Graphs

Binary search trees and balancing, heaps and tries, and graphs with the traversals and algorithms systems are built on.

  1. 7.1Trees, Binary Search Trees and BalancingTree vocabulary, traversals, BST search and insert, and how AVL and red-black trees stay balanced.Coming soon
  2. 7.2Heaps in Depth and TriesTop-K with heaps, and prefix trees behind autocomplete and routing tables.Coming soon
  3. 7.3Graphs: BFS, DFS, Shortest Paths and MoreRepresentations, traversals, Dijkstra, topological sort, union-find and minimum spanning trees.Coming soon

Module 8

Hashing

Hash tables from the inside, collisions and resizing, cryptographic hashes, and consistent hashing for spreading data across machines.

  1. 8.1Hash Tables and Hash FunctionsTurning a key into a slot, what makes a hash function good, and hash flooding attacks.Coming soon
  2. 8.2Collisions: Chaining, Open Addressing and TombstonesThe birthday paradox, chains vs probing, and why deleting from an open-addressed table needs a tombstone.Coming soon
  3. 8.3Load Factor and RehashingWhen a table must grow, what a resize costs, and how Redis rehashes a little at a time.Coming soon
  4. 8.4Hashing in Real SystemsCaches, deduplication, indexes, sets and counters, and how language hash maps are implemented.Coming soon
  5. 8.5Cryptographic Hashes and Content AddressingOne-way, collision-resistant hashes, why MD5 and SHA-1 are broken, and storing data by its hash.Coming soon
  6. 8.6Consistent Hashing and Virtual NodesWhy modulo hashing reshuffles everything, the hash ring, virtual nodes, and rendezvous hashing.Coming soon

Module 9

Searching, Sorting and Recursion

Binary search and its variants, the sorts that matter including sorting data bigger than memory, and recursion and backtracking.

  1. 9.1Searching and Binary SearchLinear vs binary search, the off-by-one traps, and searching on the answer.Coming soon
  2. 9.2Sorting Basics, Merge Sort and External SortStability and in-place sorting, divide and conquer, and k-way merging for data that does not fit in memory.Coming soon
  3. 9.3Quick Sort and Choosing a SortPartitioning, pivot choice and the worst case, and what real libraries use (TimSort, introsort).Coming soon
  4. 9.4RecursionBase cases, the call stack, recursion trees, memoization and stack overflow.Coming soon
  5. 9.5BacktrackingChoose, explore, undo: permutations, N-Queens and Sudoku, and how pruning makes it fast.Coming soon

Module 10

Storage Data Structures

The structures databases and search engines keep on disk: B-trees, B+ trees, LSM trees, skip lists and inverted indexes.

  1. 10.1RAM vs Disk, Pages, and the B-TreeWhy disk structures are wide and shallow, and how a B-tree searches, inserts and splits.Coming soon
  2. 10.2The B+ TreeKeys in the inner nodes, rows in linked leaves, fast range scans, and the fan-out maths behind a 3-level index.Coming soon
  3. 10.3LSM Trees: the Write Path and the Read PathWrite-ahead log, memtable, SSTables, and how a read checks memory, Bloom filters and levels.Coming soon
  4. 10.4LSM Compaction and AmplificationSize-tiered vs levelled compaction, and the read, write and space amplification trade-off.Coming soon
  5. 10.5Skip ListsA sorted linked list with express lanes, and why Redis sorted sets and memtables use one.Coming soon
  6. 10.6Inverted IndexesFrom documents to terms to posting lists, tokenizing, ranking, and compressing postings.Coming soon

Module 11

Probabilistic and Spatial Data Structures

Small structures that answer big questions approximately, and the ones that index the map.

  1. 11.1Bloom Filters“Definitely not” or “probably yes”: sizing, false-positive maths, and where databases and caches use them.Coming soon
  2. 11.2HyperLogLog and Count-Min SketchCounting distinct users in 12 KB and estimating heavy hitters in a stream.Coming soon
  3. 11.3Merkle TreesHashes of hashes: comparing huge datasets cheaply, in Git, Cassandra and blockchains.Coming soon
  4. 11.4Quadtrees and GeohashFinding what is near you: splitting the map into cells, and the edge cases at cell borders.Coming soon

Module 12

OOP and Clean Code

Modelling with objects, the four pillars, SOLID and the habits that keep code easy to change.

  1. 12.1Classes, Objects, Encapsulation and AbstractionWhat a class models, constructors, hiding state behind behaviour, and showing only what callers need.Coming soon
  2. 12.2Inheritance, Polymorphism and CompositionReusing and overriding behaviour, why composition usually wins, and interfaces vs abstract classes.Coming soon
  3. 12.3SOLIDThe five principles, each with code that breaks it and code that follows it.Coming soon
  4. 12.4DRY, KISS, YAGNI, Dependency Injection and Anti-PatternsSimple rules of thumb, wiring dependencies from outside, and the smells to recognise early.Coming soon

Module 13

Design Patterns

All 23 Gang of Four patterns plus the everyday ones, each with the problem it solves and when not to use it.

  1. 13.1Creational: Singleton, Factory, Abstract Factory, Builder, PrototypeFive ways to control how objects are created.Coming soon
  2. 13.2Structural I: Adapter, Decorator, Facade, ProxyWrapping objects to fit, extend, simplify or guard them.Coming soon
  3. 13.3Structural II: Composite, Bridge, FlyweightTrees of objects, splitting abstraction from implementation, and sharing state to save memory.Coming soon
  4. 13.4Behavioral I: Observer, Strategy, State, CommandNotifying listeners, swapping algorithms, state machines, and requests as objects.Coming soon
  5. 13.5Behavioral II: Chain, Template, Iterator, Mediator, Memento, Visitor, InterpreterThe remaining seven behavioural patterns, compared side by side.Coming soon
  6. 13.6Beyond GoF: Repository, Null Object, Object PoolPatterns you will meet in every codebase, and a guide to choosing a pattern at all.Coming soon

Module 14

UML and Concurrency in Code

Drawing a design so others can read it, and writing code that stays correct when many threads run it.

  1. 14.1Class DiagramsClasses, visibility, and the six relationships from association to composition.Coming soon
  2. 14.2Sequence, Use-Case, Activity and State DiagramsShowing who calls whom, what users do, how work flows and how objects change state.Coming soon
  3. 14.3Race Conditions, Thread Safety and LocksLost updates in a counter, critical sections, mutexes, read-write locks and their costs.Coming soon
  4. 14.4Thread-Safe Singleton, Producer–Consumer and Lock-Free BasicsDouble-checked locking, blocking queues, compare-and-swap, latches and the memory model.Coming soon

Module 15

Low-Level Design Case Studies

A repeatable method for object design interviews, applied to eleven classic problems.

  1. 15.1The LLD Method, and a Parking LotHLD vs LLD, from requirements to classes to code, worked through a parking lot.Coming soon
  2. 15.2Vending Machine and ElevatorTwo state machines: coins and stock, and scheduling lifts between floors.Coming soon
  3. 15.3Movie Tickets and Hotel BookingHolding a seat or room without double-booking it under concurrent users.Coming soon
  4. 15.4LRU Cache and LoggerO(1) eviction with a hash map and a list, and a thread-safe logger with levels and sinks.Coming soon
  5. 15.5Expense Splitting and a Library SystemBalances and settling debts, and books, members, loans and fines.Coming soon
  6. 15.6Chess and Snake & LadderBoards, pieces, moves and turns: modelling games with rules.Coming soon
  7. 15.7Rate Limiter (LLD)A pluggable, thread-safe limiter class with token bucket and sliding window strategies.Coming soon
  8. 15.8The LLD Interview PlaybookWhat interviewers check, a 45-minute plan, and practice problems: Tic-Tac-Toe, ATM, KV store, pub-sub, scheduler.Coming soon

Module 16

Scalability and Availability

Growing a system, keeping it up, and recovering when a whole site is lost.

  1. 16.1Scalability: Vertical vs HorizontalA bigger machine or more machines: limits, costs and what has to change in the app.Coming soon
  2. 16.2Stateless ServicesMoving state out of the server so any instance can answer any request.Coming soon
  3. 16.3Availability, the Nines, and SLI / SLO / SLADowntime per nine, availability of components in series and in parallel, and promises to customers.Coming soon
  4. 16.4Reliability, Fault Tolerance, Durability and SPOFsUp vs correct, surviving failures, never losing data, MTBF and MTTR, and finding single points of failure.Coming soon
  5. 16.5Redundancy, Failover and Split BrainActive-passive vs active-active, how failover is detected and done, and two leaders at once.Coming soon
  6. 16.6Disaster Recovery: RPO, RTO and the StrategiesHow much data and time you can lose, and backup-restore, pilot light, warm standby and multi-site.Coming soon

Module 17

Performance and Estimation

Latency, throughput and percentiles, the numbers every engineer should know, and back-of-the-envelope sizing.

  1. 17.1Latency, Throughput and Little’s LawHow they relate, why latency explodes near full utilisation, and Amdahl’s law.Coming soon
  2. 17.2Percentiles and Tail LatencyWhy averages lie, p50 to p99.9, and how fan-out turns rare slowness into the common case.Coming soon
  3. 17.3Latency Numbers Every Engineer Should KnowFrom an L1 cache hit to a transatlantic round trip, and powers of two for sizing.Coming soon
  4. 17.4Back-of-the-Envelope: QPS, Storage and BandwidthTurning daily users into requests per second, bytes per year and network load.Coming soon
  5. 17.5Memory, Cache Size and Server CountSizing a cache from read traffic, servers from capacity, and a checklist of common mistakes.Coming soon

Module 18

Distributed Trade-offs: CAP, PACELC and Consistency

What changes when data lives on many machines, and the precise meaning of “consistent”.

  1. 18.1What a Distributed System IsMany machines acting as one, partial failure, and the network you cannot trust.Coming soon
  2. 18.2The CAP TheoremDuring a partition you choose consistency or availability, and what real databases actually do.Coming soon
  3. 18.3PACELCThe trade-off that exists even without a partition: latency vs consistency.Coming soon
  4. 18.4Consistency ModelsLinearizable to eventual, read-your-writes and causal, and linearizability vs serializability.Coming soon

Module 19

Relational Databases

ACID, indexes, normalization, isolation and locking, query tuning, and what the storage engine does underneath.

  1. 19.1The Relational Model and ACIDTables, keys and joins, and what atomicity, consistency, isolation and durability guarantee.Coming soon
  2. 19.2Indexes and Index TypesB-tree, hash, composite, covering, partial and full-text indexes, and when an index is not used.Coming soon
  3. 19.3Normalization and Denormalization1NF to BCNF with one table taken step by step, and when duplicating data is the right call.Coming soon
  4. 19.4Isolation Levels and AnomaliesDirty reads, non-repeatable reads, phantoms, lost updates and write skew, and which level stops which.Coming soon
  5. 19.5Optimistic vs Pessimistic Locking, and MVCCLocking rows vs checking versions, and how databases give every transaction its own snapshot.Coming soon
  6. 19.6Query Optimization, N+1, Materialized Views and Connection PoolsReading a query plan, killing N+1 queries, precomputed views, and pooling connections.Coming soon
  7. 19.7Inside the Storage Engine: WAL, SSTables, B-Tree vs LSMHow a committed write survives a crash, and why some engines read faster and others write faster.Coming soon

Module 20

NoSQL and Specialized Databases

Key-value, document, wide-column and graph stores, distributed SQL, search engines, time-series and vector databases.

  1. 20.1NoSQL, BASE and Key-Value StoresWhy NoSQL appeared, BASE vs ACID, and the simplest store of all.Coming soon
  2. 20.2Document and Wide-Column StoresMongoDB-style documents and Cassandra-style partitions, and modelling data around queries.Coming soon
  3. 20.3Graph Databases, SQL vs NoSQL, and Polyglot PersistenceRelationships as first-class data, choosing a store, and using several in one system.Coming soon
  4. 20.4NewSQL and Distributed SQLSQL and transactions across regions: Spanner, CockroachDB, TiDB and Aurora DSQL.Coming soon
  5. 20.5Search Engines: ElasticsearchShards, replicas and analyzers, relevance scoring, and keeping search in sync with the database.Coming soon
  6. 20.6Time-Series and Vector DatabasesStoring metrics over time with downsampling, and similarity search over embeddings.Coming soon

Module 21

Scaling Databases

Splitting data across machines and copying it between them, with the failure modes of each.

  1. 21.1Partitioning and Sharding StrategiesRange, hash, directory and geo sharding, and how to choose a shard key.Coming soon
  2. 21.2Hot Partitions, Federation and ReshardingWhen one shard takes all the traffic, splitting by function, and moving data live.Coming soon
  3. 21.3Replication: Leader-Follower, Multi-Leader, LeaderlessThree topologies, sync vs async, and physical vs logical replication.Coming soon
  4. 21.4Read Replicas and Replication LagScaling reads, reading stale data, and read-your-writes tricks.Coming soon
  5. 21.5Leader Election, Split Brain and QuorumPromoting a new primary safely, fencing the old one, and why majorities matter.Coming soon

Module 22

Storage, Transactions and Data Operations

Block, file and object storage, transactions across services, change data capture, backups and migrations.

  1. 22.1Block, File and Object StorageThree ways to store bytes, what each is good at, and how object stores reach eleven nines.Coming soon
  2. 22.2Storage Tiering and ArchivalHot, warm, cold and archive tiers, and lifecycle rules that move data automatically.Coming soon
  3. 22.3Distributed Transactions: 2PC and 3PCPrepare and commit across databases, the blocked coordinator, and why 3PC does not save you.Coming soon
  4. 22.4Change Data CaptureStreaming every row change from the database log to caches, search and analytics.Coming soon
  5. 22.5Backups, Point-in-Time Recovery and 3-2-1Full, incremental and continuous backups, restoring to a second, and testing restores.Coming soon
  6. 22.6Schema Migrations Without Downtime, and Soft DeleteExpand and contract, backfills, online schema changes, and deleting without losing history.Coming soon
  7. 22.7Production Database Engineering: an E-Commerce ExampleMonitoring, capacity and tuning, then a whole store’s data architecture without overselling.Coming soon

Module 23

Caching

Why caches work, eviction, read and write patterns, keeping caches consistent, and the failure modes that take sites down.

  1. 23.1Why Cache: Hit Ratio and the Latency GapWhat a cache is, where the speed comes from, and how hit ratio decides if it pays off.Coming soon
  2. 23.2Eviction Policies: LRU, LFU, FIFO and TTLWhat to throw out when memory is full, and how Redis approximates LRU.Coming soon
  3. 23.3Read Patterns: Cache-Aside, Read-Through, TTL and WarmingWho fills the cache, how long entries live, and preloading before traffic arrives.Coming soon
  4. 23.4Write Patterns and InvalidationWrite-through, write-behind and write-around, and the hardest problem: invalidation.Coming soon
  5. 23.5Keeping Cache and Database ConsistentThe race that leaves stale data, delete vs update, leases and delayed double delete.Coming soon
  6. 23.6Cache Penetration, Avalanche and StampedeThree ways a cache stops protecting the database, and the fixes for each.Coming soon
  7. 23.7Hot Keys, Big Keys and Distributed CachesSpreading a cache across nodes with hash slots, and handling keys that are too popular or too large.Coming soon
  8. 23.8Redis vs Memcached vs ValkeyData structures, threading, persistence with RDB and AOF, licensing, and which to pick.Coming soon

Module 24

Cache Layers and CDNs

Every place a response can be cached between the user and the database, and how CDNs serve the world from the edge.

  1. 24.1Where Caches Live: Client, Application, DatabaseBrowser and app caches, in-process vs remote caches, and the database’s own buffer pool.Coming soon
  2. 24.2CDNs: Origin, Edge and PoPHow a request reaches the nearest edge, cache keys, hits and misses, and purging.Coming soon
  3. 24.3Push vs Pull CDNs, Cloudflare and CloudFrontWho uploads the content, two real providers, origin shield and request collapsing.Coming soon
  4. 24.4Edge ComputingRunning code at the edge: personalization, auth checks and A/B tests close to the user.Coming soon
  5. 24.5Multi-Level Caching and Cache DesignStacking caches, choosing keys and TTLs, sizing, and what to never cache.Coming soon
  6. 24.6Monitoring Caches, and an E-Commerce Caching DesignThe metrics that matter, then caching a whole store from product pages to the cart.Coming soon

Module 25

Load Balancing

Spreading traffic across servers, from layer 4 vs layer 7 to global load balancing across regions.

  1. 25.1Load Balancers: Layer 4 vs Layer 7What a load balancer does, and the difference between routing connections and routing requests.Coming soon
  2. 25.2Load Balancing AlgorithmsRound robin, weighted, least connections, least response time, IP hash and power of two choices.Coming soon
  3. 25.3Health Checks, Sticky Sessions and LB High AvailabilityRemoving sick servers, pinning users, draining connections, and keeping the balancer itself up.Coming soon
  4. 25.4DNS Load Balancing and GSLBBalancing with DNS answers, sending users to the nearest healthy region, and failing over globally.Coming soon

Module 26

API Design

REST, GraphQL, gRPC and SOAP, and the details that make an API safe to evolve: versioning, pagination, idempotency and errors.

  1. 26.1APIs and REST Best PracticesResources, URLs, methods and status codes used well.Coming soon
  2. 26.2GraphQLSchemas, queries and mutations, the N+1 trap and DataLoader, and GraphQL in production.Coming soon
  3. 26.3gRPC, SOAP, and Choosing an API StyleProtobuf over HTTP/2, streaming, balancing long-lived connections, SOAP, and a decision table.Coming soon
  4. 26.4Versioning and PaginationURL, header and media-type versions, deprecation, and offset vs cursor pagination.Coming soon
  5. 26.5Idempotency Keys and WebhooksMaking a retried payment charge once, and calling clients back safely with signed, retried webhooks.Coming soon
  6. 26.6OpenAPI, Error Formats and Sync vs Async APIsDescribing an API, problem-details errors, preventing lost updates with ETags, and 202-then-poll.Coming soon

Module 27

API Gateways

The front door for many services: what a gateway does, the main products, and how it differs from a load balancer and a reverse proxy.

  1. 27.1What an API Gateway DoesRouting, auth, rate limits, transformation, aggregation, caching and observability in one place.Coming soon
  2. 27.2Nginx, Kong and Amazon API Gateway; Gateway vs LB vs Reverse ProxyThree real gateways, and a clear line between three boxes that look alike.Coming soon
  3. 27.3A Scalable E-Commerce Traffic ArchitectureDNS to CDN to gateway to services, with BFFs, canaries and the advanced pieces in place.Coming soon

Module 28

Fault Tolerance and Resilience

Keeping a system working while its parts fail: timeouts, retries, circuit breakers, bulkheads, load shedding and chaos testing.

  1. 28.1Timeouts and Partial FailureWhy every network call needs a deadline, and how to choose one.Coming soon
  2. 28.2Retries, Exponential Backoff and JitterRetrying without causing a storm, retry budgets, and why only idempotent work is safe to retry.Coming soon
  3. 28.3Circuit BreakersClosed, open and half-open: failing fast so a sick dependency can recover.Coming soon
  4. 28.4Bulkheads, Fallbacks and Graceful DegradationIsolating resources, serving something useful when a part is down, and hedged requests.Coming soon
  5. 28.5Load Shedding and Chaos EngineeringDropping work on purpose to survive overload, and breaking things deliberately to find weaknesses.Coming soon

Module 29

Rate Limiting

Protecting services from overload and abuse: the five algorithms and how to enforce a limit across many servers.

  1. 29.1Why and Where to Rate LimitAbuse, fairness and cost, limiting by user, key or IP, and where in the stack to enforce it.Coming soon
  2. 29.2Token Bucket and Leaky BucketAllowing bursts vs smoothing traffic, and GCRA.Coming soon
  3. 29.3Fixed Window, Sliding Log and Sliding CounterThe boundary burst problem and two ways around it, with their memory costs.Coming soon
  4. 29.4Distributed Rate Limiting with RedisA shared counter with atomic Lua scripts, races, failing open vs closed, and RateLimit headers.Coming soon

Module 30

Messaging and Queues

Decoupling services with queues and pub/sub, delivery guarantees, ordering, retries, dead letters and backpressure.

  1. 30.1Sync vs Async, and DecouplingWhat breaks when services wait on each other, and how a queue in between helps.Coming soon
  2. 30.2Message Queues, Pub/Sub and Competing ConsumersPoint-to-point vs broadcast, and many workers sharing one queue.Coming soon
  3. 30.3RabbitMQExchanges, bindings and queues, acks and prefetch, publisher confirms and quorum queues.Coming soon
  4. 30.4Amazon SQS, SNS and EventBridgeVisibility timeouts, standard vs FIFO, fan-out with SNS, event routing, and the real limits.Coming soon
  5. 30.5Delivery Semantics and Idempotent ConsumersAt-most-once, at-least-once and “exactly-once”, and making duplicates harmless.Coming soon
  6. 30.6Message OrderingWhy order breaks, per-key ordering with partitions and FIFO groups, and how retries reorder.Coming soon
  7. 30.7Retry Queues, Delay Queues, Poison Messages and DLQsRetrying later, delaying work, spotting a message that always fails, and parking it safely.Coming soon
  8. 30.8BackpressureWhat happens when producers outrun consumers, and the ways to push back.Coming soon

Module 31

Kafka and Event Streaming

The distributed log: partitions, consumer groups, replication and exactly-once, plus Kinesis and when to use a stream instead of a queue.

  1. 31.1The Kafka Log: Topics, Partitions and OffsetsAn append-only log split into partitions and segments, brokers, and KRaft instead of ZooKeeper.Coming soon
  2. 31.2Consumer Groups and RebalancingSharing partitions among consumers, committing offsets, the new rebalance protocol and share groups.Coming soon
  3. 31.3Replication, Acks and RetentionLeaders and in-sync replicas, acks=all, the high watermark, retention, compaction and tiered storage.Coming soon
  4. 31.4Producers, Batching and Exactly-OncePartitioners, batching and compression, idempotent producers and transactions.Coming soon
  5. 31.5Amazon KinesisShards and partition keys, hot shards, and how it compares with Kafka.Coming soon
  6. 31.6Queue vs Stream, Kafka vs RabbitMQDelete-on-read vs replayable log, and a decision guide.Coming soon

Module 32

Event-Driven Data Patterns

Event sourcing, schema registries, the transactional outbox and sagas: keeping data correct across services.

  1. 32.1Events vs Commands, and Event SourcingStoring what happened instead of current state, snapshots, replays, and deleting personal data.Coming soon
  2. 32.2Schema RegistrySchema IDs in every message, compatibility checks, and safe upgrades of producers and consumers.Coming soon
  3. 32.3Transactional Outbox and InboxThe dual-write bug, writing the event in the same transaction, relaying it, and deduplicating on receipt.Coming soon
  4. 32.4Sagas: Choreography vs OrchestrationLong business transactions as steps with compensations, and when each style fits.Coming soon
  5. 32.5Advanced Messaging and an E-Commerce CapstoneClaim-check and other patterns, then an order flow built end to end with everything in this part.Coming soon

Module 33

Identity and Access

Who you are and what you may do: sessions and tokens, JWT, OAuth, OpenID Connect, SSO, access models and zero trust.

  1. 33.1Authentication vs Authorization; Sessions vs TokensProving identity vs granting permission, and server sessions vs self-contained tokens.Coming soon
  2. 33.2JWT and API KeysWhat is inside a JWT, verifying signatures, expiry and refresh, revocation, and API keys for machines.Coming soon
  3. 33.3OAuth 2.0 and PKCEDelegated access, the authorization code flow with PKCE, client credentials, and the deprecated grants.Coming soon
  4. 33.4OpenID Connect, SSO, SAML, Passkeys and MFALogging in with another provider, one login for many apps, and phishing-resistant sign-in.Coming soon
  5. 33.5RBAC, ABAC and ReBACPermissions by role, by attribute and by relationship, and policy engines.Coming soon
  6. 33.6Zero Trust and Web Application FirewallsNever trust the network, verify every request, and filtering attacks at layer 7.Coming soon

Module 34

Data Security and Common Attacks

Encrypting and storing secrets properly, the attacks every web system faces, DDoS, audit logs and privacy law.

  1. 34.1Encryption at Rest and in Transit, and Envelope EncryptionWhat each protects against, key management, and data keys wrapped by a master key.Coming soon
  2. 34.2Storing PasswordsSalting and slow hashes: bcrypt, scrypt and Argon2 with current parameters and password rules.Coming soon
  3. 34.3Secrets ManagementKeeping keys out of code, vaults, rotation and short-lived credentials.Coming soon
  4. 34.4SQL Injection and XSSHow untrusted input becomes code in the database or the browser, and the defences that work.Coming soon
  5. 34.5CSRF, SSRF, IDOR and the OWASP Top 10Forged requests, server-side request forgery, broken object access, and the current OWASP list.Coming soon
  6. 34.6DDoS ProtectionVolumetric, protocol and application attacks, and absorbing them with anycast, scrubbing and limits.Coming soon
  7. 34.7Audit Logging, PII and GDPRTamper-evident logs, finding and minimising personal data, and the rights users have over it.Coming soon
  8. 34.8Designing a Secure System End to EndA banking-style system layer by layer, and a checklist for real projects.Coming soon

Module 35

Architectural Styles

Monoliths, layers and hexagons, microservices, event-driven, serverless and peer-to-peer: what each buys and costs.

  1. 35.1Monolith and Modular MonolithOne deployable unit, its real strengths, and keeping it modular inside.Coming soon
  2. 35.2Layered and Hexagonal ArchitecturePresentation, business and data layers, ports and adapters, and Clean/Onion architecture.Coming soon
  3. 35.3Microservices, Database-per-Service and Bounded ContextsSplitting by business capability, owning your data, and drawing boundaries with DDD.Coming soon
  4. 35.4Event-Driven ArchitectureServices reacting to events instead of calling each other, and the debugging cost.Coming soon
  5. 35.5ServerlessFunctions on demand, cold starts, limits, cost at low and high traffic.Coming soon
  6. 35.6Peer-to-Peer ArchitectureSystems with no central server, and where they make sense today.Coming soon

Module 36

Microservice Patterns

Finding services, sidecars and meshes, composing APIs, CQRS, and migrating away from a monolith safely.

  1. 36.1Service DiscoveryClient-side vs server-side discovery, registries, and DNS-based discovery.Coming soon
  2. 36.2Sidecars and Service MeshMoving retries, mTLS and telemetry out of the app, and sidecarless ambient mode.Coming soon
  3. 36.3API Composition and Backend-for-FrontendJoining data from many services, and one backend per client type.Coming soon
  4. 36.4CQRSSeparate models for writes and reads, keeping them in sync, and read-your-writes.Coming soon
  5. 36.5Strangler Fig, Anti-Corruption Layer and Contract TestingReplacing a legacy system piece by piece, isolating its model, and testing services against each other.Coming soon

Module 37

Multi-Tenancy and Multi-Region

Serving many customers on shared infrastructure, cells that limit blast radius, and running in several regions at once.

  1. 37.1Multi-Tenancy: Silo, Pool and BridgeIsolation vs cost, tenant-aware data models, and noisy neighbours.Coming soon
  2. 37.2Cell-Based Architecture and Shuffle ShardingMany small copies of the whole system, a cell router, and limiting how many users one failure hits.Coming soon
  3. 37.3Active-Active Multi-Region and Conflict ResolutionWriting in every region, last-writer-wins vs CRDTs, and what “zero downtime” really costs.Coming soon
  4. 37.4Choosing and Combining ArchitecturesHow the patterns relate, a comparison chart, and a decision guide.Coming soon

Module 38

Consensus and Coordination

Getting machines to agree: quorums, Paxos and Raft, the limits of what is possible, and distributed locks done safely.

  1. 38.1Consensus, Leader Election, Quorum and Split BrainWhat agreement means, why majorities prevent two leaders, and what happens without them.Coming soon
  2. 38.2PaxosProposers, acceptors and ballots, the two phases, and Multi-Paxos.Coming soon
  3. 38.3RaftTerms, elections with randomized timeouts, log replication, commit rules and leader crashes.Coming soon
  4. 38.4Byzantine Faults and FLP ImpossibilityNodes that lie, and why no algorithm can guarantee agreement in a fully asynchronous network.Coming soon
  5. 38.5Distributed Locks: Redis SET NX and RedlockLocking with expiry, safe release, Redlock across five nodes, and its known weaknesses.Coming soon
  6. 38.6ZooKeeper Locks, Fencing Tokens and LeasesEphemeral sequential nodes, stopping a paused client from writing, and time-limited ownership.Coming soon

Module 39

Time, Ordering and Conflicts

Why clocks cannot be trusted, logical clocks that order events, and data types that merge conflicts on their own.

  1. 39.1Physical Clocks, Skew and NTPDrift and skew, how NTP corrects them, monotonic clocks, and TrueTime.Coming soon
  2. 39.2Lamport Timestamps and Hybrid Logical ClocksHappened-before, ordering events without real time, and clocks that mix both.Coming soon
  3. 39.3Vector ClocksDetecting concurrent writes, merging clocks, and handing conflicts to the application.Coming soon
  4. 39.4CRDTs and Operational TransformationCounters, sets and text that merge without coordination, and how collaborative editors work.Coming soon

Module 40

Failure Detection and Unique IDs

Knowing which machines are alive, spreading membership by gossip, and generating unique IDs without a single counter.

  1. 40.1Heartbeats and Phi-Accrual Failure DetectionSlow or dead? Fixed timeouts vs a suspicion level that adapts to the network.Coming soon
  2. 40.2Gossip and MembershipSpreading information like a rumour, cluster membership, and SWIM.Coming soon
  3. 40.3UUIDs and Ticket ServersUUID versions including time-ordered v7, and handing out ranges from a central counter.Coming soon
  4. 40.4Snowflake IDs and ULIDs64 bits of time, machine and sequence, clock rollback, and sortable alternatives.Coming soon

Module 41

Dynamo-Style Replication

How leaderless stores like Cassandra stay available: rings, quorums, hinted handoff, read repair and anti-entropy.

  1. 41.1Dynamo Architecture, Virtual Nodes and Replication FactorThe ring, preference lists, and how many copies each key gets.Coming soon
  2. 41.2N, R, W, Sloppy Quorum and Hinted HandoffTuning reads and writes, and staying writable when replicas are down.Coming soon
  3. 41.3Read Repair, Anti-Entropy and Conflict ResolutionFixing stale replicas on read and in the background with Merkle trees, and resolving siblings.Coming soon
  4. 41.4Everything Together: a Ride-Sharing BackendConsensus, locks, clocks, IDs, gossip and quorums working in one system.Coming soon

Module 42

Analytics Storage

Storing data for analysis rather than transactions: warehouses, lakes, columnar files, lakehouses and dimensional models.

  1. 42.1OLTP vs OLAPMany small transactions vs a few huge scans, and why one database rarely does both well.Coming soon
  2. 42.2Data Warehouses and Data LakesSchema on write vs schema on read, Redshift and S3, and the swamp to avoid.Coming soon
  3. 42.3Columnar Storage and ParquetWhy storing columns together makes analytics fast, encodings, and row groups.Coming soon
  4. 42.4The Lakehouse: Delta Lake, Iceberg and HudiTransactions and time travel on a data lake, table formats, and bronze, silver and gold layers.Coming soon
  5. 42.5Star and Snowflake SchemasFacts and dimensions, and handling dimensions that change over time.Coming soon

Module 43

Batch Processing and Pipelines

Moving and transforming data in bulk: ETL and ELT, MapReduce, Spark, and orchestrating it all with Airflow.

  1. 43.1Data Pipelines, ETL vs ELT, and dbtExtracting, transforming and loading, where the transform happens, and SQL-first modelling.Coming soon
  2. 43.2MapReduce and HadoopMap, shuffle and reduce on a word count, HDFS, and why the ideas outlived the tools.Coming soon
  3. 43.3Apache SparkRDDs and DataFrames, lazy evaluation, stages and shuffles, and skew.Coming soon
  4. 43.4Workflow Orchestration with AirflowDAGs, tasks and operators, scheduling and backfills, with Airflow 3.Coming soon
  5. 43.5Airflow in ProductionExecutors, retries and SLAs, sensors, idempotent tasks and the mistakes to avoid.Coming soon

Module 44

Stream Processing

Processing data as it arrives: Flink and Spark Structured Streaming, windows and watermarks, and Lambda vs Kappa.

  1. 44.1Batch vs Stream, and Apache FlinkBounded vs unbounded data, stateful operators, checkpoints and exactly-once.Coming soon
  2. 44.2Spark Structured StreamingMicro-batches, the streaming table model, and output modes.Coming soon
  3. 44.3Windows, Watermarks and Late EventsTumbling, sliding and session windows, event time vs processing time, and joining streams.Coming soon
  4. 44.4Lambda vs Kappa ArchitectureA batch layer plus a speed layer, or one stream for everything.Coming soon
  5. 44.5A Production Data Platform End to EndAll the pieces in one architecture, data quality, lineage and cost.Coming soon

Module 45

Containers and Kubernetes

Packaging apps as images and running them reliably at scale with Kubernetes and Helm.

  1. 45.1Containers and DockerImages, layers and registries, writing a Dockerfile, multi-stage builds and the everyday commands.Coming soon
  2. 45.2Volumes, Networking and Compose; VMs vs ContainersKeeping data, connecting containers, running a stack locally, and what a VM gives that a container does not.Coming soon
  3. 45.3Kubernetes ArchitectureThe control plane, worker nodes, and the reconcile loop that drives everything.Coming soon
  4. 45.4Kubernetes ObjectsPods, Deployments, Services, Ingress and Gateway, ConfigMaps and Secrets, limits, PDBs and RBAC.Coming soon
  5. 45.5Probes and AutoscalingLiveness, readiness and startup probes, and scaling pods and nodes.Coming soon
  6. 45.6HelmCharts, values and releases, upgrades and rollbacks.Coming soon

Module 46

Delivery: CI/CD, IaC and Deployments

Shipping changes safely and often: pipelines, infrastructure as code, deployment strategies, feature flags and GitOps.

  1. 46.1DevOps and CI/CD PipelinesBuild, test and deploy on every change, pipeline stages, and the DORA metrics.Coming soon
  2. 46.2Infrastructure as Code and TerraformDeclaring infrastructure, plan and apply, state and locking, and modules.Coming soon
  3. 46.3Deployment Strategies: Rolling, Blue-Green, Canary, ShadowFour ways to release, what each risks, and rolling back a bad release.Coming soon
  4. 46.4Feature Flags and GitOpsSeparating deploy from release, and Git as the source of truth with Argo CD and Flux.Coming soon

Module 47

Observability

Seeing inside a running system: logs, metrics and traces, OpenTelemetry, SLOs and alerts that matter.

  1. 47.1Monitoring vs Observability, Logs and the ELK StackThe three signals, structured logs, and collecting and searching them.Coming soon
  2. 47.2Metrics with Prometheus and GrafanaCounters, gauges and histograms, scraping, PromQL, dashboards, and the RED and USE methods.Coming soon
  3. 47.3Distributed Tracing and OpenTelemetrySpans and context propagation, Jaeger, and one standard for every signal.Coming soon
  4. 47.4SLOs, Error Budgets, Golden Signals and AlertingChoosing SLIs, spending an error budget, burn-rate alerts, and avoiding alert fatigue.Coming soon

Module 48

Cloud and Incident Management

The cloud building blocks in brief, keeping the bill sane, and handling outages like a professional team.

  1. 48.1Regions, AZs and Core Cloud ServicesThe global layout and compute, storage, database and networking at a glance, with links into the AWS course.Coming soon
  2. 48.2Cost OptimizationRight-sizing, commitments and spot, storage tiers, egress, and tagging spend.Coming soon
  3. 48.3Incidents, On-Call and RunbooksSeverity levels and roles, the incident lifecycle, healthy on-call, and runbooks that work at 3 a.m.Coming soon
  4. 48.4Blameless Postmortems, and How It All FitsLearning from failure without blame, then the whole operations picture in one diagram.Coming soon

Module 49

The System Design Interview

A step-by-step method for a 45-minute design interview, worked through a URL shortener.

  1. 49.1The Framework: Requirements and EstimationClarifying scope, functional vs non-functional requirements, and sizing the system.Coming soon
  2. 49.2API and Data ModelDesigning the endpoints and choosing the schema and the database.Coming soon
  3. 49.3High-Level Design, Deep Dive and Trade-offsDrawing the first diagram, picking what to deep-dive, and defending each choice out loud, with a timed walk-through.Coming soon
  4. 49.4Must-Know Topics, Checklist and Golden RulesWhat interviewers listen for, and a checklist to run before you say “done”.Coming soon

Module 50

AI and LLM Systems Basics

What a system designer must know about machine learning in production: training vs serving, how LLMs are served, and embeddings with retrieval.

  1. 50.1ML Systems: Training, Inference and Feature StoresThe ML lifecycle, batch vs online inference, feature stores, model registries and monitoring for drift.Coming soon
  2. 50.2Serving LLMs: Tokens, GPUs, KV Cache and BatchingPrefill vs decode, time to first token, the KV cache, continuous batching, streaming responses and cost per token.Coming soon
  3. 50.3Embeddings, Vector Search and RAGTurning text into vectors, approximate nearest-neighbour indexes, chunking, and grounding answers in your own data.Coming soon

Module 51

Case Studies I: Core Building Blocks

Eight designs that every larger system reuses: short links, pastes, IDs, rate limits, caches, key-value stores, notifications and crawling.

  1. 51.1Design a URL ShortenerShort-code generation (counter, hash, Base62), 301 vs 302, redirects at scale, caching, analytics and abuse.Coming soon
  2. 51.2Design PastebinStoring text blobs in object storage, metadata in a database, expiry, access control and hot pastes.Coming soon
  3. 51.3Design a Unique ID GeneratorSnowflake-style IDs across data centres: bit layout, clock rollback, worker assignment and sortable alternatives.Coming soon
  4. 51.4Design a Distributed Rate LimiterLimiting millions of clients across a fleet with low latency: algorithm choice, shared counters, rules and failure modes.Coming soon
  5. 51.5Design a Distributed CacheA Redis Cluster-style cache: hash slots, replication and failover, resharding, hot keys and client routing.Coming soon
  6. 51.6Design a Distributed Key-Value StoreA Dynamo-style store: partitioning, replication, tunable consistency, conflict handling and repair.Coming soon
  7. 51.7Design a Notification SystemPush, SMS and email at scale: providers, templates, user preferences, retries, deduplication and rate limits.Coming soon
  8. 51.8Design a Web CrawlerURL frontier, politeness and robots.txt, DNS caching, content deduplication, traps, and crawling billions of pages.Coming soon

Module 52

Case Studies II: Social, Media and Search

Eight designs where fan-out, real-time delivery and media dominate: feeds, photos, chat, live and on-demand video, autocomplete, search and collaborative editing.

  1. 52.1Design a Social Media News FeedFan-out on write vs read, the celebrity problem, ranking, feed caches and pagination.Coming soon
  2. 52.2Design a Photo-Sharing AppUploads, image processing and thumbnails, object storage and CDN, follows, likes and the home feed.Coming soon
  3. 52.3Design a Chat App with WebSocketsConnection servers, one-to-one and group delivery, presence, receipts, offline sync, ordering and storage.Coming soon
  4. 52.4Design Live Streaming and Live CommentsIngest, real-time transcoding, low-latency delivery, and fanning out comments and reactions to millions of viewers.Coming soon
  5. 52.5Design a Video Streaming ServiceUpload and chunking, transcoding pipelines, HLS and DASH, adaptive bitrate, CDN placement and recommendations.Coming soon
  6. 52.6Design Autocomplete / TypeaheadTop suggestions from a trie in under 100 ms, building it from query logs, sharding and freshness.Coming soon
  7. 52.7Design a Search EngineCrawl to index to query: inverted indexes, sharding by document vs term, ranking and serving results fast.Coming soon
  8. 52.8Design a Collaborative Document EditorReal-time co-editing with OT or CRDTs, cursors and presence, offline edits, version history and storage.Coming soon

Module 53

Case Studies III: Location, Commerce and Money

Eight designs where correctness under contention matters most: ride sharing, maps, bookings, flash sales, payments, a stock exchange and leaderboards.

  1. 53.1Design a Ride-Sharing AppDriver location updates, quadtree search for nearby drivers, matching, trip state, ETA and surge pricing.Coming soon
  2. 53.2Design a Proximity Service and MapsNearby places with geohash, read-heavy business data, map tiles, routing basics and caching by area.Coming soon
  3. 53.3Design a Ticket Booking SystemSeat maps, temporary seat locks with expiry, payment windows, virtual waiting rooms and no double booking.Coming soon
  4. 53.4Design a Hotel Reservation SystemAvailability by date range, inventory counters vs per-room rows, overbooking policy, search and concurrency.Coming soon
  5. 53.5Design an E-Commerce Flash SaleMillions chasing limited stock: queues in front, atomic stock decrements, distributed locks, and no overselling.Coming soon
  6. 53.6Design a Payment SystemPayment service providers, idempotency keys, a double-entry ledger, sagas across services and daily reconciliation.Coming soon
  7. 53.7Design a Stock ExchangeThe order book and matching engine, determinism and sequencing, market data fan-out, and microsecond latency.Coming soon
  8. 53.8Design a Real-Time LeaderboardRanks with Redis sorted sets, ties, sharding millions of players, and periodic resets.Coming soon

Module 54

Case Studies IV: Infrastructure, Data and AI

Eight designs of the platforms other systems run on: a message queue, object storage, file sync, a job scheduler, monitoring, trending topics, ad-click aggregation and a RAG chatbot.

  1. 54.1Design a Distributed Message QueueBuild your own Kafka: partitioned logs, replication, consumer groups, retention and delivery guarantees.Coming soon
  2. 54.2Design Object StorageBuild your own S3: metadata vs data, placement, replication and erasure coding, multipart upload and durability.Coming soon
  3. 54.3Design File Storage and SyncChunking and deduplication, block-level sync, notifying devices, conflicts and sharing.Coming soon
  4. 54.4Design a Distributed Job SchedulerStoring millions of timed jobs, firing them on time, leases so each runs once, retries and priorities.Coming soon
  5. 54.5Design a Metrics Monitoring and Logging SystemCollecting from thousands of hosts, time-series storage and downsampling, log indexing, querying and alerting.Coming soon
  6. 54.6Design Top-K and Trending TopicsHeavy hitters over a stream with Count-Min sketch and heaps, time windows, and exact vs approximate answers.Coming soon
  7. 54.7Design Ad Click AggregationCounting billions of clicks with stream processing: windows, late events, exactly-once, deduplication and reconciliation.Coming soon
  8. 54.8Design an AI Chatbot with RAGIngesting documents, embeddings in a vector database, retrieval and prompting, streaming answers, guardrails and cost.Coming soon