Generative AI Syllabus

Quick answer

A good generative AI syllabus in 2026 runs from Python and machine learning basics, through transformers and large language models, to prompt engineering, embeddings and vector databases, RAG, fine-tuning, image generation, AI agents, deployment and evaluation, and ends with a capstone project. Plan for about 3 months of full-time study or 5 to 6 months part-time. The order matters: each module builds on the one before it. The modules that job descriptions ask for most often are Python, RAG, LLM APIs and frameworks such as LangChain, so give those the most time.

• Foundations (weeks 1 to 5): Python, data handling, machine learning and deep learning basics
• Core GenAI (weeks 6 to 12): NLP, transformers, LLMs, prompt engineering, embeddings, vector databases, RAG
• Advanced (weeks 13 to 19): fine-tuning with LoRA, diffusion and multimodal models, agents, LLMOps, evaluation and responsible AI
• Capstone (weeks 20 to 22): one end-to-end project you can show in interviews
• Prerequisites: basic Python helps; school-level maths is enough to start

Key takeaways

1. Learn in order: Python, then ML and deep learning, then transformers and LLMs, then RAG, then agents and deployment. Skipping foundations makes later modules confusing.
2. RAG is the single most important applied skill. It appeared in 11 of the 12 Indian GenAI job descriptions we read on 24 October 2026.
3. A 2026 syllabus must include agents, tool use, evaluation and guardrails. Many older syllabi stop at prompting or RAG.
4. Every module should end with a small lab you build yourself. Theory without labs does not get you shortlisted.
5. Non-coders can follow a shorter beginner track focused on tools, prompting and no-code workflows, then add Python later.

1. Generative AI syllabus at a glance

Short answer: The syllabus has 11 modules plus a capstone, spread over about 22 weeks at 8 to 10 hours a week; a full-time learner or a structured course can compress it to around 3 months.

The weeks below are our suggested pace for a working professional or a final-year student studying part-time. They are a planning guide, not a rule. If you already know Python and machine learning, you can start at module 3 and finish in about 14 weeks.

Here is the learning flow as a simple diagram you can copy into your notes:

1. Code: Python and data handling
2. Learn from data: machine learning and neural networks
3. Understand language: NLP, attention and transformers
4. Use the models: LLM APIs and prompt engineering
5. Ground the models: embeddings, vector databases and RAG
6. Adapt the models: fine-tuning with LoRA
7. Go beyond text: diffusion and multimodal models
8. Let models act: agents and tool use
9. Ship it: deployment, monitoring and evaluation
10. Prove it: capstone project and portfolio

If you are brand new and want a gentler, hands-on start before this full syllabus, read our generative AI for beginners guide first.

2. Prerequisites: what you need before module 1

Short answer: You need a laptop, curiosity and school-level maths; Python is helpful but you can learn it in the first two weeks, and you do not need a computer science degree.

Many learners ask whether they must master maths first. You do not. Using and building with LLMs depends far more on Python, data handling and clear thinking than on calculus. You will meet some maths in module 2, and you can learn it as you go.

In India, this syllabus suits final-year students and freshers, developers and testers in IT services firms and GCCs in Hyderabad, Bengaluru, Pune and Chennai, and data analysts who already know Python or SQL. Marketers and non-IT professionals usually need only the beginner track in section 15.

3. Module 1: Python and data basics

Short answer: Module 1 teaches the Python you actually need for GenAI work: core syntax, data handling with Pandas, calling web APIs, reading JSON and using Git.

Every GenAI job description we read on 24 October 2026 asked for Python. Treat this module seriously even if you have written some code before.

Topics:

• Python syntax, functions, classes, error handling and virtual environments
• Working with files, text, CSV and JSON
• NumPy arrays and Pandas DataFrames for cleaning and exploring data
• Calling REST APIs with HTTP requests and handling API keys safely (environment variables, never in code)
• Git and GitHub basics: commits, branches, README files
• Jupyter notebooks and a code editor

Tools: Python, Jupyter, VS Code or a similar editor, NumPy, Pandas, Git, GitHub.

Mini lab: Download a public CSV dataset (for example, monthly rainfall by Indian state). Clean it with Pandas, answer five questions about it, and push the notebook to GitHub with a short README.

Outcome: You can write clean scripts, handle text and data, call an API and share your work on GitHub.

