0/75 done

Every chapter

75 chapters in 8 parts, and 8 labs. Parts build on each other from the processor upward, but every chapter says what it assumes, so you can start wherever your problem is.

The Machine

7/7

CPU Architecture for Software Engineers

Pipelines, superscalar issue, branch prediction, SIMD.

Memory Hierarchy & Cache Coherence

Cache lines, MESI, false sharing, NUMA. The 100x hiding in a struct layout.

The Memory Model & Atomics

Acquire, release, seq_cst. What the compiler and the CPU may reorder.

Virtual Memory & Page Tables

Page tables, the TLB, faults, huge pages, mmap, copy-on-write.

Allocators & Memory Management

malloc internals, arenas, fragmentation, and when the allocator is the bottleneck.

Speculative Execution, Spectre & the Mitigation Tax

The CPU runs code you never called. Meltdown, Spectre, and what KPTI and retpolines cost your syscalls.

GPUs for Systems Engineers

SIMT, warps, HBM, PCIe and NVLink. Why a GPU is a throughput machine and what that means for the code that feeds it.

The Operating System

10/10

Processes, Threads & Scheduling

EEVDF and CFS, context-switch cost, cgroup CPU throttling.

Syscalls, Interrupts & the Kernel Boundary

The trap, the vDSO, what a syscall costs, and how io_uring removes it.

Filesystems & the Page Cache

Inodes, extents, journaling, and what fsync actually guarantees.

Block Devices & SSDs

NVMe queues, the FTL, write amplification, why SSD latency is bimodal.

The Linux Networking Stack

sk_buff to socket: NAPI, epoll, zero-copy, eBPF and XDP.

Containers from Scratch

Namespaces, cgroups v2, overlayfs, seccomp. Docker with the magic removed.

systemd & Process Supervision

Units, dependency ordering, socket activation, cgroup delegation, journald.

Linking, Loading & How a Process Starts

execve to main: ELF, the dynamic loader, the PLT and GOT, relocations, and why startup is slow.

Virtualization, Hypervisors & microVMs

VM exits, nested page tables, virtio, and how Firecracker boots a VM in 125 ms.

eBPF: Running Your Code in the Kernel

The verifier, maps, hooks and the JIT. How one bytecode ended up running observability, networking and security.

Concurrency

5/5

Locking Primitives, End to End

Mutex, futex, spinlock, RW lock, condvar, down to the CAS and the wait queue.

Lock-Free & Wait-Free Programming

CAS, the ABA problem, hazard pointers, epoch reclamation, RCU.

Concurrency Models

Threads, async, actors, green threads, work stealing, function colouring.

Contention, Queueing & Tail Latency

Lock ordering, convoys, priority inversion, and where p99 comes from.

Concurrent Data Structures

Lock striping, concurrent hash maps, ring buffers, the LMAX disruptor.

Data & Storage Engines

10/10

Storage Engine Internals

B+tree versus LSM, page layout, the write-ahead log, the buffer pool.

Transactions & Isolation Levels

MVCC, snapshot isolation, write skew, and what serializable costs.

Query Planning & Execution

Volcano versus vectorized, join algorithms, cost estimation, index selection.

PostgreSQL Deep Dive

The heap, vacuum and xid wraparound, TOAST, WAL shipping, replication.

Redis Internals

The event loop, listpacks and skiplists, expiry, forks, cluster. The single-thread myth.

Kafka & the Log as a Primitive

ISR, acks, exactly-once, and the page-cache trick that makes it fast.

Columnar & Analytical Engines

Parquet layout, vectorized execution, late materialization, ClickHouse and DuckDB.

Caching, Properly

LRU, LFU, W-TinyLFU, stampedes, invalidation, coherence across a fleet.

Stream Processing

Event time, watermarks, windows, barrier checkpoints, and what exactly-once really covers.

How typing two words returns the best ten of ten million products in milliseconds: inverted indexes, BM25, WAND.

Distributed Systems

7/7

Time, Clocks & Ordering

Lamport clocks, vector clocks, hybrid logical clocks, TrueTime, and NTP reality.

Consensus: Raft, Paxos & Leases

Raft line by line, why Paxos is harder to read, and what a quorum read costs.

Replication & Consistency Models

Linearizable, sequential, causal, eventual. CRDTs and quorum arithmetic.

Partitioning & Rebalancing

Consistent hashing, range versus hash, hot shards, resharding without downtime.

Failure Detection & Membership

Gossip, SWIM, phi accrual, split brain, and why a timeout is a design choice.

Distributed Transactions

2PC, sagas, the outbox, idempotency keys, and exactly-once as marketing.

Distributed Training

A 70B model is 16 GPUs too big and 200 years too slow. Data, tensor and pipeline parallelism, the network, and surviving failures.

Cloud Infrastructure

8/8

Object Storage: S3 Internals

The keymap, erasure coding, strong consistency, multipart, storage classes.

VPC & Cloud Networking

CIDR, route tables, ENIs, NAT, encapsulation, and what cross-AZ traffic costs.

Load Balancing & Traffic Management

L4 versus L7, ECMP and Maglev, connection draining, health checks that lie.

DNS, TLS & the Edge

