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.

12 chapters84 practice questions24 week plan
Open the courseChapters, a study plan and timed practice exams.

Chapters

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