The roadmap¶
This is my map from applied LLM engineering into the layer underneath it — the one interviewers probe and production eventually forces you to understand anyway.
I'm writing it in the open because a plan you've published is a plan you have to defend. It is not a general-purpose reading list. It's calibrated to one starting point: someone who already ships LLM systems for a living, is fluent at the orchestration layer — agents, retrieval, prompting, provider glue — and is thin on internals. If that's roughly you, it should transfer. If you're coming from somewhere else, the sequence will still hold even where the weights don't.
Everything here is opinionated, and the omissions are the point.
The call this roadmap makes¶
By 2026 the market has split "AI engineer" and "ML engineer" into genuinely different jobs. ML engineers build and train models: training infrastructure, feature pipelines, GPU clusters. AI engineers build products on top of models: retrieval, agents, evaluation, inference economics. The split happened because foundation models swallowed the middle — the team that fine-tuned BERT for classification in 2021 now calls an API and ships in an afternoon.
I'm targeting the AI engineer side. Reading across 2026 job descriptions, the role is closer to distributed systems engineering with a probabilistic component than to ML research, and employers consistently prioritise retrieval, integration, cloud infrastructure and deployment over fine-tuning or research depth.
That changes the syllabus more than it first appears. The conventional ML-interview roadmap — derive backprop, build a transformer, memorise the bias-variance tradeoff — is prep for a different job. So the internals work here is deliberately instrumental, not foundational: I build a transformer from scratch because interviewers probe exactly one layer below your resume and I need to not flinch, not because I intend to pretrain anything.
If your target is ML Engineer or Research Engineer, invert this: deepen deep learning, and treat evals as secondary.
How this is organised¶
Pillars, not a calendar. Sequence lives in prerequisites, not dates. A plan pinned to specific months is wrong the moment you slip one.
Every module has a "done when" and an hour estimate, so you can plan a week from this page rather than only a quarter. A resource list can't tell you whether you're finished with anything, which is how people end up three-quarters through four courses.
Depth is marked honestly, because time is the scarce input:
- skim — know it exists, read once, move on
- work through — do the exercises, write the code
- reference — come back to it when you need the specific thing
Pick one "work through" resource per pillar and finish it.
Where the hours go¶
~330 hours at 12–13 hrs/week over 26 weeks. The allocation is the argument — anyone can list topics; the hard part is deciding what gets starved.
| Pillar | Hours | Why |
|---|---|---|
| DSA / coding | 75 | The gate. Eliminates more strong candidates than any AI topic, and the longest-lead item — it cannot be crammed. |
| LLM internals | 60 | I use these systems daily and have never built one. This is the credibility gap. |
| AI system design | 45 | The differentiating round, and the one most people under-prepare. |
| Evals & retrieval | 40 | What the job actually is now, and the round that separates people who ship from people who demo. |
| System design | 30 | A general design round is standard at experienced-hire level, and the prerequisite the AI version sits on. |
| Deep learning foundations | 30 | Enough to answer theory questions without hedging. Not a research education. |
| Production engineering | 25 | Security, structured outputs, cost, observability. Named in job descriptions, absent from most roadmaps. |
| Interviews & narratives | 15 | Cheap to prepare, expensive to fail. |
| Retention | 13 | 30 minutes a week. The cheapest hours here, and the ones that stop Phase 1 evaporating by Phase 3. |
Note what isn't here. Maths as a pillar — folded into deep learning as a prerequisite refresher; it's the most seductive rabbit hole in ML prep, feeling like rigorous progress while producing almost no interview value. MLOps — near-zero study time, because Docker, CI, testing and cloud are already the day job and the move is to talk about that. New portfolio projects — cut entirely; shipped systems beat anything buildable in 80 hours, so the work there is packaging. Classical ML breadth as its own track — what survives is folded into deep learning.
Kaggle competitions, MOOC completionism, and broad paper-reading are all negative ROI at this budget.
What depends on what¶
The only ordering that actually matters. Everything else can run in parallel or slot into whatever week has room.
Start today, no prerequisites:
- DSA / coding — and it runs daily throughout, not as a phase
- Deep learning foundations
- System design
- Evals & retrieval
Everything else waits on something:
| Pillar | Needs first | Because |
|---|---|---|
| LLM internals | Deep learning foundations | Backprop before attention. Building a transformer without it is copying, not learning. |
| Production engineering | Evals & retrieval | Security, cost and reliability are all judged against a quality bar you can't set yet. |
| AI system design | System design · Evals · LLM internals | The heaviest prerequisite in the roadmap, and the reason it sits in Phase 2. |
| Interviews & narratives | AI system design | Design narratives are drawn from the cases you've written. |
The one hard rule is system design before AI system design: every AI design answer is a general one with a model in the middle, and doing it backwards produces architectures that detail the embedding pipeline and never mention how requests arrive.
The six-month sequence¶
Phase 0 · Baseline and launch — weeks 1–2¶
Cheap, and it calibrates everything after it.
- Run the diagnostic below. You cannot allocate 330 hours without knowing where you are.
- Resume rewritten for the target role — quantified impact, not responsibilities. Drop stale certifications; dated tooling names signal you stopped paying attention.
- GitHub cleaned. Two strongest repos pinned with real READMEs. Unpin abandoned work.
- Start applying. Not after preparing — now. See the traps below.
- Tracker started. Company, role, date, stage, outcome. The pattern is the signal.
Phase 1 · Foundations — weeks 3–10¶
- Daily: 1–2 DSA problems. Non-negotiable, including bad weeks.
- Weekly: the retention session. From week 3, not later.
- Core: deep learning foundations — Karpathy's Zero to Hero, all of it. The dependency for everything in Phase 2.
- Parallel: start evals and system design. Both are closest to work you already do, so they compound immediately.
- Ongoing: applications, and post-mortems on early rejections.
Phase 2 · Depth — weeks 11–18¶
Where you stop reading as a generalist.
- Daily: DSA continues, now timed sets under interview conditions.
- Core: LLM internals — build a transformer from scratch, then get below the API: KV cache, quantization, serving as mechanics rather than vocabulary.
- Core: AI system design — one case written per week. Written, not read.
- Finish: evals and production engineering.
Phase 3 · Interview mode — weeks 19–26¶
- Weekly mock interviews with real humans. Solving silently trains a different skill than solving out loud for a skeptical stranger.
- 8–10 STAR stories written and rehearsed.
- System design under time pressure.
- Offer negotiation — the highest hourly-rate work in this entire plan.
Interviews happen throughout Phases 1–2, not only here. This phase is about conversion rate, not first contact.
The diagnostic¶
Run this in Phase 0 and again at week 13. It takes an afternoon and it's the only thing that tells you which pillars you can under-spend on. Score each honestly — can I do this right now, unprepared?
| Check | If no |
|---|---|
| Solve an unseen LeetCode medium in 25 min, talking aloud | DSA is your binding constraint. Nothing else matters as much. |
| Derive the gradient of a 2-layer net on a whiteboard | Start deep learning in week 3, not later. |
| Write multi-head attention in numpy from memory | LLM internals is the real gap. Budget the full 60h. |
| Design a URL shortener end to end in 45 min | Do system design before anything AI-specific. |
| State the retrieval precision of something you built, and how you measured it | Evals is not yet a discipline for you. Highest-leverage pillar. |
| Explain how you'd stop indirect prompt injection in an agent that reads webpages | Production engineering, and sooner than Phase 2. |
| Tell a 3-minute story about a system you shipped, with numbers | Interviews. Cheapest gap on this list to close. |
Seven yeses means this roadmap is not for you and you should be interviewing, not studying.
Retention¶
30 minutes, once a week, from week 3. The single highest-return habit here, and the one almost every roadmap omits.
The problem is arithmetic: six months separates Phase 1 from the interviews that test it. The evidence on this is not ambiguous — spaced retrieval produces durable recall where re-reading does not, and the retrieval attempt has to be effortful to count. Passively re-reading your notes in December will feel like studying and will not work.
What the session is:
- Anki, built as you go. One card per "done when" bar you clear, phrased as a question. The System Design Primer ships decks you can start from.
- Re-solve one DSA problem you previously needed the answer key for, from scratch. If you can't, you read it rather than learned it.
- Answer one theory question aloud, cold — why layer norm and not batch norm, what prefill and decode do differently, when an LLM judge misleads you.
Log it like any other session. A skipped retention week is more expensive than a skipped study week, and much less obvious.
If you have three weeks, not six months¶
An interview lands early. It will. The compressed path, in priority order:
- Daily DSA, doubled. Nothing recovers faster and nothing fails harder.
- The general design framework — 5 hours, and it changes how the whole round reads.
- Three written AI system design cases, timed.
- Your stories, written and spoken aloud. Five hours, and the cheapest points available.
Skip the internals work entirely. It doesn't compress, and half-built understanding is worse under questioning than an honest "I haven't built one, here's how I'd reason about it."
Two traps I'm actively avoiding¶
Preparing before applying
Application → screen → onsite runs 6–12 weeks. Waiting until I feel ready costs a full cycle, and I will never feel ready. So applications start in Phase 0, underprepared: early interviews are calibration, and they reveal where I actually fail — which is rarely where I assumed.
The signal worth tracking is which stage rejects you. Resume screen is a positioning problem. Coding round is a DSA problem. Onsite is a system design problem. Don't guess — let the pattern redirect the hours.
Studying the layer I already know
Comfortable material feels productive and teaches nothing an interviewer will probe. Another agent-framework tutorial is procrastination for me; the value is in attention mechanics, serving internals, and evaluation rigour. For someone academic the inverse holds — more theory is procrastination, and the value is in shipping something deployed.
Aim at the gap. It's uncomfortable, which is how you know it's the right target.
What actually happened, week by week, is in the learning log.