Learn

The four-step loop that lets you reason about any system at any scale. This is the platform's thesis.

You cannot have consistency, availability, and partition-tolerance all at once. PACELC extends the picture with a latency vs. consistency trade-off when there's no partition.

Numbers before diagrams. How to derive traffic, storage, bandwidth, and cache from a headline DAU number in under 3 minutes.

Two ways to add capacity, and why one usually wins at scale.

What 99.9% vs 99.99% actually means, and what each nine costs.

How to talk about reliability without hand-waving.

Once you say 'stored', you own it forever.

Two axes that pull in opposite directions.

Linearizable, sequential, causal, eventual — and when each is enough.

Two philosophies of correctness under contention.

Why stateless services are cheaper to scale — and where state has to live instead.

When to make the caller wait, and when to fire-and-forget.

Two paradigms for computing over data, and where each wins.

Who initiates? The choice defines your fan-out topology.

The 7-layer model that lets you reason about any network problem. Where each protocol sits and what real systems live at each layer.

The request-response protocol that runs the web.

Reliable-ordered vs fire-and-forget — and when you want the second.

How a name becomes an IP — and how DNS becomes a load balancer.

How the connection becomes private without a shared secret upfront.

Two ways to keep the server talking to the client.

Multiplexing and QUIC — how HTTP got faster after 20 years.

Serving the same IP from many places at once.

The 3-way handshake, sliding window, and how BBR/CUBIC decide how fast to send.

How ClientHello + ServerHello + Finished set up a secure channel in 1 round-trip.

Packet routing vs HTTP-aware routing, health checks, sticky sessions.

Why creating a TCP connection per request kills you at scale.

How the internet's routing table serves the same IP from 300 places at once.

Protobuf + HTTP/2 streaming vs JSON + HTTP/1.1 — when each wins.

How idempotency-keys turn unreliable networks into safe retries — Stripe, Shopify, OpenAI patterns.

A checkout API request from browser click to backend response — DNS, TCP, TLS, LB routing, backend. HTTP vs HTTPS side-by-side.

The taxonomy of database engines: relational, key-value, document, wide-column, graph, time-series, search, vector, and NewSQL — with when to pick each.

Indexes turn table scans into lookups; every index taxes writes.

The data structure inside most relational databases.

Write-optimized storage — how LevelDB, RocksDB, and Cassandra store data.

Read committed, repeatable read, serializable — what each protects against.

How Postgres keeps readers and writers out of each other's way.

Three topologies for the same problem: keep multiple copies in sync.

Range, hash, and consistent-hash — the trade-offs and hot-key traps.

The append-only log that gives databases durability without slow fsyncs everywhere.

How Postgres picks nested-loop vs hash vs merge join — and why one query is 1000x faster than another.

The similarity-search index behind every RAG system in 2025.

How machines agree on one value despite failures. The algorithm underneath leader election.

The ring algorithm behind Cassandra, DynamoDB, Redis Cluster, and every CDN.

Four ways to make N services commit together — with the trade-offs each accepts.

How Lamport clocks + HLC establish causal order without a global clock.

G-Counter, LWW-Register, OR-Set — data structures that merge without conflict.

The R+W>N formula that makes eventually-consistent stores feel consistent.

How Cassandra and Serf propagate cluster state at O(log N) — like disease spread.

The 3 industry patterns for mutual exclusion across machines.

The general problem: how do N machines pick one boss, and how do they replace it when it dies?