4. Module 2: ML and deep learning foundations

Short answer: Module 2 gives you the machine learning and neural network basics that make transformers and LLMs understandable, without going deep into research maths.

You will not train a giant model as an application builder, but you will fine-tune and evaluate models later, so you need these ideas.

Topics:

• What AI, machine learning (ML), deep learning (DL) and generative AI are, and how they differ (our post on generative AI vs traditional AI explains the difference)
• Supervised vs unsupervised learning; training, validation and test sets
• Regression and classification with scikit-learn; accuracy, precision, recall
• Neural networks: neurons, layers, activation functions, loss, gradient descent, backpropagation (concept level)
• CNNs for images and RNNs/LSTMs for sequences, and why they struggle with long text
• PyTorch or TensorFlow basics: tensors, a training loop, saving a model

Tools: scikit-learn, PyTorch or TensorFlow, Google Colab or another notebook service.

Mini lab: Train a simple text classifier that labels customer reviews as positive or negative, first with scikit-learn and then with a small neural network. Compare the results.

Outcome: You understand how models learn from data and can train and evaluate a small model.

5. Module 3: NLP and transformers

Short answer: Module 3 explains how computers represent language and how the transformer architecture, built on attention, became the base of every modern LLM.

The transformer was introduced in the paper "Attention Is All You Need" (Vaswani et al., Google, June 2017), which replaced recurrence with attention (arXiv, checked October 2026). Almost everything else in this syllabus builds on that idea.

Key terms explained:

• Token: a small chunk of text (a word, part of a word or a character) that a model reads and writes; a tokeniser splits text into tokens
• Embedding: a list of numbers (a vector) that represents meaning, so similar words or sentences have nearby vectors
• Attention: a mechanism that lets the model weigh which other tokens matter for each token
• Transformer: a neural network built from attention layers; encoders read text, decoders generate text

Topics:

• Classic NLP: bag of words, TF-IDF, n-grams
• Word embeddings: Word2Vec, GloVe, FastText
• Self-attention, multi-head attention, positional encoding
• Encoder models (BERT, RoBERTa) vs decoder models (the GPT family)
• Hugging Face Transformers: loading a pretrained model and tokeniser

Tools: Hugging Face Transformers, Hugging Face Hub, PyTorch.

Mini lab: Load a pretrained BERT-style model from Hugging Face, tokenise five sentences, look at the tokens, and run a ready-made sentiment or summarisation pipeline.

Outcome: You can explain how a transformer processes text and use pretrained models from Hugging Face.

6. Module 4: LLMs and prompt engineering

Short answer: Module 4 covers what large language models are, how they are trained and aligned, how to call them through APIs, and how to write prompts that give reliable results.

A large language model (LLM) is a foundation model trained on huge amounts of text to predict the next token. A foundation model is a model trained on broad data that can be adapted to many tasks. As of October 2026, the vendor model pages list lineups such as OpenAI's GPT-6 family, Google's Gemini 4, Anthropic's Claude Opus 5.5, Sonnet 5.5 and Haiku 5.5, Meta's Muse family, Mistral Large 4 and DeepSeek V4.x. Names change fast, so learn the concepts, not one model.

Topics:

• The LLM lifecycle: pre-training, instruction tuning, and RLHF (reinforcement learning from human feedback, where human preference ratings guide the model)
• Context window: how much text, in tokens, a model can consider at once
• Calling LLM APIs: system messages, user messages, parameters, streaming, cost per token
• Prompting techniques: zero-shot (no examples), few-shot (a few examples in the prompt), role prompts, chain-of-thought, prompt decomposition, structured output (JSON)
• Temperature and top_p: Microsoft's prompt engineering guide says temperature can be set between 0 and 2, with lower values giving more focused output, and advises changing temperature or top_p, not both (Microsoft Learn, October 2026)
• Hallucination: when a model states false information confidently
• Open-weight vs closed models; running small models locally with Ollama

Tools: an LLM API (OpenAI, Google Gemini, Anthropic Claude or an open model) and Ollama.

Here is a simplified example of a structured prompt you will practise in this module:

System: You are a support assistant for an Indian broadband company.
Answer only from the policy text below. If the answer is not there, say "I don't know".

Policy text: {policy}

User question: {question}

