The AI engineer roadmap: what to learn, in what order, and what to skip

AI engineering is a lot to take in, but the order makes it manageable. Learn it in six phases: foundations, building with models, context and knowledge, reliability, running it, and an optional deeper phase on the models themselves. Skip model training, framework-hopping and project-free certificates early on, and finish each phase with one small project.

Open any feed and AI engineering looks like a hundred things to learn by Friday. New models, new frameworks, new words. It is easy to read about all of it and build none of it.

The honest truth is kinder than the feed. An AI engineer builds products where a model does part of the work, and most of that product is ordinary software around the model call. If you already write code or move data for a living, you are closer than you think.

This post is the map: six phases in order, three things to skip for now, and one project per phase. If you are a data engineer who wants a month-by-month plan, read from data engineer to AI engineer: the 6-month switch. This is the wider map behind it.

The map in one picture

six towns in order; each one uses what you learned in the town beforeFoundationsphase 1Modelsphase 2Contextphase 3Reliablephase 4Runningphase 5DeeperoptionalSKIP FOR NOWtraining from scratch,every new framework,certificates alone
The roadmap as six towns. The last one is a side trip, and the detour sign marks what can wait.

Think of it as a road with six towns. Drive at your own speed, but keep the order: each town uses what you learned in the one before. The last town is a side trip, and plenty of good AI engineers never go there. The detour sign marks things that look important early but slow you down.

The six phases

climb one stair at a time; each stair ends with something that works1 FoundationsPython, APIs,SQL, Git, cloud2 Modelsprompts, JSON,tools, the loop3 Contextretrieval, RAG,the window4 Reliableevals, guardrails,traces, tests5 Runningcost, shipping,security, people6 Deeperfine-tune, serve,a tiny modeloptional
Six phases as a staircase. Stair 4 is the one people most want to skip, and the one that makes you trustworthy.

Each phase ends with a sentence you can truthfully say about yourself. That sentence matters more than the hours spent.

Phase 1: foundations

What to learn: Python well enough to write and test small programs. APIs, which are how one program asks another for something over the web, usually sending and receiving JSON (a simple text format for data). SQL, because most useful answers live in a database. Git, so your work has history and others can review it. And cloud basics: how to run a small app somewhere that is not your laptop.

You can say: "I can build a small service, test it, put it in Git and run it in the cloud."

Software engineers move through this town quickly; data engineers often need a little more on APIs and testing. Don't skip it either way.

Phase 2: building with models

What to learn: what a model call really is: messages go in, text comes out, and you pay for tokens (pieces of words) both ways. Prompting: clear instructions and examples. Structured output: asking for JSON in a fixed shape and checking it in code. Tool calling: the model asks your code to run a function, such as "look up this order", and your code decides whether to allow it. And the agent loop: the model picks a step, your code runs it, the result goes back, until the job is done or a step limit stops it.

You can say: "I can write an agent loop by hand, and a bad tool call is refused by code, not by hope."

Write the loop once in plain Python before you pick up a framework, so you know what the framework does for you.

Phase 3: context and knowledge

What to learn: the context is everything the model reads on one call. Retrieval means finding the right passages from your own documents. RAG, short for retrieval-augmented generation, means putting those passages into the context so the model answers from your facts instead of its memory. Context engineering is the wider skill of choosing what goes into that window and what stays out.

You can say: "My assistant answers from our documents, shows where each answer came from, and I can measure how often it finds the right passage."

Phase 4: making it reliable

What to learn: evals, which are a set of questions with known right answers that your system must pass before each release. Guardrails, which are small checks before and after the model and its tools that stop it doing something wrong. Tracing, which records every step of a run so you can replay a bad answer. And ordinary testing of the code around the model.

You can say: "A release is blocked when quality drops, and I can open one trace and explain a wrong answer."

This is the phase people most want to skip, and the one that makes you trustworthy. Anyone can build a demo; proving it works is the job.

Phase 5: running it

