Phase 7 — Platform & Distributed Systems Architecture

Target role: Software Architect – Distributed Systems & Platform Engineering, Apple (CAD Infrastructure Development).

Phases 1–5 build the systems behind a request (storage, consensus). Phase 6 builds the systems in front of a request (the cloud gateway). Phase 7 is about the systems between services — how you decompose a platform into services, how those services talk (sync and async), how you partition and keep data consistent, how you ship and operate it all (IaC, GitOps, SLOs), and — because this is an architect role — how you make and land the technical decisions that let other engineers move fast.

This is the "10 years + ownership of architecture" tier. The labs build the runnable substrate (event buses, a partitioned log, the outbox/saga patterns, consistent hashing, an IaC engine, a GitOps reconciler, an SLO engine), but the meta-skill the role is hiring for is judgment: choosing the right pattern, writing it down (ADRs), and building consensus. Every lab carries both.

Why this phase exists (and what it reuses)

Much of the Apple JD is already covered earlier in the book; Phase 7 cross-references those rather than rebuilding them, and builds the genuinely new platform-architecture topics.

Every new JD bullet maps to a Phase 7 lab; every overlapping bullet is already built elsewhere and linked.

How this phase is structured

Same proven shape as Phase 6 — each lab pa-NN ships:

pa-NN-name/
├── CONCEPTS.md      # the 8-part framework (the "why")
├── GUIDE.md         # the maintainer-level, hands-on deep dive
├── references.md    # papers, books, the canonical systems to study
├── docs/{analysis,execution,verification}.md
├── steps/           # staged, code-rich implementation guides
├── scripts/verify.sh
└── src/go/          # REAL, compilable, `go test -race`-green Go (stdlib-only, offline)

The runnable code you'll build and hack on:

• a service-dependency analyzer (cycle detection, blast radius, layering rules) — pa-01,
• a contract-compatibility checker (protobuf-style wire rules) + idempotency store + cursors — pa-02,
• an event bus with at-least-once delivery, idempotent consumers, and a dead-letter queue — pa-03,
• a partitioned commit log (Kafka in miniature): partitions, offsets, consumer groups, rebalancing — pa-04,
• the transactional outbox and a crash-recoverable saga orchestrator — pa-05,
• consistent hashing (vnodes, minimal movement) + a quorum simulator — pa-06,
• a mini IaC engine: dependency DAG, plan/diff, apply, state, drift detection — pa-07,
• a GitOps reconciler: sync, prune, self-heal, sync waves — pa-08,
• an SLO + multi-window burn-rate alerting engine + bulkheads — pa-09,
• architecture fitness functions (automated architecture tests) — pa-10.

Run the whole phase: bash pa-00-platform-architecture-overview/verify-all.sh.

What "Software Architect" actually means here

This is not "senior engineer + 2." An architect is measured on leverage: decisions that let many teams move faster and safer.

1. You make cross-cutting decisions and write them down. ADRs / RFCs that capture context, options, trade-offs, and the decision — so the why survives you. (pa-10)
2. You design for evolution, not perfection. Service boundaries and contracts that can change independently; the "distributed monolith" is the cardinal failure. (pa-01, pa-02)
3. You enable, you don't gatekeep. Patterns, paved roads, and automated fitness functions so the right thing is the easy thing — not a review bottleneck. (pa-10)
4. You build consensus. The hardest part is aligning teams with different incentives. Design reviews, prototypes, and data — not authority. (pa-10)
5. You own the trade-offs. CAP/PACELC, sync vs async, consistency vs availability, build vs buy. You can defend each choice with numbers. (pa-06, pa-03, pa-09)

The Apple CAD-infrastructure context: you're building the internal platform a large hardware/silicon engineering org runs on — job/data services, event pipelines, and the paved roads other teams build on. The JD is generic distributed-systems architecture; the labs keep that generality.

A note on languages

The JD says Go, Java, or Python. Phase 7's runnable code is Go (stdlib-only, so it builds offline) — the platform/infra lingua franca (Kubernetes, Terraform, etcd, NATS, most operators). The patterns are language-agnostic; the GUIDEs note where Java (Spring, Kafka Streams) or Python idioms differ.

Suggested path

pa-01 (decomposition) ─▶ pa-02 (API/contracts) ─▶ pa-03 (event-driven)
                                                        │
                                  ┌──────────────────────┼───────────────────┐
                                  ▼                      ▼                    ▼
                           pa-04 (log)           pa-05 (outbox/saga)   pa-06 (partitioning)
                                  │
        ┌──────────────────────────┼──────────────────────────┐
        ▼                          ▼                           ▼
  pa-07 (IaC)              pa-08 (GitOps)              pa-09 (SLOs/reliability)
                                                              │
                                                  pa-10 (architecture in practice)

Read HITCHHIKERS-GUIDE.md first, then INTERVIEW.md for the architect-level system-design playbook, behavioral mapping, 30-60-90, and questions to ask them.