The final architecture

flowchart TB
  APPS["📱 Rider + driver apps — local replica, offline queue, hedging (3.6)"]
  PROBE["🤖 Synthetic probes (3.8)"]
  APPS --> EDGE["Global edge — anycast, city-to-home routing (3.2)"]
  PROBE --> EDGE
  EDGE --> R1
  EDGE --> R2
  EDGE --> R3
  subgraph R1 ["Region A — active"]
    direction TB
    RT1["Cell router (3.3)"]
    RT1 --> CA1["Cell A1: gateway, realtime, dispatch, trip, pricing, location — own shards + quorum groups (3.4)"]
    RT1 --> CA2["Cell A2"]
    RT1 --> CAN["Canary cell — deploys + chaos land first (2.8, 3.7)"]
  end
  subgraph R2 ["Region B — active"]
    RB1["Cells ×N"]
  end
  subgraph R3 ["Region C — active"]
    RC1["Cells ×N"]
  end
  R1 <-. "cross-region replication (3.2)" .-> R2
  R2 <-. " " .-> R3
  R1 <-. " " .-> R3
  subgraph ASYNC ["Asynchronous planes — shared, tier-isolated"]
    K[["Event backbone — outbox, idempotency law (2.4)"]]
    OBS["Observability — burn rates, correlator, auto-remediation (2.9, 3.8)"]
    LAKE[("Streaming lakehouse — surge v2, live ops, feature store, warehouse (2.10, 1.13)")]
    PAYP["Payments + ledger + fraud (1.8, 2.11) — T1, async from T0"]
  end
  R1 -.-> ASYNC
  R2 -.-> ASYNC
  R3 -.-> ASYNC
  subgraph CTRL ["Control plane — data plane survives its death (3.5)"]
    DEPL["Progressive delivery"]
    FLAGS["Flags + config"]
    HOMES["Home map + leases"]
  end
  CTRL -- "signed proposals, last-known-good adoption" --> R1
  CTRL -- " " --> R2
  CTRL -- " " --> R3

The ideas worth transferring, in rough order of generality: (1) Availability is arithmetic — serial chains multiply failure, so the deepest lever is always removing synchronous edges, not strengthening boxes (0.3 → 2.4 → 3.1). (2) Match guarantees to data value — at-most-once pings and exactly-once ledger effects in one system, each correct (1.4 vs 1.8). (3) State is quorum truth or rebuildable ephemera; the middle is where outages live (3.4). (4) Blast radius is a design axis you can buy by construction — shards, tiers, cells (2.3 → 3.3). (5) Recovery has a speed limit; past it, be already running (2.7 → 3.2). (6) The system that configures the system is the residual risk — fail static (2.8 → 3.5). (7) Claims about failure behavior decay; only continuously rehearsed claims stay true (3.7). (8) Each nine is an economic purchase; the tier lattice is the budget (2.1 → 3.9).

And the meta-lesson, kept for last because it is the course's method as much as its content: complexity was survivable — for the system and for you — because it arrived in dependency order, each layer built on schemas already consolidated, each simplification explicit about what it deferred. That is cognitive load theory, and it is also just good engineering: the two disciplines agree that the way to build something enormous is to make sure no single step ever requires holding more than a working memory's worth of new ideas. Now go draw the skeleton from memory one last time — then go build something.