GEN AI Developer - Section 12: Pre-recorded Video Topic List
This document is Section 12 of a GenAI Developer bootcamp: a day-by-day list of pre-recorded conceptual videos, one per learning day across 72 days. Each video is ~5-8 minutes and is meant to be conceptual (not live coding). For every day the document specifies a concept title and a fixed template: a simple one-sentence definition, intuition/why-it-matters tied to the day's practical focus, one real-world example, one common misconception, and interview relevance (explain in 45-90 seconds, connect to a failure mode/engineering decision). The curriculum runs from developer role and Python basics through prompting, APIs, RAG, evaluation, security, deployment, a capstone, and interview preparation.
₹999
One payment, tax included. No mentor and no live classes — the full list is below.
Where this course leaves you
- This course covers Section 12 of a GenAI Developer Bootcamp with 72 days of pre-recorded conceptual videos.
- Each 5–8 minute video follows a fixed structure: definition, intuition, example, misconception, and interview relevance.
- The curriculum progresses from Python and developer fundamentals to prompting, APIs, RAG, evaluation, security, and deployment.
- It concludes with a capstone project and focused interview preparation.
At a glance
- Format
- Self-paced, online
- Weeks
- 12
- Lessons
- 75
- Price
- ₹999, tax included
- Track
- Tech Track
And what you do not get
A self-paced course is the material and the practice. Anything that needs another person's time is not part of it, and we would rather you knew that before you paid than after.
Included
- Every lesson, written outThe full text of each lesson below, in order, to read at whatever pace suits you.
- The videos that go with themWhere a lesson has a recording or a walkthrough, it plays inside the lesson.
- Coding practice in the browserRun the examples and the exercises as you read them. There is nothing to install.
- Your progress, rememberedStop in the middle of a week and pick it up on another device a month later.
Not included
- No mentorNobody is assigned to you, and no one reviews what you write.
- No live classes, no office hoursThere is no timetable and no session to attend.
- No assignments to hand inNothing is submitted, and nothing is marked.
- No messagingYou cannot write to a teacher from inside the course.
Those four are what the mentored programmes are for. See the programmes.
All 12 weeks, in order
Everything in the course is listed here. There is nothing behind the price you cannot see first.
- Week 1
Foundations, environment and Python basics (Days 1-6)
Sets up the GenAI developer role, Python as the control layer, functions/modules, files/JSON, debugging, and Git/HTTP, ending with the Week 1 assessment.
- Day 0 - Orientation: Prerequisites and What You Will Be Able To Do
- Day 1 - GenAI Developer role, environment + baseline: What Does a GenAI Developer Actually Build?
- Day 2 - Python values, strings, collections + control flow: Python Is the Control Layer Around the Model
- Day 3 - Functions, modules + reusable application code: Functions Keep LLM Applications Testable
- Day 4 - Files, JSON + configuration: JSON Is the Contract Between AI Components
- Day 5 - Exceptions, logging + debugging: Debugging GenAI Starts With Ordinary Software Debugging
- Day 6 - Git, simple HTTP calls + Week 1 assessment: Versioned Code Beats "final_final.py"
- Week 2
LLM mental model and prompting (Days 7-12)
Covers how LLMs work, API messages and instruction boundaries, prompt design, few-shot examples, a bridge into Python classes and objects, structured outputs, and prompt test sets, ending with the Week 2 assessment.
- Day 7 - LLM mental model + tokens/context: An LLM Predicts Text; Your Application Supplies the Job
- Day 8 - Model API messages + instruction boundaries: Instructions and Data Should Not Be Mixed Carelessly
- Day 9 - Prompt design: task, context, constraints: Good Prompts Are Specifications, Not Magic Spells
- Day 10 - Few-shot examples + output consistency: Examples Teach the Boundary of the Task
- Day 10b - Python classes and objects: From Functions to Class-Based Code
- Day 11 - Structured outputs + Pydantic/JSON schema: Structured Output Turns Natural Language Into an API Contract
- Day 12 - Prompt test set, parameters + Week 2 assessment: You Cannot Improve a Prompt Without a Fixed Test Set
- Week 3
Application engineering around LLMs (Days 13-18)
REST/FastAPI, service layers/provider abstraction, secrets/config, resilience, testing, and persistence/logging, ending with the Week 3 assessment.
- Day 13 - REST + FastAPI around an LLM feature: An LLM Feature Becomes Useful Through an Application Contract
- Day 14 - Service layers + provider abstraction: Keep Provider Code at the Edge
- Day 15 - Secrets, environment variables + configuration: API Keys Never Belong in Source Code or Prompts
- Day 16 - Timeouts, retries + resilient external calls: External Model Calls Fail; Design for It
- Day 17 - Testing LLM application code: Test Deterministic Boundaries Even When Model Output Varies
- Day 18 - Basic persistence, logging + Week 3 assessment: Store the Right Evidence, Not Every Secret
- Week 4
Embeddings, ingestion and retrieval basics (Days 19-24)
Embeddings/semantic similarity, document ingestion, cleaning/metadata, chunking, vector stores/top-k retrieval, and retrieval inspection, ending with the Week 4 assessment.
- Day 19 - Embeddings + semantic similarity: Embeddings Turn Meaning Into Searchable Vectors
- Day 20 - Document ingestion + text extraction: RAG Quality Starts Before Embeddings
- Day 21 - Cleaning + metadata design: Metadata Is Part of Retrieval Quality
- Day 22 - Chunking strategies: A Chunk Should Preserve a Useful Unit of Meaning
- Day 23 - Vector stores/indexes + top-k retrieval: A Vector Store Is an Index, Not a Knowledge Oracle
- Day 24 - Retrieval inspection + Week 4 assessment: Inspect Retrieval Before Adding Generation
- Week 5
RAG architecture and behavior (Days 25-30)
RAG architecture/suitability, grounded context construction, citations, answerability/refusal, conversation context, and RAG failure diagnosis, ending with the Week 5 assessment.
- Day 25 - RAG architecture + suitability: RAG Is a Data Flow, Not a Framework Feature
- Day 26 - Context construction + grounded prompt: Retrieved Text Must Be Converted Into Clear Evidence
- Day 27 - Citations + source traceability: A Citation Must Point to the Evidence That Supports the Claim
- Day 28 - Answerability + refusal: Knowing When Not to Answer Is a Product Feature
- Day 29 - Conversation context + query ambiguity: Chat History and Knowledge Context Solve Different Problems
- Day 30 - RAG failure diagnosis + Week 5 assessment: Ask: Retrieval Failure or Generation Failure?
- Week 6
RAG evaluation and experiments (Days 31-36)
Evaluation datasets, retrieval quality evaluation, multi-dimensional answer quality, chunking/retrieval experiments, hybrid search/reranking, and regression evaluation, ending with the Week 6 assessment.
- Day 31 - Evaluation datasets for RAG: Evaluation Starts With Representative Questions
- Day 32 - Retrieval quality evaluation: Evaluate Retrieval Separately From the Final Answer
- Day 33 - Answer correctness, relevance + groundedness: Good RAG Has More Than One Quality Dimension
- Day 34 - Chunking + retrieval experiments: Change One Retrieval Variable at a Time
- Day 35 - Hybrid search + reranking awareness: First Retrieve Broadly, Then Rank More Precisely
- Day 36 - Regression evaluation + Week 6 assessment: Every Improvement Should Survive the Old Test Set
- Week 7
Evaluation methods, security and reliability (Days 37-42)
Deterministic vs model-based evals, prompt regression/pairwise, hallucination analysis, prompt injection, privacy/secrets, and latency/cost/abuse, ending with the Week 7 assessment.
- Day 37 - Deterministic vs model-based evals: Use Code for What Code Can Check
- Day 38 - Prompt regression + pairwise comparison: Prompt Changes Need Release Criteria
- Day 39 - Hallucination + unsupported-claim analysis: Fluent Is Not the Same as Grounded
- Day 40 - Prompt injection: direct + indirect: Retrieved Documents Can Contain Instructions Too
- Day 41 - Privacy, secrets + output handling: System Prompts Are Not Secret Vaults
- Day 42 - Latency, cost, abuse + Week 7 assessment: Reliability Includes Cost and Time
- Week 8
Application patterns, tools and frameworks (Days 43-48)
This week moves from raw LLM primitives to reusable application patterns. You learn how summarization works under a compression budget, how to prefer structured outputs for decisions, what a tool call really is and why it must be validated before execution, how frameworks organize components without replacing understanding, and how to choose between fine-tuning, RAG and prompting with awareness of agents and MCP. The week ends with an assessment.
- Day 43 - Summarization patterns + long inputs: Summarization Has a Compression Budget
- Day 44 - Extraction/classification patterns: Use Structured Outputs for Decisions, Not Prose Parsing
- Day 45 - Function/tool calling basics: A Tool Call Is a Proposed Function Invocation
- Day 46 - Tool safety + human confirmation boundaries: Validate Before You Execute
- Day 47 - LangChain or LlamaIndex after primitives: Frameworks Organize Components; They Do Not Replace Understanding
- Day 48 - Fine-tuning vs RAG vs prompting + agent/MCP awareness: Choose the Intervention That Matches the Failure
- Week 8 assessment: Patterns, tools, safety and choosing interventions
- Week 9
Engineering, deployment and observability (Days 49-54)
Project structure/dependencies, mocking in tests, Docker/env vars, tracing/observability, caching/performance/cost, and deployment mental model, ending with the Week 9 assessment.
- Day 49 - Project structure + dependency management: A Reproducible GenAI App Has More Than app.py
- Day 50 - Mocking model/retrieval calls in tests: Tests Should Not Depend on Paid, Random External Calls
- Day 51 - Docker + environment variables: A Container Packages the Application, Not Its Secrets
- Day 52 - Tracing + observability for RAG: Trace the Request Across Retrieval and Generation
- Day 53 - Caching, performance + cost controls: Optimize the Bottleneck You Measured
- Day 54 - Deployment mental model + Week 9 assessment: Deployment Is an Environment Contract
- Week 10
Capstone Phase 1 (Days 55-60)
This week you begin your capstone project: deciding whether GenAI genuinely fits the problem, inventorying your knowledge sources with permissions in mind, building a stable ingestion and chunking baseline, designing an architecture that exposes failure stages, defining evaluation and a release rubric before improving, and defending a Phase 1 baseline in a cumulative viva.
- Day 55 - Capstone problem selection + GenAI suitability: First Decide Whether GenAI Is the Right Tool
- Day 56 - Corpus/source inventory + permissions: Your Knowledge Source Defines the Assistant's Boundaries
- Day 57 - Ingestion/chunking baseline: Build the Baseline Before Tuning
- Day 58 - Baseline RAG/API architecture: Architecture Should Make Failure Stages Visible
- Day 59 - Evaluation dataset + release rubric: Define "Good" Before Improving
- Day 60 - Capstone Phase 1 review + cumulative viva: A Strong Baseline Is a Defensible Checkpoint
- Week 11
Capstone Phase 2 (Days 61-66)
This week you finish your capstone: running disciplined retrieval and prompt experiments, settling on the simplest architecture that meets your quality bar, adding security and privacy regression tests, shipping a documented API with tests and Docker, writing an evidence-backed evaluation report with cost and latency, and rehearsing a defense where you own your system's failure modes.
- Day 61 - Capstone retrieval/prompt experiments: Improve One Measured Failure Class at a Time
- Day 62 - Final retrieval/context design: The Best Architecture Is the Simplest One That Meets the Quality Bar
- Day 63 - Security/privacy regression: Security Tests Belong in the Release Suite
- Day 64 - API/tests/Docker + final deployment: Quality and Engineering Must Ship Together
- Day 65 - Evaluation report + cost/latency analysis: A Demo Needs Evidence Behind It
- Day 66 - Capstone defense rehearsal + assessment: Own the Failure Modes of Your System
- Week 12
Interview preparation (Days 67-72)
A consolidation week that rehearses the real hiring pipeline for a GenAI Developer role: a Python backend coding screen, an LLM and structured-output discussion, an embeddings and RAG practical, an evaluation and security debugging case, a capstone presentation with behavioral questions, and a full mock interview with an honest gap plan.
- Day 67 - Python/backend coding screen: GenAI Interviews Still Test Software Fundamentals
- Day 68 - LLM, prompt + structured output screen: Explain LLM Application Concepts Without Buzzwords
- Day 69 - Embeddings + RAG practical: RAG Interviews Test the Whole Retrieval Chain
- Day 70 - Evaluation + security debugging case: A GenAI Engineer Must Prove Why the System Is Better
- Day 71 - Capstone presentation + behavioral: Your Project Story Should Show Decisions, Evidence and Limits
- Day 72 - Full mock hiring process + gap plan: Job Ready Means Strong Core Skills Plus a Clear Learning Boundary
Buy GEN AI Developer - Section 12: Pre-recorded Video Topic List
₹999
One payment. Tax is inside this figure, not added to it.
- You buy the course and start. There is no call and no application.
- No mentor, no live classes, no marked work, no messaging.
- Worth reading first: our refund policy.
Wanted a mentor instead?
Then this is not the thing to buy. The mentored programmes at our centre are months of full-time work with a named mentor, live classes and placement support. They are priced per batch rather than printed on a page, and you get the number on a free demo call.
Not sure this is the right course?
This one has no mentor attached to it. If that is what you actually want, book a free demo call and we will walk you through the mentored programme instead — honestly, including what it costs.
Placement assistance — not a guarantee — and we'll always be upfront about that.