Distributed Systems & Cloud

Months 13-24. Single-machine intuition is wrong at scale. Add multi-machine thinking, IaC patterns, multi-cloud, and turn basecamp from “K8s on my homelab” into “a platform another engineer could pick up and operate.” Exit ramp: DevOps / Cloud Engineer

---

Year 2 is the inflection year of ROOT. Year 1 gave you depth in one machine: kernel, network stack, container internals, a single K3s cluster you can debug from first principles. Year 2 takes that intuition and breaks it on purpose, then rebuilds it as the distributed-systems thinking that the rest of the program assumes. By Month 24 you’re not “an engineer who runs Kubernetes” — you’re an engineer who reasons about replication, consensus, partitioning, and the trade-offs every multi-machine system makes.

Inside the 5-year arc, this is the year where the platform stops being a personal homelab and starts becoming an artifact. terralabs ships publicly — the first time you let the world see your work. platform-ctl begins (private, going public in Year 5). basecamp absorbs Backstage, service mesh, signed images, secrets lifecycle, and platform-level SLOs. You finish with multi-cloud synthesis: one git repo, one CLI, three control planes (k3s + EKS + GKE).

The pattern-first discipline does the heaviest lifting of the program here. Year 2 deepens ~18 patterns to DEEP — more than any other year. Year 3-5 add new categories on top of this foundation; they don’t rebuild it.

Single-machine intuition is wrong at scale

This is the year that breaks you and rebuilds you. Most of what felt obvious in Year 1 — “the database has the answer,” “the clock is correct,” “the message arrived once” — is wrong as soon as there’s more than one machine in the picture. Phase 8 (Distributed Systems Theory) exists to confront that head-on, with DDIA Ch. 5-9 as the spine. If a phase reading feels uncomfortable, you’re in the right place. The discomfort is the learning.

---

What you’ll know at the end of Year 2

• Distributed systems theory — CAP, PACELC, consensus, replication, partitioning, eventual consistency, CRDTs, idempotency, delivery semantics, distributed time. DDIA Ch. 5-9 internalized. You can reason about CAP/PACELC trade-offs in a real architecture review without reaching for a cheat sheet.
• IaC as a pattern — Terraform and Crossplane as two implementations of declarative infrastructure with reconciliation loops. You can write declarative IaC modules from scratch, not copy-paste from a tutorial. terralabs ships publicly.
• Cloud as utility computing — AWS deep, GCP comparative. What’s primitive vs. what’s marketing. You can build a VPC + IAM + RDS + EKS topology and then justify every choice against a Crossplane equivalent.
• Platform Engineering as a discipline — Backstage IDP, service mesh (mTLS, traffic, observability), secrets lifecycle, defense in depth, zero-trust networking, SLI/SLO discipline as a platform contract.
• Multi-cloud synthesis — basecamp manages K3s + EKS + GKE from one git repo with one CLI. The capstone proves the patterns transferred, not just the tools.

You’ll be able to design and operate a multi-cloud Kubernetes platform with GitOps, service mesh, and platform-level security — at homelab scale, with patterns that scale to thousands of services.

Platform engineering is a discipline, not a tool

Year 2 treats Platform Engineering the way Year 1 treats operating systems: as a category of human need with timeless principles, not as “Backstage + Crossplane + Istio.” Backstage is one IDP implementation. Istio is one mesh implementation. The pattern — platform-as-product, with a paved road, an SLO contract, and a developer surface — is what survives the next tool cycle. Phase 12 is the longest phase in ROOT (4 months) precisely because this discipline is the load-bearing foundation for Year 3-5.

---

Phase map

Phase	Title	Approx. weeks	Approx. hours	Pattern depth focus
8	Distributed Systems Theory	8	80	replication, consensus, partitioning, eventual-consistency, CAP, idempotency, delivery-semantics, CRDTs, distributed-time
9	IaC: Terraform + Crossplane	8	80	declarative-vs-imperative, control-loops (reinforced), gitops (reinforced), immutable-infrastructure
10	AWS Deep Dive	8	90	least-privilege, defense-in-depth, threat-modeling
11	GCP + Cloud-Agnostic	5	60	(compare phase — patterns reinforced, not new)
12	Platform Engineering (UX + Security halves)	16	192	platform-as-product, service-mesh, secrets-lifecycle, defense-in-depth (DEEP), zero-trust-networking, zero-trust-security, sli-slo-error-budget
13	Multi-cloud basecamp (capstone)	8	90	multi-tenancy, plus all Y2 patterns reach DEEP
	Year 2 Final Exam	2	24	—
Total		~55 weeks	~616 hrs	~18 patterns deepened

