Course · Plus
AI engineer roadmap
A 6-month, 24-week path from zero to job-ready AI engineer for engineering students and developers in India: Python and Git, data and embeddings, machine learning, LLMs and prompting, RAG, agents and production, ending with a capstone project and interview preparation.
Open the courseChapters, a study plan and timed practice exams.Chapters
1. Python for AI engineers Weeks 1–2 · about 22 h
Write clean, working Python: data types, control flow, functions, collections, files, errors and classes, the subset you will use every day in AI work.
- Write Python scripts with variables, loops, conditions and functions without looking up the syntax.
- Pick the right built-in collection (list, tuple, dict, set) for a job and explain why.
- Read and write text, CSV and JSON files and handle errors with try and except.
- Model a small domain with a class or a dataclass and add type hints.
- Solve easy array and string problems in Python, the kind asked in online assessments.
2. Git, GitHub and engineering basics Weeks 3–4 · about 22 h
Work like a professional engineer: the terminal, Git and GitHub, virtual environments, tests with pytest, environment variables for secrets, and calling HTTP APIs with JSON.
- Use Git daily: commit, branch, merge, resolve a conflict and open a pull request.
- Keep secrets out of code with environment variables and a .gitignore.
- Create a virtual environment and pin dependencies in requirements.txt.
- Write small pytest tests and run them before every commit.
- Call a JSON HTTP API with requests, set a timeout and handle errors.
3. NumPy and pandas for real data Weeks 5–6 · about 22 h
Load, inspect, clean, reshape and summarise tabular data with NumPy and pandas, the daily tools for preparing data for models and evaluations.
- Explain shape, dtype, vectorisation and broadcasting in NumPy.
- Load a CSV into pandas and inspect it with head, info, describe and value_counts.
- Clean data: missing values, duplicates, wrong types, inconsistent text.
- Filter, group, aggregate and join tables with loc, groupby and merge.
- Prepare a clean dataset that a model or an evaluation script can use.
4. Text processing and embeddings Weeks 7–8 · about 22 h
Clean and tokenise text, turn it into numbers with TF-IDF and with embeddings, and find similar texts with cosine similarity, the foundation of semantic search and RAG.
- Clean and normalise real-world text, including Indian-language and mixed-script text.
- Explain tokens and why token counts drive the cost of LLM calls.
- Represent text with bag-of-words or TF-IDF and with dense embeddings, and compare them.
- Compute cosine similarity and return the top k most similar texts.
- Build a small semantic search over your own documents.
5. Machine learning with scikit-learn Weeks 9–10 · about 22 h
Frame a business problem as a machine learning task, prepare features, and train and compare core models with scikit-learn, starting from a baseline.
- Turn a vague request into a clear ML problem: target, features, type of task and success measure.
- Tell supervised from unsupervised learning, and classification from regression.
- Train, predict and compare linear models, trees, random forests, gradient boosting, k-nearest neighbours and k-means.
- Always start from a simple baseline and beat it with evidence.
- Decide when not to use ML at all.
6. Evaluation, overfitting and pipelines Weeks 11–12 · about 22 h
Measure models honestly with the right metrics and cross-validation, understand overfitting and the bias-variance trade-off, avoid leakage, and package everything in scikit-learn pipelines.
- Choose metrics that match the business cost of errors: precision, recall, F1, ROC AUC, MAE, RMSE.
- Read a confusion matrix and pick a decision threshold.
- Use cross-validation and explain why a single split can mislead.
- Diagnose overfitting and underfitting with the bias-variance trade-off.
- Build a leak-free Pipeline with ColumnTransformer and tune it with a grid search.
7. How LLMs work and prompt engineering Weeks 13–14 · about 22 h
Understand what a large language model does (next-token prediction, tokens, context, sampling, hallucination) and write prompts that are clear, structured, testable and reliable.
- Explain next-token prediction, tokens, the context window and temperature in plain words.
- Explain why models hallucinate and name practical ways to reduce it.
- Write prompts with a clear task, context, constraints, examples and an output format, using XML tags to separate parts.
- Use few-shot examples and prompt chaining for harder tasks.
- Compare prompt versions on a small test set instead of judging by one example.
8. LLM APIs, structured output, cost and responsible AI Weeks 15–16 · about 22 h
Call an LLM from code with the Claude Messages API, manage conversation history, get reliable JSON, handle errors and limits, estimate cost, and build responsibly.
- Call the Claude Messages API with a system prompt, messages and max_tokens, and read content, stop_reason and usage.
- Keep multi-turn conversations by sending the history, since the API is stateless.
- Get schema-valid JSON with structured outputs and validate it in code.
- Handle rate limits and errors with retries, timeouts and exponential backoff.
- Estimate monthly cost from token counts and apply responsible-AI basics: privacy, bias, transparency and human review.
9. RAG architecture, chunking and vector databases Weeks 17–18 · about 22 h
Design retrieval-augmented generation: load and chunk documents, embed and store them in a vector database, retrieve with hybrid search and reranking, and generate grounded answers with citations.
- Draw the RAG pipeline end to end and explain why each stage exists.
- Choose a chunking strategy (size, overlap, structure) for a document type.
- Compare vector stores (pgvector, Chroma, FAISS, Qdrant, Pinecone and others) and approximate search indexes such as HNSW.
- Improve retrieval with metadata filters, hybrid search and reranking.
- Write a generation prompt that cites sources and refuses when the context lacks the answer.
10. Building and evaluating RAG, and RAG frameworks Weeks 19–20 · about 22 h
Measure a RAG system with retrieval and answer-quality metrics, improve it with evidence, and understand where frameworks such as LangChain, LlamaIndex and Semantic Kernel help or get in the way.
- Build a labelled evaluation set for a RAG system.
- Measure retrieval with hit rate, recall@k and MRR, and answers with faithfulness and relevance.
- Use an LLM as a grader with a clear rubric, and check it against human labels.
- Run a disciplined improvement loop: change one thing, re-run the eval, keep or revert.
- Explain what LangChain, LlamaIndex and Semantic Kernel provide and when to use plain code instead.
11. Agents, tool calling and MCP Weeks 21–22 · about 22 h
Give models tools: define tools with JSON Schema, run the agent loop safely, choose between workflows and agents, connect tools through the Model Context Protocol, and evaluate agent behaviour.
- Define tools with clear names, descriptions and input schemas.
- Implement the tool-use loop with stop conditions, step limits and error results.
- Decide when a fixed workflow is better than an autonomous agent.
- Explain MCP: hosts, clients, servers, and the tools, resources and prompts that servers expose.
- Evaluate an agent on task success, tool-call correctness, steps, cost and safety.
12. Production, capstone and getting hired Weeks 23–24 · about 25 h
Ship AI features like a professional: optimise latency and cost, log and monitor, version prompts, deploy safely, defend against prompt injection, then finish a capstone, a portfolio and interview preparation.
- Reduce latency and cost with model choice, streaming, output limits, caching and batching.
- Log every LLM call with prompt version, model, tokens, latency and cost, and monitor quality over time.
- Version prompts in Git and run evals in CI before every change.
- Deploy an LLM service with secrets management, timeouts, retries, rate limits and security controls.
- Present a capstone project and answer AI engineer interview questions with confidence.