Pattern Library
59 patterns across 10 categories. The durable knowledge artifact of ROOT.
Each pattern starts as a STUB (frontmatter + 1-paragraph summary). When a phase first touches it, promote to OUTLINE. After 3+ months operating something that depends on it, promote to DEEP.
See
../meta/pattern-template.mdfor the structure of each depth level.
Why a pattern library
Tools change. Patterns don’t.
If you learn “Kubernetes,” you’ll be fluent in 2026 tools that may not be canonical in 2031. If you learn the underlying patterns — declarative reconciliation, control loops, eventual consistency, service discovery — those carry across whatever tool ecosystem dominates next. Staff and Principal engineers reason in patterns and treat tools as interchangeable implementations; the library is where that habit is built.
This is also the load-bearing knowledge artifact of ROOT. Phase docs are the journey through the patterns; entries here are the destination — the place a pattern earns its weight after you’ve operated something real that depends on it. By Year 5, most entries are DEEP and the library reads like a reference written by an engineer who has lived each pattern, not summarized one.
For the program’s framing of why patterns sit above tools, see the Master Plan section on the bet and the pattern depth ladder.
How to use it
- From a phase doc: every phase references the patterns it touches. Click through, read at current depth, deepen if STUB.
- From a project: when you’re building something and recognize “this is a control loop,” come here, read the entry, recognize the same pattern in your code.
- From an incident: during a postmortem, ask “what pattern was this?” — most incidents are pattern violations.
- From a job interview: when asked “how would you design X?”, reason from patterns first. Pattern → trade-offs → which canonical implementation matches the constraints.
Catalog
Foundations (7)
- resource-virtualization
- privilege-separation
- mediation
- layering-and-abstraction
- control-loops
- caching
- state-vs-computation
Distributed Systems (12)
- replication
- consensus
- partitioning
- eventual-consistency
- cap-and-pacelc
- crdts
- idempotency
- delivery-semantics
- two-phase-commit-vs-sagas
- backpressure
- fault-isolation
- distributed-time
Storage and Data (7)
- lsm-vs-btree
- append-only-log
- write-ahead-logging
- snapshot-plus-delta
- oltp-vs-olap
- schema-on-read-vs-write
- materialized-views
Stream vs Batch (3)
Networking (6)
- routing-and-addressing
- load-balancing
- service-discovery
- service-mesh
- zero-trust-networking
- network-policy
Infrastructure and Platform (6)
- declarative-vs-imperative-infrastructure
- gitops
- immutable-infrastructure
- progressive-delivery
- multi-tenancy
- platform-as-product
Observability and Operations (5)
- three-pillars-and-unified-telemetry
- sli-slo-error-budget
- blameless-postmortem
- runbook-as-code
- cardinality-as-cost
Security (5)
ML and AI (5)
Agents (3)
Depth status (kept current as patterns are deepened)
| Status | Count | Meaning |
|---|---|---|
| STUB | 59 | Title + 1-paragraph summary; not yet usable for mastery |
| OUTLINE | 0 | Headings + key points; usable for orientation |
| DEEP | 0 | Full pattern-first treatment; mastery-ready |
As you deepen entries, this table updates. By Year 5, target is mostly DEEP with a few OUTLINEs for newer patterns.