"How do I become an AI engineer?" is the most common question we get from working developers in 2026. The honest answer is a two-part one: get the high-level career picture right, then follow a specific month-by-month skills path. This guide is the second part — the granular checklist of what to study, in what order, with what checkpoints.
If you haven't read it yet, start with how to become an AI engineer in 2026 for the why and the broader strategy. This guide is the implementation.
How to use this roadmap
Six months, ~15 hours per week, with concrete checkpoints at the end of each month. If you're a working developer with strong fundamentals, you can compress this to 3–4 months. If you're brand new to programming, expand to 9–12.
You don't have to follow it exactly. Use it as a default plan you deviate from when you find something more interesting.
Month 1 — Modern Python + first LLM calls
Goal: be comfortable writing typed Python that calls an LLM and returns structured output.
Topics:
- Python 3.11+ idioms: type hints,
dataclasses, pathlib, asyncio basics.
- Environment management with
uv (the modern replacement for pip + venv).
- Pydantic v2: models, validation, JSON serialization.
- OpenAI Python SDK: chat completions, structured outputs (
response_format=), streaming.
- Anthropic Python SDK: messages API, tool use basics.
- Cost awareness: tokens, context windows, why caching matters.
Checkpoint:
- Build a CLI that takes a webpage URL, scrapes it, summarizes it with an LLM, and returns a structured Pydantic object (title, key_points, sentiment).
- Track and print the dollar cost of each run.
Month 2 — Async, FastAPI, and the first deployed service
Goal: ship a small AI-backed web service with a real URL.
Topics:
- Async Python in depth:
async def, await, gather, structured concurrency.
- FastAPI: routes, request/response models, dependency injection.
- Deployment to Vercel (via FastAPI on Vercel Functions) or Fly.io.
- Basic auth (a single API key header is fine for v1).
- Logging and basic observability (Logfire is great for FastAPI).
Checkpoint:
- Deploy a FastAPI service that exposes one endpoint: POST
/analyze taking a URL and returning the structured analysis from month 1.
- The service should handle 5 concurrent requests without falling over.
- Live URL you can share.
Month 3 — RAG fundamentals: chunking, embeddings, vector search
Goal: build a "chat with my docs" app that actually retrieves relevant chunks.
Topics:
- Document loading (PDF, web, Notion exports).
- Semantic chunking strategies (size, overlap, header-anchoring).
- Embeddings: how they work conceptually (see our vector embeddings explainer).
- Vector databases: pgvector for under 1M chunks, Qdrant or Weaviate above.
- Cosine similarity vs dot product vs Euclidean.
Checkpoint:
- Build a chat UI over 100+ pages of documentation.
- Each answer should cite the chunks it used.
- Achieve a 70%+ answer-correctness on a 20-question manual eval set.
Month 4 — Production RAG: hybrid search, reranking, evals
Goal: move from "RAG that kinda works" to "RAG that lifts answer quality measurably."
Topics:
- Hybrid search: combining BM25 and vector search.
- Reranking with Cohere Rerank or BGE Reranker.
- Building an eval harness (start with
inspect-ai, promptfoo, or plain Python).
- LLM-as-judge scoring for fuzzy correctness.
- Grounded citation enforcement.
Checkpoint:
- Hybrid + reranking lifts your month-3 RAG eval from 70% to 85%+.
- A dashboard or CSV that shows pass rate over time as you change prompts/models.
Month 5 — Agents, tools, and stateful workflows
Goal: build an agent that takes multi-step actions and recovers from errors.
Topics:
- Tool use / function calling on OpenAI and Anthropic SDKs.
- The agent loop: model → tool → model → ... until done.
- Picking between Pydantic AI (typed agents) and LangGraph (graph-based) — see LangChain alternatives.
- Retries, error handling, partial failure.
- Human-in-the-loop checkpointing.
Checkpoint:
- Build an agent that completes a real multi-step task end-to-end (e.g., research a company, draft a report, post it to Slack).
- The agent should handle at least one expected failure mode (e.g., API timeout) gracefully.
Month 6 — Production polish, portfolio, and job search
Goal: turn one of your projects into the centerpiece of your portfolio and start interviewing.
Topics:
- Production observability: structured logs, traces, cost dashboards.
- Latency optimization: streaming, caching, parallelization.
- Security: prompt injection, secret handling, rate limiting.
- Writing a great project README.
- Building a personal site or blog around your work.
Checkpoint:
- One project deployed publicly with: clear README, live demo, eval results, source code, blog post explaining the work.
- 10 job applications submitted, 2–3 interviews scheduled.
Comparison: 6-month plan vs alternatives
| Path |
Time |
Cost |
Trade-off |
| This roadmap |
6 mo |
<$500 |
Requires self-discipline |
| Bootcamp |
12–16 wk |
$3K–$10K |
Structure, expensive |
| MS in AI/ML |
1–2 yr |
$30K–$80K |
Credential, slow |
| AI engineer apprenticeship |
6–12 mo |
Paid |
Scarce slots |
Common mistakes to avoid
Spending months on "fundamentals" before shipping anything. Ship a tiny project in week 2. Iterate.
Building chatbots no one wants. Your portfolio projects should solve real problems for real users (even just yourself).
Skipping evals. Hiring managers ask about evals more than any other topic. Don't be the candidate who can't answer.
Treating "AI engineer" as the same as "ML engineer." Different jobs. AI engineer = application layer. ML engineer = training and infrastructure. This roadmap is for the first.
FAQ
Can I do this with a day job?
Yes — most people who've done it had a day job. 15 hours/week is doable evenings + weekends if you protect the time religiously.
What if I only have time for 3 months, not 6?
Compress months 1+2 if you're already a working developer. Months 3–6 are the AI-specific work that's harder to skip.
Should I learn ML theory in parallel?
A little, after month 3. Hands-on first; theory backfills naturally as questions come up.
Where to go next
For deeper context on the path, see how to become an AI engineer in 2026, best AI APIs for developers in 2026, and how vector embeddings work in 2026.