TL;DR: An AI engineer is the person who turns a language model into a product feature that survives production: picking the model, prompting or fine-tuning it, wiring retrieval and tools around it, serving it on GPUs, and measuring whether it works. The roadmap below has seven stages, each ending in something you have built. Stages 1 to 4 (how models work, calling them through an API, serving them, and retrieval) make you employable. Stages 5 to 7 (fine-tuning, evaluation and MLOps, agents) make you senior. The whole path is roughly 40 to 60 focused hours if you already write Python, and three NVIDIA certifications slot in as checkpoints along the way.
Imagine two engineers who both "learned AI" this year. One finished a survey course, can explain what attention is, and has a folder of notebook screenshots. The other built a transformer by hand, shipped a retrieval pipeline with reranking, served a fine-tuned model behind an API on a real GPU, and can show you the latency numbers. Both put "AI engineer" on their resume. Only one of them gets past the technical interview, and it is the one whose learning left artifacts behind.
That difference is the whole design principle of this roadmap. Every stage ends in a thing you built, because the job itself is building. The stages are ordered so each one uses what the previous one produced, and the order matches how the AI Engineer path on Preporato is laid out, so you can follow it there with graded work or on your own with the same sequence.
Start here
If you are deciding whether this role is for you, read how to become an AI engineer first. If you are choosing between this and the adjacent role, read AI engineer vs ML engineer. The roadmap below assumes you have decided and want the sequence.
What the role actually is
An AI engineer ships LLM-powered features to production. The daily work is choosing a model, deciding whether prompting is enough or fine-tuning is needed, building the retrieval and tool-use loops around the model, running it on GPUs that stay within a latency and cost budget, and evaluating the result so the team knows when it regresses. The model itself is usually somebody else's; the system around it is yours.
That framing matters because it tells you what to skip. You do not need to train foundation models, derive backpropagation on a whiteboard, or master classical statistics before you start. You need to understand models well enough to predict their behavior, and you need to be very good at the engineering around them.
Stage 0: prerequisites you should already have
You need three things before stage 1 makes sense. Comfortable Python, meaning functions, classes, virtual environments, and reading other people's code without fear. A working familiarity with one ML framework, PyTorch ideally, enough to define a small model and run a training loop. And basic ML literacy: what training and evaluation are, what gradient descent does, what overfitting looks like.
If you are missing the third item, spend a week on it and no more. The roadmap teaches the model-specific concepts as you go, and the fastest way to learn the general ones is to meet them inside a concrete build.
Stage 1: how language models actually work
Why first: everything downstream (why a prompt fails, why a context window fills, why a model hallucinates, why quantization costs accuracy) becomes predictable once you have seen the machinery. Engineers who skip this stage spend years treating the model as a slot machine.
What to learn: tokenization and its edge cases, embeddings, self-attention and multi-head attention, the decoder-only transformer, positional encoding, the training loop, and sampling (temperature, top-p, why greedy decoding loops).
What to build: a decoder-only transformer from scratch in PyTorch, trained on a small corpus until it generates coherent text from your own weights. This is the single highest-leverage project on the list. It takes a weekend, and it permanently changes how you read a model card.
Stage 2: using models through an API
Why now: most production AI features are API calls with careful engineering around them. This stage teaches the engineering.
What to learn: prompt structure (system, user, and assistant roles), few-shot examples, structured output (constraining the model to return JSON your code can parse), tool calling, counting tokens before you send them, prompt caching (reusing a stored prefix so repeated tokens are billed at a discount), and prompt injection (untrusted text in the input being followed as instructions).
What to build: a working feature against a hosted model with a cost ceiling, a retry and timeout policy, structured output validation, and an injection test. Keep the cost dashboard; you will be asked about it in interviews.
Stage 3: inference and serving
Why now: loading a model is easy, and serving it without going broke is the job. Stage 3 is where AI engineering separates from AI hobbyism.
What to learn: the precision, throughput, and memory tradeoffs; quantization (storing weights in fewer bits, such as INT8 or 4-bit NF4, to fit a model in less GPU memory); batching; KV-cache behavior; and the serving stack, vLLM in particular, with PagedAttention, continuous batching, and prefix caching.
What to build: quantize a model and measure the accuracy cost; sweep batch size and precision and plot throughput against latency; stand up vLLM and record real numbers for tokens per second and time to first token.
Build stages 1 and 3 on a real GPU
Implement attention, residuals, and LayerNorm by hand and train the result on TinyStories, then stand up vLLM with PagedAttention and continuous batching and measure the throughput yourself.
Stage 4: retrieval-augmented generation
Why now: RAG (retrieval-augmented generation, feeding the model relevant documents at query time instead of retraining it) is the most-shipped LLM pattern in production, and it is where most AI engineer job descriptions live.
What to learn: embeddings and vector search, chunking strategy, hybrid retrieval (dense embeddings plus BM25 keyword search, fused with reciprocal rank fusion), cross-encoder reranking, grounded generation with citations, and retrieval evaluation (did the right chunk come back, and did the answer use it).
What to build: a pipeline with hybrid search and a reranker over a real corpus, with a small evaluation set that scores retrieval and answer quality separately. This is the architecture behind most enterprise assistants, and having built it is the difference between describing RAG and being trusted with it.
Stage 4 is also the first certification checkpoint. By the end of it you have covered the architecture, prompting, and retrieval depth that the NVIDIA Certified Associate: Generative AI LLMs exam tests.
Stage 5: fine-tuning and alignment
Why now: fine-tuning is how a generic model becomes useful for a domain, and it is the stage most self-taught engineers never reach, which is exactly why it pays.
What to learn: parameter-efficient fine-tuning with LoRA and QLoRA (training small adapter matrices instead of the full model, so it fits on one GPU), the merge-versus-keep-adapter decision, continued pretraining on a domain corpus, preference alignment with DPO (direct preference optimization, training on pairs of preferred and rejected answers), and synthetic data generation for when you have no labeled set.
What to build: a LoRA fine-tune of an 8B model on your own instruction dataset, evaluated against the base model on a held-out set, with the adapter weights saved and the evaluation numbers written down.
Stage 6: evaluation and MLOps
Why now: a model you cannot measure is one you cannot trust, and a training run you cannot reproduce is one you cannot ship. Stage 6 is what makes stages 4 and 5 defensible.
What to learn: perplexity, BLEU and ROUGE and their limits, LLM-as-judge with position-bias detection (the judge model preferring whichever answer appears first), experiment tracking with MLflow, model registries and stage transitions, packaging a model as a versioned GPU container, and shipping it through CI with rollback.
What to build: an MLflow-tracked training pipeline where every run logs parameters, metrics, and artifacts, with a registered model and a hyperparameter sweep, and a CI job that builds and tests the serving container. If you want the deeper treatment, the MLOps course guide covers what a good curriculum contains.
Stage 7: agents and tool use
Why last: an agent is a model in a loop with tools, and every failure mode from the earlier stages shows up here amplified. You need the previous six stages to debug one.
What to learn: the ReAct loop (reason, act, observe), tool calling with schemas, the Model Context Protocol (MCP, a standard for exposing tools to models), orchestration patterns (ReAct versus plan-and-execute versus multi-agent supervisor routing), persistent memory, guardrails against jailbreaks and injection, and agent evaluation with traces.
What to build: a ReAct agent with a tool-call budget, an MCP server exposing your own tools, a supervisor routing between two specialist agents, memory in a vector store, and an evaluation harness that scores the agent's runs. This stage covers the surface of the NVIDIA Certified Professional: Agentic AI exam, which is the natural final checkpoint.
The roadmap at a glance
| Stage | Build this | Proves you can |
|---|---|---|
| 1. How LLMs work | A decoder-only transformer from scratch | Predict model behavior instead of guessing |
| 2. Models via API | A feature with cost ceiling, structured output, injection test | Ship a safe, budgeted LLM feature |
| 3. Inference and serving | Quantized model served on vLLM with measured throughput | Run models within a latency and cost budget |
| 4. RAG | Hybrid search plus reranker over a real corpus, with eval | Own the most-shipped LLM pattern |
| 5. Fine-tuning | LoRA fine-tune of an 8B model, evaluated against base | Move a model to a domain on one GPU |
| 6. Evaluation and MLOps | MLflow-tracked pipeline, registry, CI-built container | Make results reproducible and shippable |
| 7. Agents | ReAct agent, MCP server, supervisor routing, eval harness | Build production agents that can be measured |
Where certifications fit
Certifications do not replace the artifacts, and they are useful as checkpoints because they force breadth. Three NVIDIA exams line up with the roadmap, and the AI Engineer path places them as milestones after the matching module. As of September 2026, on NVIDIA's pages:
- NCA-GENL (NVIDIA Certified Associate: Generative AI LLMs), after stage 4. Fifty to sixty questions in one hour, remotely proctored, $125, valid two years. Practice tests and a 500-card deck are on the NCA-GENL page.
- NCP-GENL (NVIDIA Certified Professional: Generative AI LLMs), after stage 6. Sixty to seventy questions in 120 minutes, $200, valid two years, weighted toward model optimization, fine-tuning, and GPU acceleration. See the NCP-GENL page.
- NCP-AAI (NVIDIA Certified Professional: Agentic AI), after stage 7. Sixty to seventy questions in 120 minutes, $200, valid two years. See the NCP-AAI page.
For the wider landscape, including the cloud vendors' exams and what changed in 2026, read AI engineer certifications.
The roadmap for engineers in India
"AI engineer roadmap" is searched far more often from India than from anywhere else, so it is worth being specific about how the path plays out there.
The hiring pattern. Indian product companies and the India offices of global firms hire AI engineers on the same stages 1 to 4 skills as US teams, with a heavier emphasis on RAG and deployment because most roles are building assistants over enterprise documents. IT services companies hire for GenAI delivery and value stages 2, 4, and 6 (API engineering, retrieval, and MLOps) above research depth. Startups in Bengaluru, Hyderabad, and Pune tend to ask for stage 7 (agents) earlier than their US counterparts, because agent products are where they compete.
The pay bands. As of mid-2026, Glassdoor India lists the average AI engineer salary at about ₹10,00,000 a year, with the typical band from ₹6,45,000 to ₹17,87,000 and the 90th percentile around ₹34,40,000. Senior AI engineers average about ₹19,00,000, and generative AI engineers show a wider top end, with the 90th percentile near ₹40,55,000. The spread between the median and the top is the roadmap: the top of the band is stages 5 to 7.
What moves you up the band. Three things, in order: shipped artifacts (a RAG system with evaluation numbers beats any certificate), deployment skill (the ability to serve a model on a GPU within a budget is scarce everywhere and especially in India, where teams often outsource it), and agents. Degrees matter less than in traditional software hiring because the field is too new for pedigree to have formed.
Remote work. US and European companies hire Indian AI engineers remotely at rates well above the local band, and they screen almost entirely on the artifacts. That is one more reason to build every stage rather than certificate your way through.
For the US and global picture, AI engineer skills and salary breaks the numbers down by source and level.
How long it takes
The honest number for someone who already writes Python and has basic ML literacy is 40 to 60 focused hours across the seven stages, which is the estimate the Preporato path carries. Spread over evenings and weekends, that is roughly twelve weeks. Compressed into a sabbatical, it is three to four weeks.
How models work and API engineering
Weeks 1-3- •Build and train the transformer from scratch
- •Ship one API feature with a cost ceiling and structured output
- •Write an injection test and keep the cost dashboard
Serving and retrieval
Weeks 4-6- •Quantize a model and measure the accuracy cost
- •Stand up vLLM and record throughput and time to first token
- •Build hybrid retrieval with reranking and a small eval set
- •Checkpoint: NCA-GENL
Fine-tuning, evaluation, MLOps
Weeks 7-9- •LoRA fine-tune an 8B model and compare against base
- •Track every run in MLflow and register the model
- •Ship the serving container through CI with rollback
- •Checkpoint: NCP-GENL
Agents and capstone
Weeks 10-12- •Build a ReAct agent with a tool budget and an MCP server
- •Add supervisor routing, memory, and guardrails
- •Score the agent with an LLM-as-judge harness
- •Capstone: the RAG agent on Kubernetes
- •Checkpoint: NCP-AAI
The stages are sequential for a reason, and the one shortcut that works is skipping stage 5 on the first pass if your target role is RAG-heavy, then coming back to it. Skipping stage 1 does not work; every engineer who tries it ends up relearning it later under deadline pressure.
Frequently asked questions
Key takeaways
0/6 completedNext steps
Start with stage 1 this weekend. If you want the stages with graded work, the AI Engineer path runs the same sequence as 115 lessons, 49 coding challenges, 26 GPU labs, and 6 graded projects, with the three NVIDIA checkpoints placed after the matching modules; the curriculum is open to browse, and the lessons, labs, and projects are included with Preporato Pro. Then read how to become an AI engineer for the hiring side of the same path.
Sources:
- NVIDIA Certified Associate: Generative AI LLMs
- NVIDIA Certified Professional: Generative AI LLMs
- NVIDIA Certified Professional: Agentic AI
- Glassdoor India: AI Engineer salaries