12-Month Roadmap — Zero to Principal LLM Engineer

A month-by-month plan that turns this curriculum into demonstrable skill, a portfolio, and interview-readiness. Pairs with the faster 90-Day Roadmap (which is the first quarter here, intensified). Every month ends with shippable artifacts — because in interviews and on the job, what you've built beats what you've read.

How to use this

  • Each month has: a theme, the phases/docs to study, the labs/exercises to do, and the artifacts to produce (commit them to a public repo — your portfolio is your moat as a candidate, Phase 15.06).
  • The rule: never just read. Every concept doc ends with a Hands-On Lab — do it. Every phase has exercises (exercises/) — answer them in writing.
  • Track depth, not pace. "We care more about the foundation and having essential understanding." If a month takes six weeks, take six weeks — but produce the artifacts.
  • The four pillars of an impressive candidate (build all four over the year): (1) fundamentals you can explain from first principles, (2) a portfolio of working systems, (3) production judgment (cost/latency/reliability/safety), (4) a specialization (pick one role, interview-prep/).

Quarter 1 — Foundations & First Systems (Months 1–3)

Goal: understand LLMs from first principles, read the ecosystem fluently, and ship your first RAG + agent + eval systems. This quarter mirrors the 90-Day Roadmap — follow it intensively.

Month 1 — Vocabulary, Transformers, and the Ecosystem

  • Study: Phase 0 (orientation), Phase 1 (LLM vocabulary), Phase 2 (transformer foundations), the reference What Happens When You Prompt an LLM Agent.
  • Do: exercises/01-vocabulary.md (all 15); diagrams/ — redraw the transformer-inference, tokenization, and prefill/decode diagrams from memory.
  • Artifacts: a written one-page explanation of "what happens, token by token, when you prompt an LLM" (no jargon unexplained); a tokenizer + KV-cache-memory calculator (labs/lab-06-tokenizer-and-kv-cache/).
  • Impressive-in-interview signal: you can whiteboard prefill vs decode and explain why decode is memory-bandwidth-bound.

Month 2 — Model Cards, Catalogs, Selection, and the SDK

Month 3 — RAG, Agents, and Evaluation (your first real systems)

End of Q1 you can: explain LLM internals, read any model card, choose a model defensibly, and ship RAG + agent + eval systems. Portfolio: 3–4 working repos.

Quarter 2 — Production Engineering (Months 4–6)

Goal: take systems from "works on my laptop" to "runs in production" — serving, gateways, cost/latency discipline, observability, and reliability.

Month 4 — Local Inference & Serving Internals

Month 5 — Gateways, Routing, and Cost Control

  • Study: Phase 8 (LLM gateways), revisit Phase 7.07–7.09 (routing/observability/cost).
  • Do: labs/lab-08-llm-gateway/, labs/lab-11-cost-calculator/.
  • Artifacts: a working gateway (provider adapters + model registry + routing + fallback + usage metering + streaming proxy); a unit-economics cost model with caching/routing levers.
  • Signal: you can design a multi-provider gateway and engineer gross margin from cost-per-resolved-task.

Month 6 — Observability, Reliability, and the Production Runbook

  • Study: Phase 7.08–7.10, Phase 10.08 (agent observability), Phase 12.06 (latency/cost evals).
  • Do: labs/lab-12-observability/; templates/04-incident-runbook.md.
  • Artifacts: an observability layer (traces with correlation IDs, p95/p99, cost per request); a production runbook; a load test producing a latency/cost report.
  • Signal: you instrument cost and latency from day one and can run an incident.

End of Q2 you can: serve models, build a gateway, control cost/latency, and operate LLM systems. Portfolio: a production-grade serving + gateway stack.

Quarter 3 — Depth, Specialization & Safety (Months 7–9)

Goal: go deep — fine-tuning, AI coding platforms, security/governance — and begin specializing toward one role.

Month 7 — Fine-Tuning and Adaptation

  • Study: Phase 13 (fine-tuning).
  • Do: labs/lab-13-lora-finetune/; apply the prompt→few-shot→RAG→fine-tune ladder to a real task.
  • Artifacts: a QLoRA fine-tune on a small model with a before/after eval + a forgetting check; a written "when not to fine-tune" decision for your task.
  • Signal: you know fine-tuning teaches behavior not facts, and you can run LoRA/QLoRA + eval-gate it.