What to learn: cost, meaning what one question costs and the budget that stops a runaway loop. Shipping: prompts, models and tools versioned and deployed together. Security, especially prompt injection, where text inside a document or email tries to give the model orders. And human in the loop: deciding which actions wait for a person to approve, such as a refund above ₹40,000.

You can say: "Real people use it, I know what it costs per question, and risky actions wait for a person."

Phase 6: going deeper (optional)

What to learn: fine-tuning, which means training an existing model a little more on your own examples. Serving models yourself, which means hosting open models and making them fast and cheap. And building a tiny language model on your laptop, just to see how the insides work.

You can say: "I know when tuning beats prompting, and I can explain how a model predicts the next word."

This phase is for curiosity, or for moving toward shaping models rather than using them. Come here when phases 1 to 5 feel solid.

Start here, phase by phase

If you want one thing to read per phase, start with these.

PhaseStart here
1. FoundationsThe model is 10%, the harness is the other 90%
2. Building with modelsChoosing your agent loop
3. Context and knowledgeContext engineering
4. Making it reliableBefore it ships: offline evals
5. Running it9 cost mistakes
6. Going deeperPrompt, RAG or fine-tune? Pick in that order

What to skip for now

they look like the front door, but they are side rooms for laterTraining from scratcha lab's job;build with models firstNEW!Every new frameworklearn the job,not the nameCertificates alonea project with evalssays more
Three things to skip early. Each one is fine later; none of them is the place to start.
  1. Training models from scratch. Big models are trained by a few labs with enormous budgets. AI engineering is mostly building with models. A tiny model in phase 6 is a great lesson; a real one from scratch is a different job.
  2. Chasing every new framework. A new framework appears almost every week. Learn the jobs instead of the names. Our AI Universe sorts every name you will hear into seven families, so a new product becomes "another way of doing a job I already know".
  3. Certificates without projects. A certificate says you studied; a project with evals says you can build. If you only have time for one, build.

One project per phase

one small project closes each phase; finish it in a few weekends1Data servicerates API, SQL,tests, cloud2Expense helperreceipt to JSON,two tools, a loop3Handbook botanswers fromdocuments, cited4Prove itgolden questions,guardrails, traces5Go livereal users, cost,an approval step6Tiny modela laptop model ora small fine-tunethe same assistant, growing upoptional
One project per phase. Projects 3 to 5 are one assistant that you keep improving.

Reading gets you to the edge of each town; a project gets you through it. Keep each one to a few weekends.

  1. Foundations: a tiny data service. Pull daily exchange rates from a public API, store them in a SQL table, add tests, and run it in the cloud behind a small web endpoint.
  2. Building with models: an expense helper. Paste in a receipt, get back checked JSON (vendor, date, amount in ₹), and give the model two tools: "look up the policy limit" and "file the claim". Write the loop yourself, with a step limit.
  3. Context and knowledge: ask the handbook. An assistant over a set of policy documents that answers with citations. Keep twenty test questions and count how often it finds the right passage.
  4. Making it reliable: prove the handbook bot. Add thirty golden questions that run on every change, two or three guardrails, and a trace for every run.
  5. Running it: put it in front of people. Let a few friends or teammates use it. Show cost per question, set a budget, add one action that waits for approval, and try to break it with a planted instruction in a document.
  6. Going deeper: a tiny model. Train a very small model on a public-domain book on your laptop, or fine-tune a small open model and compare it with plain prompting on your phase 4 eval set.

Projects 3, 4 and 5 are the same assistant growing up, on purpose. One project you can explain end to end beats six demos you can't.

Mistakes that slow people down

Five questions to check your own progress

  1. Can you build, test and deploy a small service without following a tutorial step by step?
  2. Can you write an agent loop by hand, with a step limit, and explain each line?
  3. Does your assistant show where its answers come from, and do you know how often it finds the right passage?
  4. Would your current project block a release if quality dropped?
  5. Do you know what one question costs, and which actions wait for a person?

Each "yes" is a town behind you. For topics, projects and readiness checks at each level, see the AI Engineering path.

Pick the town you are in today, finish its one project, and drive on.