Sign in Explore the program

The AI engineer roadmap for 2026

A complete, ordered roadmap from first Python script to production AI systems, with what to learn and what to build at each stage.

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
  • IRI Industry Readiness assessment and certificate