Pipelines, streaming, storage, and distributed systems.
Exploration ·
Pull the plug on a database halfway through a write and it comes back with every committed transaction and none of the half-finished ones. How? Follow a write through the log, the buffer pool and the disk, compare B+trees with LSM-trees, watch compaction, and then see the other half of the promise — what concurrent transactions are allowed to see — with real PostgreSQL and SQLite running between the paragraphs.
Tool ·
Watch a three-region replicated store at Cosmos DB's five consistency levels — strong, bounded staleness, session, consistent prefix, eventual — with stale and out-of-order reads, latency and availability counted as you cut regions off or fail them; the four session guarantees and causality, each broken and fixed; a linearizability and sequential-consistency checker for your own histories; and a clickable map of the models.
Tool ·
A catalogue of 75 distributed patterns built on Redis — locks, leases and fencing, transactions and Lua, queues and streams, notification, rate limiting, caching, idempotency, counting, data structures, service coordination and cluster-aware design — each with its guarantees, its Lua, its failure modes and 185 labs you can step through: clients racing on a Redis in the page, real Lua included, without the pattern and with it, and on your own server. Plus Redis Cluster and Sentinel, animated.
Tool ·
An animated MongoDB cluster in your browser: a replica set with its oplogs, elections in terms, write concern and the rollback of acknowledged w:1 writes, read concern and read preference with maxStalenessSeconds; a sharded cluster with mongos, config servers, ranges, hashed and ranged keys, zones, the balancer and jumbo ranges; a query-targeting checker and a shard-key evaluator.
Tool ·
Size NoSQL deployments with the working shown: Cassandra and ScyllaDB nodes from rows, replication and compaction headroom, with node-replacement and repair times; Redis memory per key by encoding (listpack, intset, hashtable, skiplist) with fragmentation, replication buffers and an eviction policy; MongoDB working set, WiredTiger cache and oplog window; Azure Cosmos DB request units, partitions and cost; and a Zipf hot-partition checker.
Tool ·
Model one application four ways — document (embed or reference, with the subset, bucket, extended-reference, computed and outlier patterns), wide column (one table per query), key-value (keys and hand-made indexes) and graph — and see for each which access patterns are one read, several or scatter-gather, how many copies every write touches and what can go out of step; then a "Which database?" questionnaire with a reasoned shortlist and a CAP/PACELC explainer, and exports as CQL, MongoDB $jsonSchema, Cypher and JSON.
Tool ·
How offline-first apps sync, animated: CouchDB/PouchDB-style replication between a phone, a laptop and a server that go offline — revision trees, the changes feed, checkpoints, _revs_diff and _bulk_docs, conflicts and the deterministic winning revision, three ways to resolve them, compaction and _revs_limit's false conflicts — against a Firestore-style single-leader cache with pending writes, server timestamps and rolled-back writes.
Tool ·
Practise big-tech style system design interviews: a paced 45- or 60-minute framework with a mock interviewer, random questions and a self-scoring rubric, a back-of-the-envelope estimator, 38 reference architectures (likes, web search, webhooks, group chat, Kafka- and Dynamo-style stores, maps, a matching engine and more) as clickable diagrams with model deep-dive answers and interview cards, a live simulation of each one you can overload and break, a searchable question bank with a compare view, runnable building blocks (rate limiters, consistent hashing, Snowflake IDs, Bloom filters, fencing tokens, the outbox pattern and more) with Python, Go and Java versions, and trade-off cards.
Tool ·
How big should the database connection pool be? Little's law and Erlang C from your request rate and connection hold time, the PostgreSQL wiki's cores × 2 + spindles explained, every instance's pool against max_connections (RDS defaults included), a simulation of a pool too small and too large, and HikariCP's settings with maxLifetime and keepalive worked out from the idle limits on your network path.
Tool ·
Frequent itemsets with Apriori (level by level, pruning shown) and FP-Growth (the FP-tree drawn), association rules with support, confidence, lift, leverage and conviction; and clustering — k-means step by step with k-means++, elbow and silhouette, DBSCAN with its k-distance plot, hierarchical clustering with a dendrogram — on points you edit or a CSV, checked against mlxtend, scikit-learn and scipy.
Tool ·
Paste PostgreSQL EXPLAIN (JSON or the usual text) or MySQL EXPLAIN ANALYZE / FORMAT=JSON and see the plan as a tree with each node's own time, a flame chart and a table of hotspots, the problems found — row misestimates, sorts and hashes spilling to disk, big filtered scans, missing join indexes, JIT overhead, foreign-key triggers — with advice for each, and two plans compared side by side.
Tool ·
Two or three SQL sessions side by side: step through an interleaving and watch what PostgreSQL or MySQL InnoDB does at each isolation level — results, which statement blocks on which lock, deadlocks, serialization failures (40001 / 40P01) and the final table — with the classic anomalies, their fixes and the Hermitage tests built in, or the same steps on a real Postgres server.
Tool ·
Find near-duplicate documents: character or word shingles, exact Jaccard, seeded MinHash signatures, LSH banding with its S-curve and a (b, r) tuner, 64-bit SimHash with the permuted-table search, precision and recall against an exact similarity join, and clusters — 10,000+ documents in a Web Worker.
Tool ·
Build a row key from parts — fields, reversed timestamps, salts, hash prefixes, padding, separators — run a workload against Bigtable, HBase, Cassandra or DynamoDB, and see where the writes land over time (region splits included), which queries become one range scan and which a fan-out or scatter-gather, and what the key costs in bytes.
Tool ·
Paste two SQL schemas (PostgreSQL or MySQL, hand-written or from pg_dump / mysqldump) and get the migration from one to the other as SQL, Flyway versioned files or a Liquibase changelog (YAML or XML), with warnings for the changes that rewrite or lock tables — by database version — and an ER diagram of what changed.
Tool ·
Paste Spring Boot Actuator output and read it: why each auto-configuration did or didn't apply, the bean dependency graph, which property source wins for every key, bound @ConfigurationProperties, the endpoint table, metrics and health. Plus a properties ↔ YAML converter with profiles, a checker for common keys, and every relaxed-binding form of a property name.
Tool ·
Inside a time-series database: validate InfluxDB line protocol and Prometheus exposition text and see the series keys; watch Gorilla, Prometheus XOR/XOR2 and InfluxDB TSM compression bit by bit on your data (byte-identical to Prometheus's and InfluxDB's own encoders); estimate cardinality and memory; downsample counters correctly; size retention tiers; and watch Prometheus cut and compact blocks.
Tool ·
Real DuckDB in your browser with a console, results grid, plan trees for EXPLAIN ANALYZE, quick charts and CSV/Parquet export — sample datasets, your own CSV/Parquet/JSON files read locally, and twelve guided labs: window functions, QUALIFY, PIVOT, ASOF joins, ROLLUP/CUBE, nested types, regex, Parquet metadata and columnar storage.
Tool ·
A Jupyter-style Python notebook that runs entirely in your browser (Pyodide) — code and Markdown cells, one shared namespace, pandas tables and matplotlib figures inline, tracebacks, CSV upload, open and download .ipynb files, autosave, share links, and starter notebooks for pandas, plotting, linear algebra, SciPy statistics and simulation.
Tool ·
An animated RabbitMQ broker in your browser: producers, exchanges (direct, fanout, topic, headers, default), bindings, classic and quorum queues and consumers, with every publish, route, delivery, ack, confirm and dead-lettering drawn as it happens — prefetch, requeues, TTL, max-length, priorities, DLX retry with backoff, poison messages and RPC, in guided scenarios or a topology you build.
Tool ·
A real SPARQL 1.1 engine (Oxigraph, in WebAssembly) in the page — load Turtle, TriG, N-Triples or JSON-LD, run SELECT, CONSTRUCT, ASK, DESCRIBE and updates, see results as a table, as Turtle or as a graph drawing, work through labs on property paths, aggregates, named graphs and RDFS inference by rules, or query Wikidata.
Tool ·
Real SQLite in your browser with a console, and what is underneath: the database file decoded page by page (header, b-tree pages, cell pointers, cells and records, overflow and freelist pages), a b-tree diagram for any table or index, VDBE bytecode annotated opcode by opcode, query plans as trees, the pages each statement writes — and eleven labs from rowid tables to WAL.
Tool ·
Real jq 1.8 in your browser — input, filter and output side by side, updating as you type, with the command-line flags, --arg and --argjson, over fifty example filters on sample data (a GitHub API response, a Kubernetes pod list, a JSON-lines log, a nested config), the output after every stage of the pipe, and the shell command to copy.
Tool ·
A Cassandra data-modelling lab and CQL client: a cqlsh-like console on a built-in Cassandra node (CQL, TTLs, tombstones, SSTables, lightweight transactions), a query-first checker that says which queries a table supports and why, partition sizes and hot partitions, the token ring with vnodes and replica placement, consistency levels with replica responses — and a native-protocol client for your own Cassandra through the gitwebsite app.
Tool ·
Browse and query object stores and HDFS from the browser — S3, MinIO, R2, B2, Wasabi, GCS, Azure Blob and WebHDFS/HttpFS: buckets and folders, uploads with resumable multipart, Range downloads, presigned URLs, Parquet/ORC/Avro schema and row-group statistics, DuckDB SQL over files, HDFS block locations, bucket CORS/policy/lifecycle generators, and the aws/mc/gcloud/az/hdfs command and curl for every action.
Tool ·
Design a DynamoDB single table — entities with key templates, GSIs and LSIs — see its items grouped by partition, check every access pattern (which GetItem or Query serves it, on which index, and how much it reads to return what), estimate capacity and on-demand against provisioned cost, and export to NoSQL Workbench, CloudFormation or CDK; with a DynamoDB engine in the page and a client for DynamoDB Local.
Tool ·
Write Cypher against sample graphs — movies, a social network, a metro — in an engine that runs in the page (MATCH with variable-length paths and shortestPath, WITH, aggregation, CREATE/MERGE/SET/DELETE, EXPLAIN and PROFILE), see results as a force-directed graph, a table or cypher-shell text, and run the same queries on a real Neo4j over Bolt.
Tool ·
A mongosh-like console on a MongoDB that runs in your browser — with sample data, an aggregation pipeline builder that previews every stage, explain plans drawn as a tree (COLLSCAN vs IXSCAN), schema inference and $jsonSchema validators, a reference with runnable examples — and a real-server mode that speaks MongoDB's wire protocol through the gitwebsite app.
Tool ·
Open a distributed trace as OTLP/JSON, a Jaeger export or Zipkin v2 JSON and read it as a waterfall with events and errors, a service map, the critical path and self time per service — flag and adjust clock skew, compare two traces span by span, and convert between the formats, all in the browser.
Tool ·
Write PromQL and LogQL against four hours of generated metrics and logs — counters with resets, histograms, a failing instance, a target that goes down — see the result as a graph or table, and walk through any query step by step, down to the arithmetic of rate()'s extrapolation and histogram_quantile()'s interpolation.
Tool ·
Every major eviction policy — LRU, LFU, FIFO, CLOCK, ARC, 2Q, W-TinyLFU, S3-FIFO — against Belady's optimum on Zipf, loop, scan and shifting workloads or your own trace; hit-ratio curves for all of them at once, a step-through of each policy's internal state, write policies, cache stampede fixes (singleflight, jitter, XFetch, stale-while-revalidate) and hot-key and two-tier maths.
Tool ·
Queueing maths for capacity planning: Little's law, M/M/1, M/D/1, M/G/1 and Kingman, M/M/c with Erlang C and exact percentiles, the utilisation-versus-latency knee, the tail at scale of fan-out requests, hedged and tied requests, a discrete-event simulator that checks the formulas, and a planner that turns a p99 target into a server count.
Tool ·
Time and agreement without coordination: space-time diagrams with Lamport, vector and hybrid logical clocks (skewed and drifting physical clocks, last-writer-wins gone wrong, causal broadcast); CRDTs from G-Counter to OR-Set and a collaborative RGA text editor across three replicas; and SWIM failure detection and epidemic gossip, animated.
Tool ·
An animated, step-by-step Elasticsearch (and OpenSearch) cluster in your browser: murmur3 routing, primaries and replicas, the indexing buffer, translog, refresh, flush and segment merging inside every shard, query-then-fetch search, node failures, master elections, split brain and shard sizing — with guided scenarios and a REST console.
Tool ·
An animated Flink job in your browser: Kafka partitions feeding chained operators, keyBy through key groups, event-time windows driven by watermarks, keyed state on HashMap or RocksDB, checkpoint barriers (aligned and unaligned), failure and recovery, a two-phase-commit Kafka sink, backpressure and rescaling from a savepoint — with guided scenarios, a key-group calculator and a window explorer.
Tool ·
An animated, step-by-step Linux host running Docker in your browser: docker run through dockerd, containerd and runc to clone(); namespaces, cgroups and the OOM killer; overlayfs copy-up and whiteouts; the build cache; pulling by digest from a registry; the bridge, veths, DNS and NAT; volumes; and the capabilities, seccomp and user namespaces that keep a container in — with a terminal that drives the same diagram.
Tool ·
An animated, step-by-step fleet of servers behind a load balancer: round robin, least outstanding, power of two choices, peak-EWMA and consistent hashing with bounded loads; then timeouts, retries with jitter and budgets, retry storms and metastable failure, circuit breakers, hedged requests, load shedding and adaptive concurrency limits — with latency, throughput and error charts over time.
Tool ·
Where keys live and how copies stay in step: consistent hashing with virtual nodes, rendezvous, jump hash and Maglev with animated key movement; an animated Dynamo-style store with preference lists, N/R/W quorums, sloppy quorums and hinted handoff, read repair, vector-clock siblings and Merkle-tree anti-entropy; and the latency and staleness of partial quorums.
Tool ·
Real PostgreSQL 18 in your browser (PGlite) with a psql-like console, twenty runnable labs for the distributed patterns Postgres does well — SKIP LOCKED queues, advisory-lock mutexes, leases with fencing tokens, leader election, LISTEN/NOTIFY, outbox, idempotency keys, rate limits — an animated model of concurrent sessions, and a real-server mode that races sessions on your own Postgres.
Tool ·
Bloom, counting Bloom and cuckoo filters, the Count-Min sketch with conservative update and heavy hitters, HyperLogLog (original, HLL++ sparse and Ertl's estimator), the t-digest and reservoir sampling — each fed by a live seeded stream, drawn from the inside, with accuracy-vs-memory charts against the formulas.
Tool ·
Consensus you can watch: Raft servers with terms, votes, logs and commit indexes exchanging labelled RequestVote and AppendEntries messages — elections, split votes, replication, crashes, log repair, partitions, the paper's Figure 8, membership changes, ReadIndex and lease reads, snapshots — plus Basic and Multi-Paxos and a randomised safety torture test.
Tool ·
An animated Spark application in your browser: a DataFrame or SQL program becomes a logical plan, Catalyst rewrites it, the planner picks joins and inserts shuffles, the DAG scheduler cuts stages and runs tasks on executors with real memory regions — with guided scenarios on partitions, skew, joins, AQE, caching, spills and failures, an executor sizing calculator and an EXPLAIN reader.
Tool ·
A B+tree and an LSM-tree side by side in your browser, fed the same operations: page splits and merges, the WAL and buffer pool, memtable flushes, leveled, size-tiered and lazy-leveling compaction, Bloom filters, fence pointers and tombstones — with write, read and space amplification counted as you watch, guided scenarios and the textbook cost models.
Tool ·
Atomic commitment and its alternatives, animated: two-phase commit with forced log writes, in-doubt participants and a blocking coordinator crash, presumed abort and commit, three-phase commit failing under a partition, orchestrated and choreographed sagas with compensations and a semantic lock, and the dual-write problem fixed by a transactional outbox and an idempotent consumer.
Tool ·
Work with a real Kafka cluster from the browser through a REST proxy (Confluent REST Proxy or Redpanda): brokers and configs, topics with partitions, ISR and offsets, produce single records or batches, consume by group or partition with live tail, consumer group lag and offset resets — and a log of every HTTP call, with copy as curl.
Tool ·
An animated, step-by-step Kafka cluster in your browser: partitions as replicated logs, the ISR and high watermark, acks and min.insync.replicas, broker failures and KRaft leader elections (clean and unclean), idempotence and transactions, consumer-group rebalances, compaction and retention — with guided scenarios.
Tool ·
A redis-cli in the browser with a built-in Redis to practise on, Lua scripts and functions, a reference for 255 commands with runnable examples, per-connection history, a key browser, pub/sub and stream viewers — and connections to real Redis servers over a REST gateway or a WebSocket bridge.
Playground ·
Two real database engines compiled to WebAssembly — SQLite for everyday SQL and DuckDB for analytics on your own CSV and Parquet files.
Article ·
How I built AOEE, an in-memory relationship cache for social-graph queries: posting lists borrowed from search engines, four adaptive encodings, set maths instead of joins, and friend-of-friend suggestions with a budget.
Project ·
A low-latency pub/sub service: back-end services publish state changes, and clients subscribe over WebSocket or long-poll to receive events plus a server-maintained snapshot of each object.
Project ·
Metadata-driven incremental replication from PostgreSQL into Apache Iceberg — the database counterpart to my structured-logger project.
Project ·
An outbound event-delivery platform: it consumes internal events from Kafka, matches them to subscribers, translates them to CloudEvents, and delivers them as signed webhook batches or WebSocket streams.
Project ·
A TAO-inspired in-memory relationship cache for social-graph queries, with compressed posting lists and fast set operations for friend-of-friend queries and feeds.
Project ·
A metadata-driven structured logging framework: it generates type-safe loggers for Java and Python from JSON definitions and lands every log line in Apache Iceberg tables you can query with SQL.
Project ·
A horizontally scalable web crawler in Java: Kafka distributes URLs across crawler processes, Cassandra keeps the metadata, and S3 or MinIO stores the content.
Project ·
A Java library and discovery server that let Kafka producers and consumers look up brokers and security settings by topic, then talk to Kafka directly.