Return JSON: {"answer": "...", "policy_line_used": "..."}

Mini lab: Build a small script that sends the same 10 customer questions to an LLM with three prompt versions (plain, few-shot, structured JSON). Record which version gives the most accurate and consistent answers.

Outcome: You can call an LLM from code, design prompts deliberately, and explain why a model hallucinates.

7. Module 5: Embeddings and vector databases

Short answer: Module 5 teaches you to turn text into embeddings, store them in a vector database and search by meaning, which is the engine behind RAG.

A vector database stores embeddings and finds the vectors closest to a query, so "refund for late delivery" matches "compensation for delayed orders" even with no shared words.

Topics:

• Embedding models for text (and an introduction to multimodal embeddings)
• Similarity measures: cosine similarity and dot product
• Chunking: splitting long documents into pieces, with character, recursive, document-based and semantic methods
• Indexing and approximate nearest-neighbour search
• Metadata filters (for example, search only HR policies from 2026)
• Choosing a store: a library (FAISS), an embedded database (Chroma), a managed service (Pinecone, Weaviate) or Postgres with pgvector

Tools: an embedding model API or a Hugging Face embedding model, FAISS, Chroma, Pinecone, Weaviate, pgvector.

Mini lab: Embed 200 FAQ entries from a public government or bank website, store them in Chroma or FAISS, and build a search box that returns the three closest answers to any question.

Outcome: You can build semantic search and choose sensible chunk sizes and a vector store for a use case.

8. Module 6: Retrieval-augmented generation (RAG)

Short answer: Module 6 combines modules 4 and 5: you retrieve relevant text from your own documents and pass it to an LLM so its answers are grounded in your data, with citations.

RAG (retrieval-augmented generation) was introduced by Lewis et al. at Facebook AI in a May 2020 paper that combined a language model with a searchable index retrieved at generation time (arXiv, checked October 2026). Today it is the most common way companies use LLMs on private data.

Here is the RAG pipeline you will build, step by step:

1. Ingest: load PDFs, web pages or database rows
2. Chunk: split them into passages
3. Embed: convert each chunk into a vector
4. Store: save vectors and metadata in a vector database
5. Retrieve: embed the user's question and fetch the top matching chunks
6. Rerank: reorder the chunks so the most relevant come first
7. Generate: send the question plus chunks to the LLM with a grounded prompt
8. Cite and check: return the answer with sources, and flag answers not supported by the chunks

Topics:

• Naive RAG vs advanced RAG (query rewriting, hybrid keyword plus vector search, reranking)
• Graph RAG and multi-document RAG (introduction)
• Prompt templates for grounded answers and refusals
• LangChain: models, prompts, retrievers, chains
• LlamaIndex: document loaders, indexes and query engines
• Common failure points: bad chunks, wrong retrieval, missing citations

Tools: LangChain, LlamaIndex, a vector store from module 5, an LLM API.

