The AI engineer roadmap for 2026

The exact roadmap our program follows.

The principles behind it

• Built from job descriptions, not from textbook tables of contents: ~70% of AI-engineer roles are LLM-first and 95.6% are production work (889 JDs, Jan 2026).
• Every module ships something public: a live URL or Hugging Face Space, a README, and (from Module 9 on) an evaluation report.
• Every lab runs at zero cost to the learner: Colab plus free LLM API tiers (Groq, Google AI Studio, Mistral, GitHub Models) and local open models.
• Built for India: Indian datasets and documents (GST invoices, public policy PDFs, UPI-style transactions), Indian languages (IndicTrans2), and the DPDP Act 2023 for personal data.
• Tool-neutral where tools churn, specific where employers are specific (Python, SQL, FastAPI, Docker, GitHub Actions, LangGraph, MCP, PyTorch, Hugging Face).

Module 1: AI & Computing Foundations

Git, APIs, environments and the vocabulary of AI: the tools everything else uses.

You'll build: No portfolio project: this module sets up the toolkit every later project uses.

• AI vs ML vs DL vs GenAI
• AI problem framing
• Git/GitHub basics
• Python environment setup
• HTTP, APIs and JSON

Module 2: Python for AI

Python to a professional standard, ending in a working command-line capstone.

You'll build: Sales-analytics command-line tool. A real CLI with argparse, tests and exit codes.

• Variables and data types
• Operators and expressions
• if/elif/else
• for/while loops
• Lists, tuples, sets, dictionaries
• Functions and scope
• Modules and packages
• Exceptions and error handling
• Classes and OOP
• Iterators and generators
• Virtual environments
• NumPy arrays
• Pandas dataframes
• Matplotlib visualization
• Python mini-capstone

Module 3: Mathematics & Statistics for AI

The vectors, derivatives and probability that make machine learning make sense.

You'll build: Math-to-ML notebook. A model trained by hand in NumPy, every step explained.

• Vectors
• Linear combinations
• Matrix multiplication
• Eigenvalues/eigenvectors
• Derivatives
• Partial derivatives
• Chain rule
• Gradient descent
• Probability fundamentals
• Conditional probability/Bayes
• Expectation and variance
• Correlation vs causation
• Sampling and confidence intervals
• Hypothesis testing
• Math-to-ML checkpoint

Module 4: Data, SQL & Machine Learning in Practice

Query real business data with SQL, build and honestly evaluate classical ML models, and explain every metric to a manager.

You'll build: Credit-risk or churn model on an Indian-style dataset: SQL feature pipeline, three models compared, cost-based threshold, model card. Published as a Hugging Face Space.

• SQL for analysis: SELECT, filters, joins on a real sales database
• Aggregations, window functions and CTEs
• SQL from Python, and loading query results into pandas
• The scikit-learn workflow: splits, pipelines, and leakage-proof preprocessing
• Linear and logistic regression in practice
• Decision trees, random forests and gradient boosting
• Metrics that match the business: precision, recall, ROC-AUC, cost-based thresholds
• Cross-validation and hyperparameter tuning
• Feature engineering for tabular data and text (TF-IDF)
• Clustering and customer segmentation
• Model cards: reporting what a model can and cannot do

Module 5: Deep Learning & Transformers from Scratch

Train neural networks in PyTorch and build a working mini-GPT, so LLMs stop being a black box.

You'll build: A from-scratch mini-GPT trained in Colab plus a sentence-embedding semantic search demo, with a write-up of what each component does.

• PyTorch tensors and autograd
• The training loop: batches, loss, optimiser, GPU in Colab
• Multilayer networks, overfitting and regularisation
• Convolutional networks and transfer learning
• Tokenisation and embeddings
• Attention, built by hand
• The transformer block
• Build and train a mini-GPT on Indian-language text
• Pretrained models from the Hugging Face Hub: pipelines and sentence embeddings

Module 6: LLM Application Engineering

Build and ship an LLM-powered service that returns reliable, structured results, with cost and latency under control.

You'll build: Invoice-to-data service: upload GST invoices (image or PDF), get validated JSON, with a FastAPI backend, a simple UI, cost per document measured, deployed on a free tier.

• How LLMs are served: tokens, context windows, sampling, cost and latency maths
• One client for many models: free-tier APIs and local models
• Prompts that hold up: instructions, examples, delimiters and prompt versioning
• Structured outputs: JSON schemas, Pydantic validation and retries
• Function calling and tool use
• Context engineering: deciding what goes into the window
• Multimodal inputs: images, PDFs and speech
• Streaming, caching, rate limits and fallbacks
• Serving an AI feature with FastAPI
• Front ends for AI apps: Streamlit, then a first look at TypeScript and Next.js
• Privacy and responsible AI, including India's DPDP Act 2023

Module 7: AI-Native Engineering with Coding Agents

