Push the pieces
yourself.
Push a button, move a slider, and watch the system respond. Each one is a hand-built diagram in motion, paired where it fits with a guide that explains the same machinery in full.
Begin here.
CAP Theorem
Pick two. Toggle the partition. Watch the third guarantee fail.
Consistent Hashing
Add, remove, and move nodes around the ring.
Rate Limiter
Token bucket, leaky bucket, fixed and sliding windows.
Bloom Filter
Tune bits and hashes; watch false-positive rate.
Distributed systems.
Many machines, sometimes wrong.
CAP Theorem
Pick two. Toggle the partition. Watch the third guarantee fail.
Consistent Hashing
Add, remove, and move nodes around the ring.
Database Sharding
Range, hash, and directory strategies compared.
Read/Write Quorum
Tune N, R, W — watch reads and writes succeed or stall.
Isolation Levels
Dirty reads, non-repeatable reads, phantoms — side-by-side.
Rate Limiter
Token bucket, leaky bucket, fixed and sliding windows.
Circuit Breaker
State-machine resilience pattern, with failure playback.
Retry Strategy
Exponential, jittered, decorrelated — load-tested.
Load Balancer
Round-robin, least-conn, hashing, p2c — under real load.
Chaos Playground
Inject latency, packet loss, and node failure at will.
Raft consensus
Five nodes. Kill the leader. Watch the cluster elect a new one and replicate the log.
WAL + crash recovery
Issue writes, kill the process, restart — watch the WAL replay restore consistency.
Distributed cache
4 cache nodes + origin DB. Hot keys, stampedes, node failure, consistent vs modulo hashing, write-through/back/around, single-flight and stale-while-revalidate.
Thundering herd
Four scenarios (accept(), cache, condvar, cron), four fixes (EPOLLEXCLUSIVE, single-flight, signal-vs-broadcast, jitter). Slide N, watch the bar.
Split-brain cluster
5 nodes, click to cut links. Quorum mode refuses writes on the minority; unsafe accepts everywhere and conflicts on heal; LWW reconciles by clock.
Distributed lock
Redlock / ZooKeeper / etcd. Inject GC pauses and network partitions; toggle fencing tokens; watch corruption or rejection.
Data structures.
Shapes that hold information well.
Cache Eviction
LRU, LFU, ARC, TinyLFU compared in real time.
LRU Cache
Watch the list mutate as you read and write.
Storage Engine — B-tree vs LSM
Comparative — same workload, both engines, read/write paths side by side.
B-Tree
Insert, split, rebalance — node by node.
Heap
Sift-up and sift-down with the array-and-tree dual view.
AVL vs Red-Black Tree
Comparative — same input, both trees, rotations side by side.
Segment Tree
Range queries in O(log n) with lazy propagation.
Suffix Tree
How grep, BLAST, and bzip2 search at a billion bytes.
Trie / Autocomplete
Prefix tree walk-through with live lookup.
Bloom Filter
Tune bits and hashes; watch false-positive rate.
Linked List
Singly, doubly, circular — pointers annotated.
Queue & Stack
FIFO, LIFO, priority, deque — visualised.
Decision Tree
Grow, split, prune — classification made visible.
Vector Embedding
Cosine similarity, ANN search, index tradeoffs.
LSM Tree
Memtable, flush, compaction — the storage engine behind RocksDB, Cassandra, DynamoDB.
Red-Black Tree
Self-balancing BST with the five-case rotation rules animated.
Skip List
Coin-flip levels, staircase search — Redis sorted sets in motion.
Algorithms.
Steps that always work.
Big-O race
Slide n; watch O(1) → O(n²) lanes race. Past n=10k they fan out by orders of magnitude.
Sorting Visualiser
Bubble, quick, merge, heap — comparison counts visible.
Binary Search
Leftmost, rightmost, insertion point patterns.
Dijkstra Pathfinding
Shortest path on a grid with weighted obstacles.
A* Pathfinding
Heuristic-guided search — Dijkstra with a goal.
BFS vs DFS
Same graph, two modes. Queue vs stack, level vs depth.
N-Queens (Backtracking)
Watch the recursion try, conflict, and backtrack.
DP — Longest Common Subsequence
Fill the table, trace the LCS back.
Algorithm Visualizer
Explore common algorithms step by step.
Recursion · DP
Naive, memo, tabulate — call stack and tree, side by side.
Networking & protocols.
How endpoints agree.
TCP Handshake
Three-way and four-way, with sequence numbers.
TCP Congestion
Slow start, congestion avoidance, fast recovery.
HTTP Flow
Request lifecycle across client, proxy, origin.
HTTP/2 Streams
Multiplexed frames, dependencies, head-of-line blocking.
HTTP/3 + QUIC
Side-by-side HTTP/2 vs HTTP/3 race; drop a packet, watch the head-of-line difference.
CORS preflight
When does the browser fire an OPTIONS preflight, and why does the real request 403?
gRPC vs REST
Side-by-side wire format, streaming, error model.
JSON vs Protobuf
Size, parse cost, schema evolution.
TCP vs UDP
Two channels, same loss conditions — watch TCP retransmit and UDP drop.
DNS Resolution
Browser → OS → recursive → root → TLD → authoritative, with caches and TTLs.
Databases & SQL.
Persistent state, queried.
Isolation Levels
Dirty reads, non-repeatable reads, phantoms — side-by-side.
WAL + crash recovery
Issue writes, kill the process, restart — watch the WAL replay restore consistency.
SQL JOIN types
Two editable tables, five JOIN types, one live result — see where the NULLs come from.
ACID transactions
Run a transfer, crash mid-transaction, see atomicity roll it back. Add a concurrent reader.
Storage Engine — B-tree vs LSM
Comparative — same workload, both engines, read/write paths side by side.
B-Tree
Insert, split, rebalance — node by node.
SQL query execution
EXPLAIN ANALYZE as an animation. Toggle the index, watch the plan flip.
LSM Tree
Memtable, flush, compaction — the storage engine behind RocksDB, Cassandra, DynamoDB.
Lifecycle & runtime.
The pieces that wake and die.
Container layers
Edit a Dockerfile, rebuild, watch which layers cache-hit and which rebuild slowly.
Event loop
Drop in setTimeout + Promise.then; watch microtasks beat macrotasks every time.
JWT Lifecycle
Issue, verify, rotate, revoke — the full loop.
K8s Rollout
RollingUpdate, surge, unavailable — live deployment.
Pod Eviction
PDBs, node pressure, preemption — playable.
Goroutine Scheduler
GMP model: work stealing, netpoll, preemption.
Mutex deadlock
Two threads, two locks, one wait-for cycle — and three ways to break it.
How Redis works
Single event loop, six data types, pipelining vs not, eviction policies, MULTI/EXEC transactions, pub/sub fan-out.
Password hashing
MD5/SHA-256 vs bcrypt/scrypt/Argon2id. Slide the cost parameter, watch GPU attack rate drop from 100B/s to 100/s.
Cloud & infrastructure.
AWS architectural surfaces, played out.
Consistent Hashing
Add, remove, and move nodes around the ring.
Database Sharding
Range, hash, and directory strategies compared.
Load Balancer
Round-robin, least-conn, hashing, p2c — under real load.
DNS Resolution
Browser → OS → recursive → root → TLD → authoritative, with caches and TTLs.
S3 Prefix Sharding
3,500 PUT / 5,500 GET per prefix; watch hot partitions throttle and auto-split.
VPC Packet Flow
Drag a packet through IGW, NAT, security groups, NACLs — see route table evaluation.
CloudFront Cache
Edge → regional → origin shield → origin. Watch the cascade and the populate-on-return.
Service Mesh
Istio / Linkerd / App Mesh. Canary, mTLS, retries, circuit breaker — animated request flow.
Auto-Scaling Group
Drag the load curve; watch target-tracking add and remove instances with cooldown.
Container Scheduler
ECS + Kubernetes bin-packing. Filter, score, place; cluster-autoscaler triggers when full.
Anycast Routing
World map of PoPs advertising one IP via BGP. Fail a PoP, watch traffic converge.
OS & kernel internals.
Below the application layer.
Syscall Journey
A single read() through 20 stages: libc → syscall trap → KPTI → VFS → ext4 → page cache → block layer → NVMe → DMA → copy_to_user. Real cycle counts at every step.
CPU Scheduler
FCFS, Round Robin, Priority, and CFS-like — same five jobs, four algorithms, four very different Gantt charts.
Stack Frame
Function calls push frames; locals fill them; an overflow corrupts the return address. Toggle canary, NX, ASLR — watch the exploit succeed or get blocked.
Virtual Memory
Click a virtual page. TLB hit, page walk, minor fault, major fault from swap, or COW after fork() — the whole MMU on one diagram.
Memory Allocator
malloc with first-fit / best-fit / buddy; watch external fragmentation form. Slab caches for fixed-size kernel objects beside.
Filesystem (ext4)
Tiny ext4 layout: block groups, inode bitmap, block bitmap, inode table, data blocks, journal. Create + delete files live; simulate a crash and watch the journal replay.
Linux boot
UEFI → bootloader → kernel → initramfs → systemd → login. Step through six stages with memory map, disk activity, and the process tree growing under each.
How Docker actually works
A container is clone() + namespaces + cgroups + overlayfs. Toggle each primitive off and watch the isolation break.
NAND to CPU
Build AND/OR/NOT from NAND; then half-adder, full-adder, ALU, register, memory, a tiny Hack-style CPU running compute 2+3.
Each specimen has
a guide.
The how is in the guides; this is where you push on it. Pair them — read first if you want context, push first if you learn by feel.
Open the guides →