Mini lab: Build a "policy assistant" that answers questions from five public PDF documents (for example, a university's academic regulations) and shows the page each answer came from.

Outcome: You can build, debug and improve a RAG application, the skill Indian employers ask for most.

9. Module 7: Fine-tuning with LoRA

Short answer: Module 7 teaches when fine-tuning beats prompting or RAG, and how to fine-tune an open model cheaply with parameter-efficient methods such as LoRA and QLoRA.

Fine-tuning means training an existing model further on your own examples so it learns a style, format or narrow task. LoRA (Low-Rank Adaptation) freezes the original model weights and trains small extra matrices instead, so you need far less memory and compute. Hugging Face's PEFT library documentation describes these parameter-efficient methods, which train a small number of extra parameters instead of the whole model (Hugging Face, October 2026). QLoRA applies the same idea to a compressed (quantised) model.

Topics:

• Supervised fine-tuning with instruction and response pairs
• Preparing a clean training dataset and a held-out test set
• LoRA and QLoRA settings: rank, target layers, learning rate (concept level)
• RLHF and preference tuning (concepts)
• Comparing a fine-tuned model with the base model and with RAG

Tools: Hugging Face Transformers, PEFT, a GPU notebook service, an open-weight model from Hugging Face Hub.

Mini lab: Fine-tune a small open model with LoRA on 500 examples that turn messy customer complaints into a fixed JSON format. Compare its output with the base model on 50 test complaints.

Outcome: You can decide between prompting, RAG and fine-tuning, and run a LoRA fine-tune end to end.

10. Module 8: Image and multimodal generation

Short answer: Module 8 covers how models generate images and handle several types of input, from GANs and VAEs to the diffusion models behind today's image tools.

Multimodal means a model can work with more than one type of data, such as text, images, audio and video.

Key terms explained:

• GAN (generative adversarial network): two networks, a generator and a discriminator, trained against each other
• VAE (variational autoencoder): a model that compresses data into a smaller "latent" space and generates new samples from it
• Diffusion model: a model that learns to remove noise step by step, turning random noise into an image; latent diffusion, the basis of Stable Diffusion, does this in a compressed space

Topics:

• Autoencoders, VAEs and GANs (with types such as conditional GANs)
• Diffusion: forward noising, reverse denoising, text conditioning
• Text-to-image prompting: subject, style, composition, negative prompts
• Vision-language models: describing images, reading charts and documents (OCR)
• Speech and audio basics: text to speech and speech to text
• Copyright, consent and deepfake risks in image and video generation

Tools: Stable Diffusion (open models via Hugging Face), image features of major LLM platforms, a multimodal LLM API.

Mini lab: Generate a set of 10 product images for a fictional Hyderabad handloom brand with Stable Diffusion, then use a multimodal model to write captions and alt text for each image.

Outcome: You understand how image generation works and can build a simple text-to-image or image-understanding feature.

11. Module 9: Agents and tool use

Short answer: Module 9 teaches you to build AI agents, LLM-powered programs that plan steps, call tools such as search, databases or APIs, and act until a goal is met.

An agent is a system where the LLM decides which action to take next, runs a tool, reads the result and continues. The ReAct pattern (reasoning plus acting, Yao et al., October 2022) is the basis of many agent designs. If you want to know how agents differ from plain generative AI, read our comparison of agentic AI vs generative AI.

Topics:

• Function calling (tool calling): describing a tool to the model and handling its response
• The agent loop: plan, act, observe, repeat; stopping conditions
• Memory: short-term conversation memory and long-term memory in a vector store
• Multi-agent workflows: a researcher agent, a writer agent and a reviewer agent working together
• Human approval steps for risky actions (sending emails, updating records)
• Standards seen in 2026 job descriptions: MCP (Model Context Protocol, for connecting tools) and A2A (agent-to-agent communication)
• Agent frameworks: LangChain agents, LangGraph, CrewAI, AutoGen and Semantic Kernel (learn one well)

Tools: LangChain or LangGraph, one other agent framework, an LLM API that supports tool calling.

Mini lab: Build a "placement prep agent" that takes a job description, searches your notes for matching skills, lists gaps and drafts five interview questions, with a human approval step before it saves anything.

Outcome: You can build a tool-using agent with clear limits, memory and human checkpoints.

12. Module 10: LLMOps and deployment

Short answer: Module 10 teaches you to turn a notebook prototype into a working service: wrap it in an API, package it, deploy it on a cloud AI platform, and monitor quality and cost.

LLMOps is the practice of deploying, monitoring and maintaining LLM applications in production, similar to MLOps for classic machine learning.

Topics:

• Building an API for your app with FastAPI (or Flask)
• Packaging with Docker; an introduction to Kubernetes
• Cloud AI platforms: Amazon Bedrock and SageMaker on AWS, Microsoft Foundry (formerly Azure AI Foundry, which includes Azure OpenAI), and Gemini Enterprise Agent Platform (formerly Vertex AI) on Google Cloud, which Google renamed in April 2026
• Logging, tracing and monitoring: latency, token usage, errors
• Cost control: caching, smaller models for simple tasks, prompt length limits
• Security and privacy: API key management, personal data handling, prompt-injection risks
• Versioning prompts and models; CI/CD basics with Git

Tools: FastAPI, Docker, one cloud AI platform, MLflow or LangSmith for tracking and tracing, GitHub Actions or a similar CI tool.

Mini lab: Wrap your module 6 RAG app in a FastAPI endpoint, put it in a Docker container, deploy it to a free or trial cloud tier, and log every request's latency and token count.

Outcome: You can ship an LLM app as a service and keep an eye on its cost, speed and failures.

13. Module 11: Evaluation and responsible AI

Short answer: Module 11 teaches you to measure whether your GenAI app is accurate, safe and fair, and to add guardrails before real users see it.

Most syllabi skip evaluation, yet the TCS, JPMorganChase, Wells Fargo, Tech Mahindra and Capgemini GenAI listings we read on 24 October 2026 all named evaluation, hallucination or groundedness checks, or observability.

Topics:

• Text metrics: BLEU, ROUGE, METEOR, BERTScore, and why they are not enough for chat apps
• LLM-specific checks: groundedness (is the answer supported by retrieved text?), factuality, relevance, coherence
• Building a test set of questions with expected answers; regression testing after every prompt change
• Using an LLM as a judge, with human spot checks
• Image metrics at concept level: FID and Inception Score
• Guardrails: input and output filters, refusals, PII masking, prompt-injection defences
• Risk frameworks: NIST AI 600-1, the Generative AI Profile of NIST's AI Risk Management Framework, lists 12 GenAI risks and calls hallucination "confabulation" (NIST, published July 2024, checked October 2026)
• Bias, privacy, copyright and transparency; India's AI Governance Guidelines, unveiled by MeitY in November 2025 (PIB, November 2025)

Tools: a test-set spreadsheet or notebook, MLflow or LangSmith evaluation features, a guardrail library or custom filters.

Mini lab: Create 50 test questions for your RAG app, score answers for groundedness and correctness, fix the three worst failures, and re-run the test to show the improvement.

Outcome: You can prove your app works with numbers, catch regressions and explain the main risks of GenAI.

14. Capstone project ideas

Short answer: The capstone combines at least four modules into one working, deployed project with a demo video, a GitHub repository and a short write-up of results and limits.

Pick one project that matches the role you want. Each idea below names the modules it uses.

What every capstone should include:

• A clear problem statement and target user
• An architecture diagram (a numbered flow is fine)
• Working code on GitHub with a README and setup steps
• A deployed demo or a 3-minute screen recording
• An evaluation table: test questions, scores, and what you fixed
• A short "limitations and risks" section

For smaller starter projects, see our list of generative AI projects for beginners.

15. Beginner track vs advanced track

Short answer: Non-coders and managers can take a short beginner track focused on tools, prompting and responsible use; developers and engineers should take the full advanced track with RAG, fine-tuning, agents and deployment.

Not everyone needs every module. Use this table to pick your track.

A middle path also works: finish the beginner track, then learn Python and continue from module 3.

How does this compare with a data science syllabus? A data science syllabus focuses on statistics, data analysis, visualisation and predictive machine learning models. A generative AI syllabus shares the Python and ML foundations (modules 1 and 2) but then moves to transformers, LLMs, prompting, embeddings, RAG, fine-tuning, diffusion, agents and LLM evaluation. Data analysts often have a head start because they already know Python and data handling.

16. How the syllabus maps to real job descriptions

Short answer: The modules that matter most for jobs are Python, RAG, LLM APIs, LangChain-style frameworks, vector databases, evaluation and cloud deployment, based on 12 Indian GenAI job descriptions we read on 24 October 2026.

The JDs came from Naukri and LinkedIn listings seen on 24 October 2026 from Capgemini, Infosys, Tech Mahindra, PwC, Tiger Analytics, Coforge, Wells Fargo, TCS, JPMorganChase, TVS Credit, Crisil and a recruiter hiring for a client. They are listings seen on that date, not hiring commitments.

Keyword-match counts on Naukri point the same way. On 24 October 2026, a Naukri search showed about 10,953 results for "generative ai" in India, about 7,585 for "rag" and about 4,323 for "langchain". These are keyword matches that include duplicates and loosely related roles, not a count of open GenAI jobs, but they show why modules 5, 6 and 9 deserve the most time.

Which modules lead to which role:

• After modules 1 to 4: you can apply for AI intern roles and use LLMs in support, content or analyst work
• After modules 5 and 6: you can build RAG systems, the core of most "Gen AI developer" and "Generative AI engineer" listings
• After modules 7 to 9: you can handle fine-tuning and agent work asked for in senior and "agentic AI" roles
• After modules 10 and 11: you can own a feature in production, which experienced roles expect

For the full picture of the role, read how to become a generative AI engineer. To practise for interviews on these modules, use our generative AI interview questions.

17. Certification syllabi and university syllabi compared

Short answer: Vendor certification syllabi test a narrower slice of this syllabus, and university GenAI electives vary by institution, so use this syllabus for skills and add an exam outline only if you want a credential.

Many searchers look for an exam syllabus rather than a course syllabus. Here is how the main certification outlines relate to the modules above, using the official pages as checked in October 2026.

AWS offers the foundational AI Practitioner (AIF-C01, 65 questions, $100) and the Generative AI Developer, Professional (AIP-C01, 75 questions, $300) (AWS, October 2026). Microsoft's current associate is the Azure AI Apps and Agents Developer Associate (exam AI-103); AI-102 is retired. For exam detail, read our Google Cloud Generative AI Leader certification guide.

University syllabi (BCA, MCA, B.Tech): GenAI electives in Indian universities differ by university and year, and they tend to stress theory and written exams. If you are a BCA, MCA or B.Tech student, follow your university's official syllabus for marks, and use modules 4 to 6 and a capstone from this page to build the practical skills employers test.

18. How to use this syllabus for self-study

Short answer: Study one module at a time, spend at least half your hours building the mini lab, keep everything on GitHub, and review each module against the outcome line before moving on.

A simple weekly routine for 8 to 10 hours:

1. Read and watch (2 to 3 hours): official documentation first, then one course video series
2. Follow along (2 hours): run the documentation examples yourself
3. Build the mini lab (3 to 4 hours): change the dataset or problem so it is your own
4. Write it up (1 hour): a README with what you built, what failed and what you learned

For resources, start with official sources: the Python documentation, Hugging Face docs for Transformers and PEFT, Microsoft's prompt engineering guide (module 4), LangChain and LlamaIndex docs, the RAG paper (module 6), cloud vendor explainers, and NIST AI 600-1 (module 11).

Common mistakes to avoid:

• Jumping to agents before you can build a basic RAG app
• Watching course videos for weeks without writing code
• Copying a tutorial project without changing anything
• Ignoring evaluation, so you cannot say whether your app is any good
• Chasing every new model release instead of mastering the patterns

If you want a month-by-month learning timeline with resources, our generative AI roadmap lays it out phase by phase. If you prefer a structured course, compare costs in our guide to generative AI course fees before you decide.

About a syllabus PDF: we have not attached a PDF to this page. The at-a-glance table in section 1 and the module sections are designed to be printed or saved as a PDF from your browser, so you can tick off topics as you go.

19. How Brolly Academy helps

Short answer: Brolly Academy's 3-month Generative AI course in Hyderabad follows a 16-module syllabus that covers most of the modules on this page, with live trainers, projects and placement assistance.

Brolly Academy's Generative AI Training in Hyderabad runs for 3 months in classroom and live online formats, with a self-paced video recording plan as well (course page, checked 24 October 2026). The roadmap on the page is: month 1, Python, machine learning and deep learning (scikit-learn, TensorFlow, PyTorch); month 2, generative AI, LLMs, NLP and computer vision; month 3, AI agents, prompt engineering and MLOps, followed by a capstone and placement preparation.

Here is how Brolly's 16 modules map to the syllabus on this page:

To be clear about the gaps: the Brolly syllabus does not name FastAPI, Docker, LangGraph or CrewAI, so plan to learn those from documentation if your target JDs ask for them.

What else the course page lists:

• Trainers: Mr. Dinesh, Generative AI Specialist and Cloud Architect with 12+ years in AI, ML and Generative AI, with co-trainers Ms. Madhumitha (Senior AI and ML Mentor, 15+ years) and Tabassum (AI and NLP Engineer, 7+ years)
• Capstone projects: an AI chatbot with GPT and LangChain, a Stable Diffusion image generator, customer service automation, an MLOps pipeline deployment and multi-agent AI workflows
• Eligibility: coding is not mandatory and no CS degree is required; Python is preferred
• Fees: Video Recording ₹14,999, Online ₹35,000 and Classroom ₹40,000, with EMI on the Classroom and Online plans
• Certificate: a Brolly Academy course completion certificate after the course and capstone (no vendor certification is included)
• Placement assistance: resume and LinkedIn help, mock interviews and interview scheduling (the page gives no placement numbers)

Frequently asked questions