Deep dives, organized into
study paths.
Single-page curricula. Each path bundles the books, courses, labs, and certifications that actually move you from "I've heard of this" to "I can run it in production." Curated, dated, cited.
→ See the map of the codex 17 sections · 170+ deep dives
Kubernetes, learned properly
A single-page curriculum — Day-zero kubectl through CKA-prep, with curated books, courses, labs, certifications, and hands-on environments.
Distributed systems, from scratch
Replication, consensus, time, partial failure — the four problems every distributed system has to solve.
Programming languages
Three languages, each as a single-page curriculum plus a runtime deep dive — Go, Rust, JavaScript. Twelve mental models, the standard library, concurrency, memory model, and the runtime internals.
Databases, actually understood
B-trees, LSM, MVCC, isolation, WAL, replication. The pieces every storage engine assembles differently.
API design, every wire format
REST, gRPC, GraphQL, Protobuf, Thrift, JSON, WebSockets, webhooks — and the engineering decisions (versioning, auth, idempotency) underneath them all.
Operating systems, from the ground
Processes, threads, the scheduler, virtual memory, file systems, IPC, syscalls. The kernel layer your code lives on top of.
Computer networking
Sockets, bytes on the wire, IP, TCP, UDP, QUIC, TLS, DNS, BGP, routing, NAT, load balancing. The stack that carries every byte your code ever sends — from the foundations a first networking program needs through to the operational details that show up in production.
Computer architecture
The bare-metal foundation underneath every other path on this site. Transistors, ALU, clocks, the instruction cycle, pipelining, branch prediction, out-of-order execution, SIMD, the memory hierarchy, caches and MESI, virtual memory and the TLB, NUMA, PCIe and DMA, SSDs, GPUs, and how the whole thing turns on at boot.
System design
The interview line. Capacity math, storage choice, replication, async work, idempotency, multi-region. Plus a playbook of canonical questions — URL shortener, news feed, chat, rate limiter, notifications — each walked end-to-end with the trade-offs that separate a passing design from a great one.
Performance engineering
Methods that diagnose real systems — USE for resources, RED for services, top-down for CPU work, the roofline model, latency budgets and percentiles, queueing theory, profiling in production, load testing without coordinated omission. The toolkit that turns "it’s slow" into a specific tunable.
Problem-solving
Patterns first, data structures as the substrate. Twenty canonical interview patterns — two pointers, sliding window, hash map, binary search, recursion, BFS/DFS, backtracking, DP, heap, monotonic stack, greedy, union-find, trie, top-sort, bit, linked-list, tree DP, graph algos, math. Plus a full section on practice methodology — the 20-minute rule, spaced repetition, the "explain it back" trick.
Object-oriented design
The low-level design round. Seven canonical OOD problems — LRU cache, parking lot, deck of cards, hash map, call center, chat server, vending machine — each modelled with class diagrams, state machines, and the edge cases that separate good designs from naive ones.
Security — the engineer's chapter
Threat modeling that fits in a working week, secrets management that actually rotates, authentication primitives that compose into a working sign-in flow, and the half-dozen CVE classes that account for almost every real incident.
Cloud — the senior mental model
Compute, storage, networking, identity, managed databases, multi-region, observability, cost. AWS-first because that's what most teams ship on, with GCP and Azure equivalents called out per topic. The eight-topic mental model that survives every cloud reorg.
AI systems, for engineers
How the AI stack actually runs in production. Tokens and embeddings, the transformer, inference and the KV cache, vector search, RAG, agents and tool use, the AI gateway. Written for backend engineers who ship these systems, not for researchers training them.
Observability, done properly
The discipline of knowing what a running system is doing. Logs, metrics, and traces and when to reach for each; OpenTelemetry and distributed tracing; SLOs and error budgets; the cardinality trap; eBPF for zero-instrumentation visibility.
Linux, at the terminal
The investigative layer between shell syntax and kernel theory. Sixteen pages organised by the question you are asking — what is eating my CPU, who holds this port, why is the disk full — each with the five flags that matter, annotated real output, and how it works underneath.