AI Engineering Roadmap
8-week master plan
Created by Md Zeeshan Ali
Plan
Reviewed and updated for May 2026 · 8-week intensive track
8-week sprint: 60 hours of structured material × 2 = 120 hours total (learning + implementation), which is about 15 hours per week. Treat it like a part-time job and put it on your calendar.
4
Phases
8 weeks
Intensive duration
12
Phase exercises
Do the exercises during the phase, immediately after the related topic cluster, not all at the end. Each one should become a small public artifact: push the code to GitHub, write a concise README with screenshots or a demo clip, and share what you built on LinkedIn or YouTube.
Phase 1 — Foundations · week 1–2
Python fluency
numpy, pandas, async/await, plus pydantic — typed models are now central to AI codebases.
Exercise 1.1 · Build and publish
Learning Progress Data Explorer
Build a Python CLI or tiny web app that reads CSV/JSON learning logs, cleans them with pandas, calculates weekly progress, and exports one chart plus a Markdown summary.
When: Do this right after Python fluency, pandas/numpy, and basic project setup.
Solidifies: Python fluency, pandas, numpy basics, file I/O, plotting, data cleaning, project structure, README writing.
Public artifact: Push the repo with sample data, screenshots, and a LinkedIn post or short YouTube walkthrough of the progress dashboard.
Just-enough math
Linear algebra intuition and basic probability — enough to read papers, not derive them.
Core ML concepts
Training vs inference, loss, overfitting, embeddings, tokens — enough to reason about model behavior.
Exercise 1.2 · Build and publish
Embedding Similarity Playground
Create a local notebook or Streamlit app where you embed your notes, visualize nearest neighbors, and explain why semantically similar text clusters together.
When: Do this after just-enough math, core ML concepts, tokens, and embeddings.
Solidifies: embeddings, vectors, cosine similarity, tokens, linear algebra intuition, data visualization, model behavior.
Public artifact: Push the notebook/app and share a post explaining embeddings with one visual example from your own notes.
Transformer architecture intuition
Attention, residual streams, how next-token prediction creates apparent reasoning.
LLM behavior fundamentals
new
Reasoning models vs base models, context windows, tool use, why models hallucinate. Foundational for everything after.
Exercise 1.3 · Build and publish
Typed LLM Behavior Lab
Build a small Python app that sends controlled prompts to an LLM, records outputs into Pydantic models, and compares temperature, instruction clarity, and context length.
When: Do this at the end of Phase 1, after transformer intuition and LLM behavior fundamentals.
Solidifies: pydantic, API calling, experiment design, LLM behavior, hallucination patterns, structured result capture.
Public artifact: Push the experiment runner and post your findings as "3 things I learned about LLM behavior."
Phase 2 — LLM engineering · week 3–4
Context engineering
updated
The 2025 successor to "prompt engineering" — composing system prompts, examples, retrieved data, and tool results into context that fits and works.
LLM APIs — OpenAI, Anthropic, Gemini
updated
Structured outputs, function calling, prompt caching, streaming, batch APIs. Know the cost and latency tradeoffs of each provider.
RAG — retrieval, hybrid search, reranking, agentic RAG
updated
Vector + BM25 hybrid, cross-encoder rerankers, query rewriting, and letting the agent decide when to retrieve. Long context complements but doesn't replace.
Exercise 2.1 · Build and publish
RAG Knowledge Base for Your Own Docs
Build a Q&A app over your notes, PDFs, or code snippets with chunking, embeddings, retrieval, answer citations, and a small comparison between naive retrieval and improved retrieval.
When: Do this after context engineering, LLM APIs, structured outputs, and the RAG topic.
Solidifies: RAG, chunking, embeddings, vector search, retrieval quality, citations, context construction, error analysis.
Public artifact: Push the repo with a demo dataset, screenshots, and a LinkedIn/YouTube explanation of where retrieval failed and how you improved it.
Multimodal — vision and audio inputs
new
Pass images, PDFs, screenshots, audio to modern models. Now table stakes — most production AI products use vision somewhere.
Exercise 2.2 · Build and publish
Multimodal Document Analyst
Build an app that accepts a screenshot, invoice, resume, or report page, extracts structured data, validates it with Pydantic, and lets the user ask follow-up questions.
When: Do this after multimodal inputs and structured output/schema validation.
Solidifies: vision inputs, PDF/screenshot handling, structured outputs, schema design, validation, prompt/context design.
Public artifact: Push the repo with redacted examples and post a before/after demo showing unstructured input becoming usable structured data.
Modern orchestration — LangGraph, Pydantic AI, DSPy
updated
LangGraph for stateful graphs, Pydantic AI for typed agents, DSPy for programmatic prompt optimization. LangChain itself is now legacy for new code.
Vercel AI SDK
new
Your unfair advantage as a frontend engineer — streaming, tool use, generative UI in React/Next.js. Ship AI features your team can actually merge.
Exercise 2.3 · Build and publish
Streaming AI Copilot in React
Build a Next.js or React copilot with streamed responses, one tool call, loading states, retry behavior, and a clean UI that feels production ready.
When: Do this after orchestration and Vercel AI SDK streaming/tool-use patterns.
Solidifies: Vercel AI SDK patterns, streaming, tool calling, frontend state, latency UX, provider cost/latency tradeoffs.
Public artifact: Push the repo, deploy it, and share a demo clip focused on the UX decisions that make AI feel responsive.
Fine-tuning, RAG, and prompting
Decision framework and hands-on. LoRA, instruction tuning, and the OpenAI / Anthropic fine-tuning APIs — know enough to actually do it, then choose wisely.
Phase 3 — Agentic AI · week 5–6
AI agents and tool use
Tool/function calling loops, planning, memory, when an agent is the right shape vs a workflow.
Exercise 3.1 · Build and publish
Tool-Using Research Agent
Build an agent that can search local docs, call at least two tools, produce a cited brief, and show the tool steps it took before answering.
When: Do this after agent basics, tool/function calling, planning, and memory.
Solidifies: tool calling, planning loops, memory, agent vs workflow judgment, traceable outputs, failure handling.
Public artifact: Push the repo and share a demo where you intentionally show one failed tool path and how the agent recovers.
MCP — Model Context Protocol
updated
Now an industry standard supported by OpenAI, Anthropic, Google, JetBrains, Cursor. Build at least one server and one client.
Exercise 3.2 · Build and publish
Tiny MCP Server and Client
Build an MCP server exposing a useful personal tool, such as reading a learning log, querying a bookmarks file, or creating a GitHub issue, and connect it to a simple client.
When: Do this immediately after the MCP topic, before going deep into multi-agent systems.
Solidifies: MCP primitives, server/client boundaries, tool schemas, typed inputs, integration testing, AI app extensibility.
Public artifact: Push both server and client with a setup video or README GIF showing another developer how to run it.
Multi-agent systems
Supervisor patterns, handoffs, when to use them and when one good agent beats five mediocre ones.
Computer use and browser agents
new
Anthropic Computer Use, OpenAI Operator-style agents, Playwright-driven flows. The next big surface for AI products.
Voice AI and realtime APIs
new
Speech-to-speech models and WebRTC streaming. Voice agents are now a real product category, not a demo.
Evals — the highest-leverage skill
updated
Error analysis, custom datasets, LLM-as-judge with calibration, regression testing. The single skill that distinguishes serious AI engineers from prompt tinkerers.
Exercise 3.3 · Build and publish
Agent Eval Harness
Create a 20-row evaluation set for your agent, run it on every change, score answer quality with a rubric, and log the biggest failure modes.
When: Start the eval rows while building Exercises 3.1 and 3.2, then finish this after the evals topic.
Solidifies: eval datasets, LLM-as-judge calibration, regression testing, error analysis, measurable agent improvement.
Public artifact: Push the eval harness and post the scorecard showing what improved between version 1 and version 2.
Phase 4 — Production and MLOps · week 7–8
Deployment — FastAPI, Docker, Modal
updated
FastAPI for the API layer, containers for portability, Modal or similar for serverless GPU when you need fine-tuning or open models.
Exercise 4.1 · Build and publish
Production API Wrapper for Your AI App
Turn one earlier project into a FastAPI service with Docker, typed request/response models, health checks, rate limiting, and a simple deploy target.
When: Do this after deployment, FastAPI, Docker, and environment/config basics.
Solidifies: FastAPI, Docker, deployment, API design, environment config, pydantic contracts, operational readiness.
Public artifact: Push the productionized repo and share an architecture diagram plus a short deployment walkthrough.
Observability — Langfuse, Logfire, Arize
updated
Trace every LLM call. OpenTelemetry-based tooling has matured; pick one and instrument from day one.
Security — prompt injection, jailbreaks, OWASP LLM Top 10
updated
Indirect prompt injection is the most common AI vulnerability shipped to production. Know the patterns and the OWASP LLM Top 10.
Exercise 4.3 · Build and publish
Prompt-Injection Defense Lab
Add adversarial test cases to your RAG or agent app, detect risky instructions, isolate retrieved content from system instructions, and document what still breaks.
When: Do this immediately after security, OWASP LLM risks, and production hardening.
Solidifies: OWASP LLM risks, indirect prompt injection, security testing, trust boundaries, eval-driven mitigation, incident notes.
Public artifact: Push the test suite and share a security write-up with safe examples of attacks, mitigations, and remaining risks.
Cost and latency optimization
new
Prompt caching, model routing (small first, escalate to large), request batching, quantization, and self-hosted inference (vLLM / SGLang). The 5–10x lever in production.
Exercise 4.2 · Build and publish
Observability and Cost Dashboard
Instrument your LLM calls with traces, latency, token usage, error labels, and per-feature cost. Add a dashboard or exported report that explains what changed after optimization.
When: Do this after observability, tracing, cost, and latency optimization topics.
Solidifies: Langfuse/Logfire-style tracing, observability, token accounting, latency analysis, prompt caching, model routing, cost control.
Public artifact: Push the instrumentation and post a case study: "How I reduced latency/cost in my AI app."
Skills to skip
Training LLMs from scratch Classic ML deep dives (SVMs, decision trees) TensorFlow / Keras Hadoop / Spark Computer vision removed — now multimodal
Resources- 2026
~60 hours of structured material + ~60 hours of practice (120 total over 8 weeks at ~15 hr/week)
54
Resources
~60 hr
Structured time
29
New / updated
Phase 1 — Foundations
BL
Learn X in Y Minutes — Python
Compact cheatsheet to refresh syntax fast.
Cheatsheet ~30 min
BK
Automate the Boring Stuff with Python
Free book, chapters 1–6 — practical Python idioms.
Book ~2 hr
DC
Pandas — “10 minutes to pandas”
Official quickstart. Covers DataFrames, indexing, and the NumPy basics you actually use day-to-day.
new Docs
~45 min
BL
Real Python — Async IO in Python
The clearest async/await primer. Maps cleanly from JS — differences between coroutines, tasks, and the event loop are spelled out.
new Blog
~1 hr
DC
Pydantic — Concepts and models
The type system underpinning FastAPI, Pydantic AI, Logfire, and OpenAI structured outputs. Closest mental model to Zod for JS folks.
new Docs
~45 min
YT
3Blue1Brown — Essence of Linear Algebra
Visual, intuitive linear algebra. The standard recommendation for a reason.
Video ~3 hr
YT
3Blue1Brown — Neural Networks (incl. attention and GPT)
The clearest visual explanation of what a transformer actually does. Watch after linear algebra.
new Video
~2 hr
BL
Jay Alammar — The Illustrated Transformer
Still the best 30-minute explanation of attention.
Blog ~30 min
CR
fast.ai — Practical Deep Learning, lessons 1–3
Top-down deep learning intuition. Skip the rest of the course unless you enjoy it.
Course ~3 hr
YT
Karpathy — Neural Networks: Zero to Hero
Watch micrograd, "Let's build GPT", and the GPT tokenizer videos. Demystifies what's actually inside an LLM.
Video ~6–7 hr
YT
Karpathy — Deep Dive into LLMs like ChatGPT
Pretraining, post-training, RLHF, hallucinations, reasoning, tool use — the most complete free LLM intro that exists.
new Video
~3.5 hr
YT
Karpathy — How I use LLMs
Practical companion to “Deep Dive into LLMs”. Real workflows, tools, prompting habits, when to trust output. Feb 2025.
new Video
~2 hr
Phase 2 — LLM engineering
DC
Anthropic — Prompt engineering and extended thinking
The reference for serious prompting. Covers reasoning models, prompt caching, and tool use.
updated Docs
~1 hr
DC
OpenAI — Prompt and context engineering guide
Practical patterns for instructions, examples, tool outputs, and structured context. Great complement to Anthropic's approach.
new Docs
~45 min
DC
OpenAI — Reasoning-model best practices
Reasoning models (o-series, Claude extended thinking, DeepSeek R1) need different prompting. Clear specs, minimal CoT prompting, developer-message patterns.
new Docs
~30 min
GH
OpenAI Cookbook
Hundreds of working examples — structured outputs, function calling, batch, realtime.
GitHub Self-paced
GH
Anthropic Cookbook
Recipes for tool use, vision, PDFs, citations, and Claude-specific patterns.
GitHub Self-paced
DC
Google — Gemini API quickstart
The third major provider — long context, multimodal, and competitive pricing.
Docs ~30 min
DC
Anthropic — Vision and PDFs
How to send images, screenshots, charts, and PDF documents to Claude. The canonical reference for multimodal inputs.
new Docs
~30 min
DC
Vercel AI SDK
Your frontend background pays off here — typed streaming, tool use, and generative UI in React/Next.js. Highest leverage of any single tool for you.
new Docs
~1 hr
DC
LlamaIndex — RAG and ingestion
Best-in-class for document loaders, chunking strategies, and structured RAG patterns.
Docs ~1 hr
CR
DeepLearning.AI — Building and Evaluating Advanced RAG
Hands-on video course on rerankers, sentence-window retrieval, and evaluating RAG quality. Pairs with LlamaIndex docs.
new Course
~1 hr
DC
LangGraph — Quickstart and agent tutorials
Replaces the LangChain tutorial as the primary recommendation. Stateful agents with checkpoints and streaming.
updated Docs
~1.5 hr
DC
Pydantic AI
Typed agents from the Pydantic team — the cleanest mental model for production agent code.
new Docs
~1 hr
DC
DSPy — Programming, not prompting
Stanford's framework for compiling prompts. Worth knowing even if you don't adopt it — it changes how you think.
new Docs
~1 hr
HF
Hugging Face — LLM Course, units 1–2
Open-source models, transformers library, basics of fine-tuning.
HF ~2 hr
CR
DeepLearning.AI — Finetuning Large Language Models
Hands-on LoRA, instruction tuning, and the actual mechanics of fine-tuning a small model. Closes the loop on the decision framework.
new Course
~1.5 hr
Phase 3 — Agentic AI
BL
Anthropic — Building Effective Agents
Workflows vs agents, common patterns, when not to use either. Required reading.
Blog ~45 min
CR
DeepLearning.AI — AI Agents in LangGraph
Hands-on agent patterns from the LangChain team. Pairs well with the Anthropic post.
Course ~1.5 hr
DC
OpenAI Agents SDK
Lightweight Python SDK with handoffs, guardrails, tracing. Good "first agent framework" for OpenAI-heavy stacks.
new Docs
~1 hr
CR
DeepLearning.AI — Multi AI Agent Systems with crewAI
Build multi-agent systems with role-based agents, handoffs, and tasks. The canonical hands-on intro to multi-agent patterns.
new Course
~1.5 hr
DC
Model Context Protocol — official docs
Build a server, build a client, ship a useful tool. Now industry standard.
updated Docs
~1 hr + lab
DC
Anthropic — Computer Use
Screenshots in, mouse/keyboard out. Build a working browser agent in an afternoon.
new Docs
~30 min
DC
OpenAI — Realtime API
Speech-to-speech via WebRTC. Voice agents are now a real product surface.
new Docs
~30 min
BL
Anthropic — Claude Code best practices
The closest thing to a frontier-lab playbook for working with coding agents: context curation, plan-then-execute, file ops, debugging loops.
new Blog
~45 min
BL
Hamel Husain — Evals FAQ
The single most-cited eval guide in serious AI eng. Error analysis, custom datasets, LLM-as-judge done right.
new Blog
~1 hr
DC
Braintrust — Evals guide
Practical scoring functions, datasets, and CI integration. Pairs with Hamel's FAQ.
Docs ~1 hr
Phase 4 — Production and MLOps
DC
FastAPI — Tutorial, first 10 sections
The default Python web framework for AI APIs. Streaming and async map cleanly to LLM workloads.
Docs ~1.5 hr
DC
Docker — Get started, parts 1–5
Enough Docker to ship a containerized FastAPI service to any cloud.
Docs ~1.5 hr
DC
Modal — Serverless GPU and AI examples
Pythonic serverless. The fastest path from "I have a Python script" to "it runs on a GPU on demand".
new Docs
~1 hr
BL
Eugene Yan — Patterns for Building LLM-based Systems
The canonical map of architectural patterns in production AI: evals, RAG, fine-tuning, caching, guardrails, defensive UX. Read it twice.
new Blog
~1 hr
DC
Langfuse — LLM observability
Open-source tracing, prompt management, evals. Free tier is enough for serious projects.
Docs ~45 min
DC
Pydantic Logfire
OpenTelemetry-native observability that handles plain Python and AI workloads in one place.
new Docs
~30 min
DC
Anthropic — Prompt caching
The single highest-leverage cost lever in production: cache long system prompts and contexts to cut spend 5–10x and improve latency.
new Docs
~30 min
DC
vLLM — Quickstart and serving
The default high-throughput inference server for open-weight models. Required reading for self-hosting Llama, Qwen, DeepSeek at scale.
new Docs
~45 min
BL
OWASP — LLM Top 10
The standard taxonomy of LLM vulnerabilities. Reference it in design reviews.
new Reference
~30 min
CR
DeepLearning.AI — Red Teaming LLM Applications
Practical attack patterns and defenses for production LLM apps.
Course ~1 hr
Stay current
BL
Simon Willison's blog
The single best signal-to-noise blog in AI. Try every model, ship every weird idea.
Blog Daily
BL
AI News — Smol AI
Daily summary of every Discord, Reddit, and Twitter thread that mattered. Time-saver.
Newsletter Daily
HF
Hugging Face blog
Open-source model releases and applied write-ups, often the day they ship.
HF Daily
BL
Latent Space
Newsletter and podcast — deep interviews with the people actually building.
Blog Weekly
BL
Hamel Husain
Evals, fine-tuning, what consultants actually see in real LLM systems.
new Blog
Frequent
BL
Eugene Yan
System design and applied ML/LLMs. Long-form pieces that hold up over time.
new Blog
Monthly
BL
Lil'Log — Lilian Weng
The reference posts on agents, hallucination, RLHF. Slow but definitive.
new Blog
Quarterly
Execution playbook
Tricks to finish ASAP
Skim, don't read. Most docs are reference material. Read at 2x scan first; deep-dive only when you hit something you'll actually use this week.
Watch videos at 1.5×–2×. Karpathy's Z2H goes from ~7 hr to ~4 hr at 1.75×. You will not lose information; you will gain time.
Build before you finish learning. Pick one project on day 3 — "a Vercel AI SDK + LangGraph + MCP RAG-and-agent thing" — and treat the curriculum as just-in-time learning.
Skip what you already know. As a frontend engineer: skim Learn X in Y, Async IO, FastAPI, Docker. Don't rewatch the basics.
Compound projects, don't restart them. Same repo for everything: add multimodal → add agents → add MCP → add evals → add Logfire → add caching. One repo at the end shows depth.
Phase 4 is JIT. Don't learn FastAPI, Docker, Modal, vLLM, OWASP until you have something that actually needs them. They're 1-day skills when motivated.
Use AI to learn AI. Paste any confusing concept into Claude or ChatGPT and ask "explain like I'm a frontend engineer." It is the world's best on-demand tutor.
Public artifacts beat private notes. Tweet weekly. One LinkedIn post per phase. A 20-line README on each project. Recruiters at top AI companies read these.
Find one accountability partner. Latent Space Discord, AI Engineer community, a friend doing the same. Solo timelines usually drift; paired timelines usually ship.
Stop watching what you already know. If a video says "tokens are sub-words" and you already know that, jump 3 minutes.
Two non-negotiable evals. Even on a tiny demo, write a 20-row eval set + a Langfuse trace. That single habit is what separates the top decile from the rest of the field.
Execution order that works. Hit Phase 1 + Phase 2 hard for 4 weeks → ship a public project → then layer Phase 3 + Phase 4 onto that same project for 4 more weeks. Two months from today you'd have a portfolio piece and a credible AI-engineer narrative.