Use coding agents to build faster without shipping bugs: write specs, tests and reviews that keep AI-written code correct.

You'll build: Ship a real feature or fix to an open-source repository as a reviewed pull request, built with a coding agent and covered by tests.

• How coding agents work: context, tools and failure modes
• Writing specs an agent can execute
• Tests first: pytest, fixtures and test-driven prompting
• Git and pull requests with agents: branches, reviews, small diffs
• Agent workflows that transfer across tools (terminal agents, IDE agents, chat)
• Verifying AI-written code: security, licences and hidden assumptions
• System design for AI apps: queues, caching, cost and latency
• Debugging with an agent, without letting it guess

Module 8: RAG Engineering

Build retrieval systems that answer from company documents with citations, in English and Indian languages, and prove how often they retrieve the right source.

You'll build: Bilingual policy assistant: answers questions about public Indian government documents in English and Hindi with citations, plus a retrieval-quality report.

• Why RAG, and when not to use it
• Parsing real documents: PDFs, tables and scanned pages
• Chunking strategies and their trade-offs
• Embeddings and vector databases (Chroma, Qdrant, pgvector)
• Hybrid search: keywords plus vectors
• Reranking
• Query rewriting and routing
• Grounded answers with citations
• Multilingual RAG for Indian languages
• Text-to-SQL: answering questions from databases
• Graph-based retrieval: an introduction
• Measuring retrieval: recall@k and MRR

Module 9: Evals, Guardrails & AI Security

Measure whether an AI system is actually good, catch regressions before users do, and defend it against prompt injection and data leaks.

You'll build: A published evaluation suite and red-team report for the Module 8 assistant, wired into CI so a regression fails the build.

• Why AI apps fail silently
• Error analysis on real traces
• Golden datasets and synthetic test data
• Code-based checks and assertions
• LLM-as-judge, calibrated against human labels
• Evals in CI: blocking a bad prompt change
• Tracing and observability with open-source tools
• OWASP Top 10 for LLM apps: prompt injection, data leakage, excessive agency
• Guardrails and personal-data redaction
• Red-teaming your own app

Module 10: Agents & MCP

Build agents that use tools, remember context, ask a human before risky steps, and plug into real software through MCP.

You'll build: Finance-operations agent: reconciles invoices against a ledger through MCP tools, asks for approval before any write, and logs every step.

• Workflows vs agents: choosing the simplest thing that works
• The tool-use loop, built without a framework
• Planning, reflection and routing patterns
• LangGraph: state, nodes and checkpoints
• Agent memory: short-term and long-term
• Building an MCP server
• MCP clients: connecting agents to spreadsheets, GitHub and databases
• Multi-agent orchestration
• Human-in-the-loop approvals
• Evaluating agents and controlling their cost
• Voice agents, including Indian languages
• Browser and computer-use agents: capabilities and safety

Module 11: Fine-Tuning, Open Models & Inference

Decide when fine-tuning beats prompting, fine-tune a small open model on free GPUs, and serve it efficiently.

You'll build: Fine-tune a small open model to extract fields from Indian documents, beat the prompt-only baseline on a held-out eval set, and publish it on the Hugging Face Hub.

• Fine-tune, RAG or prompt? A decision framework
• Dataset engineering and synthetic data
• LoRA and QLoRA on a free Colab GPU
• Instruction tuning for structured extraction
• Preference tuning (DPO): an introduction
• Evaluating a fine-tune against the prompt baseline
• Quantisation and running models locally
• Serving: throughput, latency and cost
• Publishing a model with a model card on the Hugging Face Hub

Module 12: Production AI & LLMOps

Package, deploy, monitor and pay for AI systems like a production team does.

You'll build: Productionise the Module 10 agent: containerised, CI/CD with eval gates, deployed, with a monitoring dashboard and a written runbook.

• Docker for AI apps
• CI/CD with GitHub Actions, with eval gates
• Deploying on free tiers
• Cloud essentials: storage, serverless and managed model APIs on AWS
• Secrets, authentication and rate limiting
• Monitoring, logging and alerts
• Cost engineering: caching, model routing and batching
• Drift, feedback loops and retraining
• Incidents and rollbacks

Module 13: Capstone & Career Launch

Deliver an AI project for a real problem end to end, and walk into interviews with proof: portfolio, JD-matched resume and practised answers.

You'll build: Client-style capstone for a small business, NGO or open dataset of the learner's choice: spec, build, evals, deployment, demo video and case study.

• Discovery: turning a business problem into an AI spec
• Scoping, estimates and success metrics
• Build sprint 1
• Build sprint 2 with evals
• Deploy and record a demo
• Portfolio: GitHub profile, READMEs and a case study
• Resume and LinkedIn matched to real job descriptions
• Interview preparation: fundamentals, LLM system design and take-home tasks
• Mock interviews
• Industry readiness assessment and certificate