Resolution path, the handshake, cert chains, anycast, CDN cache keys.

Compute Abstractions

VMs, Firecracker microVMs, Lambda cold starts, and how a pod gets placed.

IAM & the Security Boundary

Policy evaluation order, STS, least privilege, the confused deputy.

Kubernetes Internals

kubectl apply writes one record and exits. Follow the watches, reconcile loops and kubelet that turn it into three running pods.

RPC, gRPC & QUIC

Protobuf on the wire, gRPC over HTTP/2, why one lost packet stalls every stream, and how QUIC moves the transport onto UDP.

Designing & Running Systems

6/6

The System Design Method

Back-of-envelope numbers, capacity first, and knowing which box to draw.

Metrics, logs, traces. Cardinality, sampling, Prometheus and OpenTelemetry internals.

Reliability Engineering

SLO arithmetic, error budgets, retries with jitter, circuit breakers, load shedding.

Performance Engineering

Flame graphs, perf, USE and RED, and benchmarks that are not lies.

Queueing, Capacity & Scaling

Little's Law, M/M/1, the universal scalability law, autoscaling that oscillates.

Systems Interview Mastery

How to structure a design answer, the rubric, and the question behind the question.

System Design Case Studies

22/22

Designing WhatsApp

A billion phones online at once, messages that arrive exactly where they should, and a server that can't read them.

Millions of moving cars, one request, a match in two seconds: hexagons, road graphs and the assignment problem.

Designing YouTube

Upload once, play anywhere without a stall: resumable uploads, a transcoding DAG, caches inside ISPs, DASH manifests and buffer-based bitrate.

Designing Stripe

A tunnel eats the reply and she taps Pay again. Idempotency keys, double-entry ledgers and signed webhooks make sure she pays once.

Five people on four continents inside a fifth of a second: RTP, NAT traversal, SFUs, video layers, jitter buffers and congestion control.

Designing ChatGPT

Words streaming within a second: prefill and decode, continuous batching, PagedAttention, prefix caching and speculative decoding.

Designing Google Maps

Draw any part of the world instantly and route across a continent with live traffic: tile pyramids, contraction hierarchies and ETAs.

Designing a Distributed Job Scheduler

Forty thousand customers to charge at midnight, once, whatever breaks: timing wheels, leases, idempotent jobs and the midnight herd.

Designing Valorant

Two players fire within milliseconds. How a 128-tick authoritative server decides who hit whom first, when every screen shows an old world.

Designing Netflix Recommendations

Forty rows, the titles in each, a picture on every one, chosen in a second: embeddings, nearest-neighbour graphs, bandits and experiments.

Designing Figma

Two designers edit one file at once, one in a train tunnel: OT vs CRDTs, per-property last-writer-wins and fractional indexing.

Designing Twitter's Home Timeline

One post to 300 followers, another to 100 million: fan-out on write vs read, Redis timelines, Snowflake IDs, Earlybird and ranking.

Designing Dropbox

Save a 2 GB project, see it everywhere, never lose an offline edit: 4 MB blocks, rolling hashes, three trees, Magic Pocket.

Designing Ticketmaster

Millions of fans, 70,000 seats, 10:00 sharp: seat holds that expire, signed queue tokens, random pre-queues and cached seat maps.

Designing Discord

One message, a million people online in one server: Snowflake-bucketed partitions, ScyllaDB, request coalescing and Elixir relays.

Designing JioHotstar: Live Cricket at Scale

Dhoni walks out and millions tap Play at once. Live segments, request collapsing, multi-CDN steering and scaling before the crowd.

₹20 for chai moves between two banks that share nothing, in two seconds. Switches, VPAs, debit-then-credit, deemed payments and reconciliation.

Designing Zerodha and the Stock Exchange

Meera taps Buy at 9:15. Follow her order through risk checks and leased lines into NSE's order book, and the price back out.

Designing Amazon's Cart and Checkout

Prime Day at midnight: a cart that never refuses a write, vector clocks, 1,000 deal units for a million taps, one order each.

Designing Cloudflare

A shop under a multi-terabit flood, a shopper who never notices: anycast, dosd fingerprints in XDP, Unimog, Pingora, isolates, Quicksilver.

Designing LeetCode

Two minutes left, a stranger's C++ hits the judge. Sandboxes from isolate to Firecracker, fair timing, checkers, rankings, winnowing.

Designing Notion

Everything is a block. A tree with parent-pointer permissions, Postgres sharded into 480 shards then tripled to 96 hosts, and SQLite in the browser.

The Labs

8/8

A CAS succeeding, then failing. Two threads on one counter, one cache line.

Drag utilization toward 1.0 and watch the latency curve go vertical.

An election and a log replication, message by message. Drop any one of them.

Storage Engine Lab

The same keys into a B+tree and an LSM. Page splits on one side, compaction on the other.

Consistent Hashing Lab

Add and remove nodes from a ring. Count exactly which keys move.

Cache Eviction Lab

LRU, LFU and W-TinyLFU on one trace, hit rate updating per access.

Two transactions, one row. Produce write skew, then prevent it.

Packet Path Lab

One packet from write() to the wire and back, through every layer that touches it.