# Learning Roadmap — the 19-course track A priority-ordered path through every course in `docs/`, built for **catching up on this repo + interview readiness** as a backend engineer who owns **conversationmgmt · notification · spike**. - **19 courses · 255 lessons.** Each course is `docs//index.html` with its own cheat sheet, glossary, and reference map. - **How priority was decided:** a blend of (1) *is it a prerequisite for other courses?*, (2) *how central is it to the code you touch daily?*, and (3) *how much interview weight does it carry?* - **How to use it:** follow the **Recommended sequence** top to bottom — it respects prerequisites. Short on time? Do the **Fast track (P0+P1)** and treat P2/P3 as reference. ## Priority legend | Tier | Meaning | |------|---------| | **P0 · Foundation** | Learn first — the language, datastore, transport, and code shape everything else builds on. | | **P1 · Core** | The repo's daily patterns and the heaviest interview topics. | | **P2 · Cross-cutting** | Reliability, data movement, delivery & ops that tie services together. | | **P3 · Infra depth** | Platform / deployment — valuable, but more role- and interest-dependent. | --- ## Recommended sequence (prerequisite-ordered) | # | Course | Priority | Lessons | Why here | Prereqs | |---|--------|----------|---------|----------|---------| | 1 | [Go — the language](golang/index.html) | **P0** | 23 | The language everything is written in. Nothing else lands without it. | — | | 2 | [PostgreSQL](postgresql/index.html) | **P0** | 24 | The primary datastore; RLS, transactions & indexing underpin Auth, v2 & reliability. | — | | 3 | [gRPC](grpc/index.html) | **P0** | 17 | The primary transport for every service and RPC endpoint. | Go | | 4 | [Go service assembly](go-techstack/index.html) | **P0** | 12 | How a service is actually wired here — bootstrap, config, resources, DI. Bridges "Go" → "this repo". | Go, gRPC | | 5 | [Containers & local dev](containers-local/index.html) | **P1** | 8 | Get hands-on: run the local stack, hot-swap binaries. Short and enabling. | — | | 6 | [v2 Architecture (Hexagonal + CQRS + sqlc)](v2-architecture/index.html) | **P0** | 12 | The shape *your own* new code takes — ports/adapters, commands/queries, typed SQL. | Go, Postgres, gRPC | | 7 | [Authentication & Authorization](auth/index.html) | **P1** | 12 | RBAC + `resource_path`/RLS multi-tenancy — touches every endpoint and query you write. | Postgres, gRPC | | 8 | [Unit Testing](testing/index.html) | **P1** | 12 | Table-driven tests, mocks, mock-by-layer — how you ship the v2 code safely. Interview staple. | Go, v2 Architecture | | 9 | [Apache Kafka](kafka/index.html) | **P1** | 11 | The durable event bus — pipelines, CDC sink, async work. | Go | | 10 | [NATS JetStream](nats/index.html) | **P1** | 12 | The fast eventing bus **your services subscribe to daily** (convo/notification). | Go, Kafka (compare) | | 11 | [CDC / Streaming-ETL](cdc/index.html) | **P2** | 12 | Debezium change-data-capture — the repo's signature data-movement pattern & the outbox relay. | Kafka, Postgres | | 12 | [Platform add-ons (the toolkit)](platform-add-ons/index.html) | **P2** | 12 | Migrations · lint/hooks · secrets · build · reliability (idempotency/retries/outbox) · email/push delivery · cron. Ties everything together. | Kafka, NATS, Postgres | | 13 | [Observability & monitoring](observability/index.html) | **P2** | 12 | Metrics, tracing, logging — how you see what production is doing. | gRPC, Containers | | 14 | [CI/CD & delivery](cicd/index.html) | **P2** | 12 | How code goes from PR to production; test tiers, gates, rollout. | Containers | | 15 | [Kubernetes](kubernetes/index.html) | **P3** | 12 | The runtime the whole platform runs on. | Containers | | 16 | [Helm](helm/index.html) | **P3** | 12 | How every service is packaged & configured for k8s. | Kubernetes | | 17 | [Istio & the service mesh](istio/index.html) | **P3** | 12 | mTLS, traffic policy, mesh routing between services. | Kubernetes | | 18 | [Infrastructure as Code](iac/index.html) | **P3** | 12 | Terraform — the cloud infra under the cluster. | — | | 19 | [Apache Airflow](airflow/index.html) | **P3** | 16 | Data-pipeline orchestration (hephaestus/DWH). Peripheral to your services. | Postgres | --- ## The phases, at a glance ### Phase A — Foundations (P0) · courses 1–4, 6 **Go → PostgreSQL → gRPC → Go service assembly → v2 Architecture.** The language, the datastore, the transport, how a service is assembled, and the architecture your own modules follow. Everything after this assumes fluency here. If you learn nothing else, learn these. ### Phase B — Core repo fluency (P1) · courses 5, 7–10 **Containers → Auth → Testing → Kafka → NATS.** Getting productive locally, then the cross-cutting concerns every handler carries (auth/RLS), how you prove correctness (testing), and the two event buses your services live on. This is where "catch up on the repo" mostly happens — and it's the densest interview material. ### Phase C — Cross-cutting (P2) · courses 11–14 **CDC → Platform add-ons → Observability → CI/CD.** Data movement, reliability (idempotency/retries/outbox), seeing production, and shipping. These connect the services rather than living inside one. ### Phase D — Infra depth (P3) · courses 15–19 **Kubernetes → Helm → Istio → IaC → Airflow.** The platform underneath. Deep, valuable, and great for a platform/SRE-leaning interview — but you can work effectively in your services before mastering these. Learn on demand. --- ## Fast track — if you only do five For the quickest jump to daily productivity + interview confidence, in order: 1. **[Go](golang/index.html)** — the language. 2. **[PostgreSQL](postgresql/index.html)** — the datastore + RLS. 3. **[v2 Architecture](v2-architecture/index.html)** — the shape of your code. 4. **[Auth & Authorization](auth/index.html)** — multi-tenancy on every request. 5. **[NATS JetStream](nats/index.html)** — the bus your services subscribe to. Then add **[Platform add-ons](platform-add-ons/index.html)** for the reliability trio (idempotency · retries · outbox) — the single most interview-dense stretch of the track. --- ## How the courses interconnect - **v2 Architecture** rests on **Postgres** (transactions, RLS), **gRPC** (transport), and feeds **sqlc** from **migrations** (Platform add-ons). - **Auth**'s `resource_path`/RLS shows up in **every** query, migration, and the tenancy that survives the async hop in **Kafka**/**NATS**. - **Reliability** (Platform add-ons) uses the **outbox** relayed by **CDC** (Debezium), retries on **Kafka**/**NATS**, and idempotency on the consumer. - **Delivery** (Platform add-ons: spike/SendGrid email, notification/FCM push) runs on the buses from **Kafka**/**NATS** and is scheduled by the **cron** framework. - **Kubernetes → Helm → Istio** stack together; **Containers** and **CI/CD** bookend how code is built and shipped onto them. --- ## Tracking progress Each course's `index.html` shows which lessons are built and marks them `ready`. Do one lesson, take its quiz **cold** (no peeking), and revisit a day later — spacing beats cramming. When you've worked through a phase, a **cold mock interview** across those courses is the best way to prove retention (and it's the one thing this whole library hasn't tested yet) — just ask. _19 courses · 255 lessons · generated 2026-07-12._