a map of backend systems

Node map · backend systems

Read the systems
as a map — not a list.

I learn one system at a time, down to where I can make design decisions and read other people's code. Each one becomes a station on this line — mental model first, gotchas included. Follow the track.

Open the map How this works
deep-dive series planned 4 nodes · 42 articles
  1. N01 · 10-part series Redis Ten short deep-dives that build one mental model of Redis — from the single thread to the design calls. Trace line
    1. Start here — series guide 3 min read
    2. Redis, from the ground up 10 min read
    3. The data types as a design toolkit 11 min read
    4. Expiration, eviction & memory 11 min read
    5. Atomicity in depth 12 min read
    6. Caching patterns done right 11 min read
    7. Messaging: Pub/Sub vs Streams 11 min read
    8. Persistence: RDB vs AOF 11 min read
    9. HA & scale: replication, Sentinel, Cluster 12 min read
    10. Specialized structures: bitmaps, HyperLogLog, geo, vector sets 11 min read
    11. Running it in prod 12 min read
  2. N02 · 8-part series Elasticsearch Eight short deep-dives that build one mental model of Elasticsearch — from the inverted index to the design calls. Trace line
    1. Start here — series guide 3 min read
    2. Elasticsearch, from the ground up 11 min read
    3. Documents, mappings & the shape of your data 13 min read
    4. How Elasticsearch reads text: the analysis pipeline 12 min read
    5. The Query DSL: match, term, bool & the two contexts 12 min read
    6. Why results come back ranked: BM25 relevance 11 min read
    7. Aggregations: the analytics engine 12 min read
    8. Running at scale: shards, replicas & the write path 14 min read
    9. When to reach for Elasticsearch (and when not to) 11 min read
  3. N03 · 9-part series MySQL Nine short deep-dives that build one mental model of MySQL — from how InnoDB stores a row to the pitfalls that bite from application code. Trace line
    1. Start here — series guide 3 min read
    2. How InnoDB stores your rows 10 min read
    3. Data types as a design decision 10 min read
    4. Indexes and the B-tree 11 min read
    5. Reading EXPLAIN 10 min read
    6. JOINs and the optimizer 10 min read
    7. Transactions and isolation levels 11 min read
    8. Locking and deadlocks 11 min read
    9. Schema changes without downtime 10 min read
    10. MySQL from application code 11 min read
  4. N04 · 11-part series Postgres Eleven deep-dives for engineers who know their way around a database and want to understand what Postgres does differently — and why it matters in production. Trace line
    1. Start here — series guide 4 min read
    2. The heap: how Postgres stores your rows 11 min read
    3. MVCC: row versions in the heap 13 min read
    4. VACUUM, autovacuum, and the dead-tuple problem 14 min read
    5. Data types as design decisions 12 min read
    6. The index toolbox: beyond the B-tree 15 min read
    7. Reading EXPLAIN ANALYZE 14 min read
    8. The planner and where estimates come from 15 min read
    9. Transactions, isolation, and locking 15 min read
    10. JSONB and document modeling 13 min read
    11. Transactional DDL and safe migrations 14 min read
    12. WAL, replication, and production concerns 15 min read