Rows To Replicas

From Single-Node Tables to Distributed Storage Platforms

30 modules

116 lessons

—

Part 1

Appendices

Appendix A - Diagram Templates by StepSign in
Appendix B - Technology Mapping GuideSign in
Appendix C - Readiness Assessments (Step N to Step N+1)Sign in
Appendix D - GlossarySign in

Part 2

Course Setup and the Incremental Ladder

Course Setup and the Incremental LadderSign in
Why "Rows to Replicas": databases as system memory, and how guarantees get expensive fastSign in
How to Use This Course: steps as "storage slices" (model -> mechanism -> guarantees -> failures)Sign in
The Incremental Ladder (Step 0 -> Step 7): what each rung addsSign in
The Course Lenses: data model and API, indexing and execution, transactions and concurrency, replication and distribution, recovery, operations, evolutionSign in

Part 3

Mental Models: What a Database System Is

Mental Models: What a Database System IsSign in
System Types: OLTP vs OLAP vs key-value vs object storage (and what "system of record" means)Sign in
DB vs Storage Engine vs Cache: who owns truth, who owns speedSign in
Guarantees as Product Features: latency, throughput, freshness, durabilitySign in

Part 4

Workloads and Access Patterns

Workloads and Access PatternsSign in
Read/Write Shapes: point lookups, range scans, joins, aggregatesSign in
Logical vs Physical: schemas, views, projections, denormalizationSign in
Constraint Mapping: latency SLOs, throughput targets, storage growth, failure expectationsSign in

Part 5

Diagramming and Notation for Databases

Diagramming and Notation for DatabasesSign in
Schema Shapes: ER diagrams, document shapes, key spacesSign in
Index and Plan Diagrams: B+ trees/LSM at a conceptual level; operator pipelinesSign in
Cluster Topologies: leaders/replicas/shards/routers; trust and failure boundariesSign in

Part 6

Step 0 Data Modeling: Relational, Document, Key–Value

Step 0 Data Modeling: Relational, Document, Key–ValueSign in
Relational Basics: keys, constraints, normalization vs denormalization (conceptual)Sign in
Document Modeling: embedding vs referencing; shape evolution pressuresSign in
Key-Value Modeling: key design, scans, and "opaque value" tradeoffsSign in

Part 7

Step 0 Query Interfaces and Baseline Execution

Step 0 Query Interfaces and Baseline ExecutionSign in
Query Languages: SQL-ish SELECT/JOIN/GROUP BY; document filters; KV get/put/scanSign in
Full Scans as Baseline: filters, projections, orderingSign in
Materialization Choices: early vs late materialization (high-level intuition)Sign in

Part 8

Step 1 Index Structures

Step 1 Index StructuresSign in
B+ Trees (Conceptual): what they optimize, what they costSign in
Hash Indexes: where they win, where they fail (ranges, ordering)Sign in
Clustered vs Non-Clustered; Primary vs Secondary IndexesSign in

Part 9

Step 1 Planning, Operators, and Performance

Step 1 Planning, Operators, and PerformanceSign in
Index Design and Maintenance: prefixes, composite keys, write amplificationSign in
Query Planning (Conceptual): logical vs physical plans; selectivity and cardinality intuitionSign in
Execution Operators: scans, joins (nested/merge/hash), sorts, aggregates (conceptual)Sign in
Query Anti-Patterns: N+1, unbounded scans, missing indexes, ad hoc query chaosSign in

Part 10

Step 2 Transaction Guarantees

Step 2 Transaction GuaranteesSign in
ACID (Conceptual): what app developers actually get from each letterSign in
Transaction Lifecycle: begin -> read/write -> commit/rollback; savepointsSign in
Transaction Boundaries in Applications: where invariants live (and where they leak)Sign in

Part 11

Step 2 Isolation Levels and Application Patterns

Step 2 Isolation Levels and Application PatternsSign in
Isolation Levels (Conceptual): read uncommitted -> serializableSign in
Anomalies: dirty/non-repeatable/phantoms and why "mostly works" is dangerousSign in
App Patterns: idempotency, retries, invariant enforcement, saga-like compensationsSign in

Part 12

Step 3 Lock-Based Concurrency

Step 3 Lock-Based ConcurrencySign in
Shared vs Exclusive Locks; what blocks what (conceptual)Sign in
Granularity: row/page/table/partition; escalation and hierarchiesSign in
Practical Conflict Reduction: shorten transactions, order operations, avoid hot rowsSign in

Part 13

Step 3 MVCC, OCC, and Conflict Handling

Step 3 MVCC, OCC, and Conflict HandlingSign in
MVCC (Conceptual): snapshots, visibility rules, cleanup/vacuum pressureSign in
OCC (Conceptual): read -> compute -> validate -> commit; where it shines/falls downSign in
Deadlocks and Starvation: detection, timeouts, avoidance strategiesSign in
Distributed Preview: why cross-node coordination changes everything (latency + partial failure)Sign in

Part 14

Step 4 Replication Fundamentals

Step 4 Replication FundamentalsSign in
Logical vs Physical Replication: change streams, log shipping, snapshots (conceptual)Sign in
Why Replicate: HA, read scaling, locality, disaster recoverySign in
The Enemy: lag, divergence windows, and stale readsSign in

Part 15

Step 4 Replication Topologies

