The AI Engineering Program

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

Project. No portfolio project: this module sets up the toolkit every later project uses.

1. AI vs ML vs DL vs GenAI
2. AI problem framing
3. Git/GitHub basics
4. Python environment setup
5. HTTP, APIs and JSON

Open the Module 1 page

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

Project. Sales-analytics command-line tool. A real CLI with argparse, tests and exit codes.

1. Variables and data types
2. Operators and expressions
3. if/elif/else
4. for/while loops
5. Lists, tuples, sets, dictionaries
6. Functions and scope
7. Modules and packages
8. Exceptions and error handling
9. Classes and OOP
10. Iterators and generators
11. Virtual environments
12. NumPy arrays
13. Pandas dataframes
14. Matplotlib visualization
15. Python mini-capstone

Open the Module 2 page

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

Project. Math-to-ML notebook. A model trained by hand in NumPy, every step explained.

1. Vectors
2. Linear combinations
3. Matrix multiplication
4. Eigenvalues/eigenvectors
5. Derivatives
6. Partial derivatives
7. Chain rule
8. Gradient descent
9. Probability fundamentals
10. Conditional probability/Bayes
11. Expectation and variance
12. Correlation vs causation
13. Sampling and confidence intervals
14. Hypothesis testing
15. Math-to-ML checkpoint

Open the Module 3 page

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

Project. 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.

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

Open the Module 4 page

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

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

1. PyTorch tensors and autograd
2. The training loop: batches, loss, optimiser, GPU in Colab
3. Multilayer networks, overfitting and regularisation
4. Convolutional networks and transfer learning
5. Tokenisation and embeddings
6. Attention, built by hand
7. The transformer block
8. Build and train a mini-GPT on Indian-language text
9. Pretrained models from the Hugging Face Hub: pipelines and sentence embeddings
10. Module project

Open the Module 5 page

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

Project. 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.

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

Open the Module 6 page

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

Project. 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.

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

Open the Module 7 page

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

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

1. Why RAG, and when not to use it
2. Parsing real documents: PDFs, tables and scanned pages
3. Chunking strategies and their trade-offs
4. Embeddings and vector databases (Chroma, Qdrant, pgvector)
5. Hybrid search: keywords plus vectors
6. Reranking
7. Query rewriting and routing
8. Grounded answers with citations
9. Multilingual RAG for Indian languages
10. Text-to-SQL: answering questions from databases
11. Graph-based retrieval: an introduction
12. Measuring retrieval: recall@k and MRR
13. Module project

Open the Module 8 page

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

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

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

Open the Module 9 page

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

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

1. Workflows vs agents: choosing the simplest thing that works
2. The tool-use loop, built without a framework
3. Planning, reflection and routing patterns
4. LangGraph: state, nodes and checkpoints
5. Agent memory: short-term and long-term
6. Building an MCP server
7. MCP clients: connecting agents to spreadsheets, GitHub and databases
8. Multi-agent orchestration
9. Human-in-the-loop approvals
10. Evaluating agents and controlling their cost
11. Voice agents, including Indian languages
12. Browser and computer-use agents: capabilities and safety
13. Module project

Open the Module 10 page

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

Project. 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.

1. Fine-tune, RAG or prompt? A decision framework
2. Dataset engineering and synthetic data
3. LoRA and QLoRA on a free Colab GPU
4. Instruction tuning for structured extraction
5. Preference tuning (DPO): an introduction
6. Evaluating a fine-tune against the prompt baseline
7. Quantisation and running models locally
8. Serving: throughput, latency and cost
9. Publishing a model with a model card on the Hugging Face Hub
10. Module project

Open the Module 11 page

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

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

1. Docker for AI apps
2. CI/CD with GitHub Actions, with eval gates
3. Deploying on free tiers
4. Cloud essentials: storage, serverless and managed model APIs on AWS
5. Secrets, authentication and rate limiting
6. Monitoring, logging and alerts
7. Cost engineering: caching, model routing and batching
8. Drift, feedback loops and retraining
9. Incidents and rollbacks
10. Module project

Open the Module 12 page

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

Project. 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.

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

Open the Module 13 page