Deep dives, organized into
study paths.

A single-page curriculum — Day-zero kubectl through CKA-prep, with curated books, courses, labs, certifications, and hands-on environments.

Replication, consensus, time, partial failure — the four problems every distributed system has to solve.

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.

B-trees, LSM, MVCC, isolation, WAL, replication. The pieces every storage engine assembles differently.

REST, gRPC, GraphQL, Protobuf, Thrift, JSON, WebSockets, webhooks — and the engineering decisions (versioning, auth, idempotency) underneath them all.

Processes, threads, the scheduler, virtual memory, file systems, IPC, syscalls. The kernel layer your code lives on top of.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.