Step 4 Replication TopologiesSign in
Single-Leader: write path, read options, read-your-writes pitfallsSign in
Failover (Conceptual): detecting failure, promoting leaders, split-brain hazardsSign in
Multi-Leader and Leaderless (Conceptual): conflicts, resolution pressure, operational complexitySign in

Part 16

Step 4 Sharding and Routing

Step 4 Sharding and RoutingSign in
Partitioning: horizontal vs vertical; range vs hash vs directorySign in
Rebalancing and Hotspots: uneven keys, hot partitions, adaptive strategiesSign in
Routing Layers: proxies/service discovery; client-side vs server-side routing; metadata control planeSign in

Part 17

Step 5 Failure Modes and Consistency Models

Step 5 Failure Modes and Consistency ModelsSign in
Failure Modes: node loss, slow nodes, partitions, partial vs total outagesSign in
Consistency Models (Conceptual): strong/eventual/causal/session guaranteesSign in
CAP-ish Thinking: tradeoffs as design choices, not labels; graceful degradation under partitionsSign in

Part 18

Step 5 Quorums and “App-Level Truth”

Step 5 Quorums and “App-Level Truth”Sign in
Quorum Intuition: W+R>N and what it buys you (high-level)Sign in
Tunable Consistency: latency vs safety vs throughput; where knobs backfireSign in
Application Design for Imperfect Consistency: semantic merges, idempotency, UX patterns for eventual correctnessSign in

Part 19

Step 6 WAL and Durability

Step 6 WAL and DurabilitySign in
Write-Ahead Logging: log-then-data ordering and why it mattersSign in
Redo vs Undo vs Logical Logs (Conceptual): what each makes easy/hardSign in
Group Commit and fsync Strategy: throughput vs latency tradeoffsSign in

Part 20

Step 6 Recovery and Engine Internals

Step 6 Recovery and Engine InternalsSign in
Checkpointing and Snapshots: recovery speed vs write overheadSign in
Crash Recovery Flows: what happens after power loss (conceptual walkthroughs)Sign in
Maintenance as a Feature: background work, compaction/vacuum, "hidden" system loadSign in

Part 21

Step 6 Storage Engine Families and Layout

Step 6 Storage Engine Families and LayoutSign in
B-Tree Engines: pages, splits/merges, fragmentation; random vs sequential implicationsSign in
LSM Engines: memtables/SSTables, compaction strategies; write/read amplification tradeoffsSign in
Layout and Compression: row vs column (conceptual), encoding, OLTP vs OLAP alignmentSign in
Data Lifecycle: TTLs, archival, cold storage, capacity planningSign in

Part 22

Step 7 Shared-Nothing and Distributed Execution

Step 7 Shared-Nothing and Distributed ExecutionSign in
Shared-Nothing Locality: why data placement is performanceSign in
Distributed Query Planning (Conceptual): scatter/gather, pushing down filters/aggregatesSign in
Cross-Shard Joins/Sorts/Groups: why "simple SQL" gets complicated fastSign in

Part 23

Step 7 Distributed Transactions and Coordination

Step 7 Distributed Transactions and CoordinationSign in
2PC Concepts: what it guarantees and why it is operationally heavySign in
Consensus-Based Commits (High-Level): where coordination moves and what it costsSign in
Avoiding Distributed Transactions: denormalization, async workflows, sagas, per-entity ownershipSign in

Part 24

Step 7 Global Indexes, Metadata, and Geo Distribution

Step 7 Global Indexes, Metadata, and Geo DistributionSign in
Global Secondary Indexes: maintaining them without killing write throughputSign in
Metadata Services: partition maps, schema state, routing truthSign in
Multi-Region Architectures: active-passive vs active-active; residency and latency constraintsSign in

Part 25

Step 7 Operating Database Platforms

Step 7 Operating Database PlatformsSign in
Observability: latency/throughput, queue depth, compaction pressure, replication lagSign in
Multi-Tenancy: isolation models, noisy neighbors, limits, governance/billingSign in
Schema Evolution and Migrations: online backfills, dual writes, safe rolloutsSign in
Security and Compliance (Data-Centric): roles, encryption (conceptual), audit logs, access trackingSign in
Reference Architectures: OLTP + replicas + cache; lake/warehouse pipeline; tunable-consistency KV storeSign in

Part 26

Data Modeling and API Design Patterns

Data Modeling and API Design PatternsSign in
Lessons on modeling for access patterns, invariants placement, denormalization boundaries, read/write isolation strategiesSign in

Part 27

Indexing and Query Performance Patterns

Indexing and Query Performance PatternsSign in
Lessons on composite keys, covering indexes, pagination shapes, join strategies, plan stability, and performance anti-patternsSign in

Part 28

Transaction and Consistency Patterns

Transaction and Consistency PatternsSign in
Lessons on idempotency and retries, outbox/inbox-style integration, conflict resolution semantics, session guarantees, eventual UXSign in

Part 29

Replication, Sharding, and Resilience Patterns

Replication, Sharding, and Resilience PatternsSign in
Lessons on failover playbooks, hotspot mitigation, resharding and rebalancing, quorum tuning, and degraded-mode designSign in

Part 30

Operations, Observability, and Evolution Patterns

Operations, Observability, and Evolution PatternsSign in
Lessons on SLOs for databases, capacity planning, backup and restore drills, migration playbooks, tenancy guardrails, and auditabilitySign in

Course overview