Month 8 — AI Coding Platforms & Advanced Agents

  • Study: Phase 11 (AI coding platforms); revisit Phase 10.06–10.07 (code/browser agents).
  • Do: labs/lab-10-structured-output/; build a mini code-editing agent (apply-patch + eval).
  • Artifacts: a codebase-indexing + symbol-search prototype; an apply-patch agent with an apply-rate/task-resolution eval.
  • Signal: you understand context selection under a latency budget and latency-tiered multi-model routing.

Month 9 — Security, Privacy & Governance

  • Study: Phase 14 (security/privacy/governance).
  • Do: labs/lab-14-prompt-injection-redteam/; fill the security checklist.
  • Artifacts: a red-team report (direct/indirect/exfil) + an enforced trust boundary; a PII-safe audit log; a tenant-isolation leak-test suite.
  • Signal: you treat injection as architectural, fail closed, and can pass an enterprise security questionnaire.

End of Q3 you can: fine-tune, build coding agents, and secure/govern LLM systems. Portfolio: a fine-tune + a secured multi-tenant system. Specialization chosen.

Quarter 4 — Capstone, Startup & Interview Mastery (Months 10–12)

Goal: integrate everything into one platform, learn to build a product/business on it, and become interview-ready at a senior/principal bar.

Month 10 — The Capstone Platform

  • Study: the Capstone spec.
  • Do: build it — gateway + registry + adapters (local + vLLM) + OpenAI-compatible API + model-selection UI + cost dashboard + eval harness + RAG + coding + agent demos.
  • Artifacts: the Startup-Grade LLM Platform (all 18 components) + architecture diagrams + deployment guide + security checklist + ops runbook + investor/demo narrative.
  • Signal: one repo proves you can interpret terminology, choose models, estimate cost/memory, serve, route, build RAG/agents, evaluate, and operate in production.

Month 11 — Startup Playbook & Product Thinking

  • Study: Phase 15 (startup playbook).
  • Do: exercises/07-startup-product.md; run an opportunity map → discovery → MVP spec → unit economics → moat → demo.
  • Artifacts: an opportunity map, an MVP spec, a unit-economics model, a moat strategy, and a 3-minute technical demo of your capstone framed as a product.
  • Signal: you answer "can OpenAI build this?" structurally and your demo shows before→after→trust→outcome.

Month 12 — Interview Mastery & Specialization

  • Study: your chosen role in interview-prep/ (one of nine), plus the papers reading guide.
  • Do: the role's 30-minute drill, the 2-hour take-home, all relevant exercises/; mock system-design and debugging interviews.
  • Artifacts: a polished portfolio (capstone + 4–6 supporting repos), a role-specific portfolio project, completed take-home, and a written "senior-level expectations" self-assessment.
  • Signal: you pass system-design, debugging, and incident rounds at a senior bar and can defend every design decision with cost/latency/reliability/safety reasoning.

End of Q4 you can: build a startup-grade platform end-to-end, reason about it as a product and business, and interview at a senior/principal level in your chosen specialization.

The portfolio you'll have built (your interview moat)

By month 12, a public repo set demonstrating:

  1. Fundamentals — tokenizer/KV-cache calculator, a "what happens when you prompt" explainer.
  2. RAG — Q&A app with hybrid search, reranking, citations, retrieval+generation evals.
  3. Agents — tool-calling agent with the trust boundary + per-step reliability eval.
  4. Serving — local quantized inference + vLLM with p95-under-load benchmarks.
  5. Gateway — multi-provider routing/fallback/metering/streaming + cost model.
  6. Evaluation — a reusable eval harness with a golden set and an LLM-judge with calibration.
  7. Fine-tuning — a QLoRA fine-tune with eval-gating and a forgetting check.
  8. Security — a red-team report + trust boundary + tenant-isolation tests + audit log.
  9. Capstone — the integrated Startup-Grade LLM Platform.
  10. Product — an opportunity map, MVP spec, unit-economics model, and demo narrative.

The principle: every claim on your résumé maps to a repo and a number (a p95, a cost-per-resolved-task, an eval score, an apply-rate). That is what makes a candidate impressive — not knowing about LLMs, but having built and measured LLM systems. (interview-prep/ shows how to present each.)

Pacing variants

  • Full-time intensive (career switch): compress to ~6 months by doing two months' work per month; keep all artifacts.
  • Part-time (employed, ~10 hrs/week): the 12-month plan as written.
  • Already an engineer: skip Months 1–2 fundamentals you know, but still do the labs — the artifacts are the point.
  • Targeting one role now: do Q1, then jump to your role's phases + interview-prep/, then backfill.

Next: start Month 1 with Phase 0, or jump to the 90-Day Roadmap for the intensive first quarter. Track every artifact in a public repo.