12 hrs/week × 52 weeks = 624 hrs. Year 2 fits with ~8 hrs slack. Phase 12 is the longest phase in ROOT (4 months) — earns its length because Platform Engineering is the discipline that makes Year 3-5 possible.

Phase 11 is deliberately a compare phase — short, structural. Re-implementing the same primitives on GCP after eight weeks of AWS is the pattern-first scaffold’s COMPARE step at year scale. If GCP feels easy, the AWS pattern transferred. If it feels foreign, AWS taught you GCP-specific naming, not the underlying category.

---

What ships publicly during Year 2

Project	Phase	Launch energy
terralabs	Phase 9	First real launch — README, examples, CI, blog post on abukix.dev. Multi-cloud TF modules + Crossplane equivalents side-by-side is genuine teaching content.
platform-ctl	Phase 12	Private — start the repo; ship publicly Year 5
basecamp	Phase 9 onward	Private — grows continuously; goes public Year 3
triage	Phase 13	(already public from Y1; multi-cloud-deployed this year)

terralabs is the first artifact you let the world see. It’s where you stop being someone-with-a-homelab and start being someone-who-ships-to-the-community. Two implementations of declarative infrastructure (Terraform’s plan/apply, Crossplane’s reconcile loop) sitting side-by-side in one repo is the kind of teaching artifact that shows pattern-fluency, not just tool-fluency — exactly the bet ROOT makes.

platform-ctl starts here as the unified CLI front-door for basecamp. It stays private through Year 4 and ships publicly with the Studio launch in Year 5.

---

Patterns deepened in Year 2

By Year 2 end, these reach DEEP:

• distributed-systems/replication (DDIA + Phase 8 hands-on)
• distributed-systems/consensus (Raft implementation in Go)
• distributed-systems/partitioning
• distributed-systems/eventual-consistency
• distributed-systems/cap-and-pacelc
• distributed-systems/idempotency (revisited at scale)
• distributed-systems/delivery-semantics
• distributed-systems/two-phase-commit-vs-sagas
• distributed-systems/crdts
• distributed-systems/distributed-time
• infrastructure-and-platform/declarative-vs-imperative-infrastructure
• infrastructure-and-platform/gitops
• infrastructure-and-platform/immutable-infrastructure
• infrastructure-and-platform/multi-tenancy
• infrastructure-and-platform/platform-as-product
• networking/service-mesh
• security/secrets-lifecycle
• security/defense-in-depth
• security/least-privilege
• security/zero-trust-networking
• security/zero-trust-security
• observability-and-ops/sli-slo-error-budget (pulled forward from Y3 — discipline, not tools)

Year 2 deepens the most patterns of any year. Year 3-5 add new categories on top.

Browse the full library by category: distributed systems, infrastructure and platform.

---

Cloud requirements

AWS Free Tier  — Phase 10
  └── 12-month free tier; budget ~$50 for what overruns free
GCP $300 credits — Phase 11
  └── used over 6 months; budget $0
TOTAL Y2 cloud spend: ~$50

Discipline: destroy at end of session, every time.
            Budget alerts on day 1.

Cloud is exploration, not production. Default deployment target is still the homelab — see homelab/hardware for the 32GB DDR5 spec Year 2 assumes. Cloud is the lab where you verify the patterns generalize across environments. Free Tier discipline (destroy-on-exit, budget alerts day one) is itself a Year 2 lesson: your first real bill is your first real cost incident. Treat it like one.

---

Reading order

1. This index (you are here)
2. phase-8.md — DDIA-heavy; pace 1 chapter/week
3. Each subsequent phase in order: Phase 9 → Phase 10 → Phase 11 → Phase 12 → Phase 13
4. final-exam.md ~2 weeks before end of Phase 13
5. As each Y2 pattern is referenced in a phase: read its entry under patterns/distributed-systems/ or patterns/infrastructure-and-platform/ and promote it OUTLINE → DEEP while the phase context is live.

DDIA Ch. 5-9 is Year 2’s spine. Read at the rate of 1 chapter/week starting Phase 8 and you’ll finish by mid-Phase 12.

---

Year 2 graduation

You can:
- Design and operate multi-cloud K8s platforms
- Reason about distributed-systems trade-offs from theory + practice
- Build internal developer platforms (Backstage, service mesh, security)
- Manage cost across clouds, defend security at depth, recover from DR
- Ship OSS that other engineers find useful (terralabs)
- Define + measure platform SLOs

Exit ramp: DevOps Engineer / Senior DevOps / Cloud Engineer / Platform Engineer
Confidence: real, demonstrable, has shipped artifacts (terralabs public, basecamp multi-cloud)

→ Year 3: Platform Engineering & Data