Full curriculum
36 modules. 12 weeks. 25+ builds.
Every week runs three live, mentor-led sessions with a guided mini-lab and a main build. Sessions are Monday, Thursday and Saturday or Sunday, 8 pm to 9 pm IST.
📚 36 modules🗓️ 12 weeks🧪 12 mini-labs🚀 12 main builds
📅 Week 01: Foundations of AI Engineering 3 sessions
🧪 Mini-lab: First LLM Script · 🚀 Main build: Build a command-line Ask-an-Expert assistant
01Introduction to AI Engineering & the GenAI Landscape
- What is an AI Engineer?
- AI vs ML vs Deep Learning vs GenAI
- The Modern AI Stack
- Where LLMs Fit In
- Capabilities & Limits of GenAI
- Common AI Application Patterns
- Responsible & Ethical AI
- The AI Product Lifecycle
- Roles in an AI Team
- Industry Use Cases
02Development Environment & Working with LLM APIs
- Python Environment & Virtualenv
- Notebooks vs Scripts
- Managing API Keys & Secrets
- Anatomy of an LLM API Call
- Requests, Responses & Tokens
- Temperature & Sampling
- Streaming Responses
- Rate Limits & Error Handling
- Cost Awareness
- Examples: OpenAI, Claude, Open Endpoints
03Python for AI Engineers
- Functions, Modules & Packages
- Working with JSON
- Type Hints & Dataclasses
- Async Basics for API Calls
- Environment Variables
- Logging
- Reading & Writing Files
- Calling REST APIs
- Clean Code for AI Apps
📅 Week 02: Data & Machine Learning Essentials 3 sessions
🧪 Mini-lab: Semantic Similarity Explorer · 🚀 Main build: Build a Find Similar search over a small dataset
04Data Handling for AI
- NumPy Arrays & Vectors
- Pandas DataFrames
- Loading CSV, JSON & Parquet
- Cleaning & Missing Values
- Filtering & Aggregation
- Basic Visualization
- Train and Test Concepts
- Working with Text Data
- Data Quality for AI
05Machine Learning Foundations (Just Enough)
- Supervised vs Unsupervised
- Features & Labels
- Classification vs Regression
- Training vs Inference
- Overfitting & Generalization
- Accuracy, Precision & Recall
- The Bias and Variance Idea
- Why GenAI Still Needs ML Thinking
06Embeddings & Vector Representations
- What Are Embeddings?
- Turning Text into Vectors
- Semantic Similarity
- Cosine Similarity & Distance
- Embedding Models (concept)
- Visualizing Embeddings
- Search, Clustering & Recommendations
- Limitations of Embeddings
📅 Week 03: Deep Learning Essentials with PyTorch 3 sessions
🧪 Mini-lab: Train a Tiny Classifier · 🚀 Main build: Build and evaluate a text or image classifier in PyTorch
07Neural Networks Fundamentals
- Neurons, Weights & Biases
- Layers & Activation Functions
- Forward Propagation
- Loss Functions
- Gradient Descent (intuition)
- Back-Propagation (intuition)
- Epochs, Batches & Learning Rate
- Why Deep Networks Work
08Deep Learning with PyTorch
- Why PyTorch Is the Default
- Tensors & Operations
- Autograd
- Defining a Model (nn.Module)
- The Training Loop
- Optimizers & Schedulers
- GPU vs CPU
- Saving & Loading Models
- Datasets & DataLoaders
09Training, Evaluation & Avoiding Overfitting
- Train, Validation & Test Splits
- Regularization & Dropout
- Early Stopping
- Hyperparameter Tuning
- Reading Loss Curves
- Transfer Learning (intro)
- Model Evaluation in Practice
📅 Week 04: NLP & the Transformer Architecture 3 sessions
🧪 Mini-lab: Visualize Attention · 🚀 Main build: Build a text and sentiment app using a pretrained transformer
10NLP Foundations
- What Is NLP?
- Text Preprocessing
- Tokenization Basics
- Bag-of-Words & TF-IDF
- Sequence Modeling Problems
- Classic vs Modern NLP
- Classification, NER & Summarization
11Tokenization & Word Embeddings
- Tokens vs Words vs Characters
- Subword Tokenization (BPE concept)
- Vocabulary & Token IDs
- Word Embeddings (Word2Vec idea)
- Contextual Embeddings
- Token Limits & Context
- Counting Tokens for Cost
12The Transformer Architecture
- Why Transformers Replaced RNNs
- Self-Attention (intuition)
- Multi-Head Attention
- Positional Encoding
- Encoder vs Decoder
- Pre-training vs Fine-tuning
- From Transformer to GPT-style Models
📅 Week 05: Large Language Models 3 sessions
🧪 Mini-lab: Compare Model Outputs · 🚀 Main build: Build a multi-model comparison tool
13How Large Language Models Work
- Next-Token Prediction
- Pre-training at Scale
- What Parameters Mean
- Emergent Capabilities
- Strengths & Failure Modes
- Hallucinations Explained
- Determinism & Randomness
- Why Prompts Matter
14Model Families: Open vs API
- API vs Open-Weight Models
- Model Sizes & Trade-offs
- Latency, Cost & Quality
- Running Open Models Locally (concept)
- Multimodal Models
- How to Choose a Model
- Examples: GPT, Claude, Llama, Mistral
15Context, Tokens & Limitations
- Context Windows Explained
- Input vs Output Tokens
- Managing Long Inputs
- Truncation & Summarization
- System, User & Assistant Roles
- Conversation Memory
- Token Budgeting & Cost Control
📅 Week 06: Prompt Engineering 3 sessions
🧪 Mini-lab: Prompt Showdown · 🚀 Main build: Build a prompt-driven content tool with a test harness
16Prompting Fundamentals & Patterns
- Anatomy of a Good Prompt
- Zero-shot vs Few-shot
- Role & System Prompts
- Chain-of-Thought Prompting
- Instruction Clarity
- Delimiters & Formatting
- Common Prompting Pitfalls
- Reusable Prompt Templates
17Structured Outputs & Function Schemas
- Why Structured Output Matters
- Asking for JSON
- JSON Schema & Validation
- Function and Tool Schemas
- Parsing & Error Recovery
- Constrained Generation (concept)
- Output Reliability Techniques
18Prompt Evaluation & Iteration
- What Makes a Prompt Good?
- Building a Test Set
- Manual vs Automated Evaluation
- LLM-as-a-Judge (concept)
- Versioning Prompts
- A/B Testing Prompts
- Reducing Hallucinations
📅 Week 07: Retrieval-Augmented Generation (RAG) 3 sessions
🧪 Mini-lab: Build a Mini Knowledge Base · 🚀 Main build: Build Chat with your documents, version one
19Introduction to RAG
- Why RAG? Limits of LLM Knowledge
- The RAG Pipeline Overview
- Retrieve, Augment & Generate
- Grounding & Citations
- RAG vs Fine-tuning
- RAG Architecture Patterns
- Real-World RAG Use Cases
20Embeddings & Vector Databases
- From Documents to Embeddings
- What Is a Vector Database?
- Indexing & Similarity Search
- Metadata Filtering
- Hosted vs Self-Hosted
- Choosing a Vector Store
- Examples: Pinecone, Chroma, pgvector, FAISS
21Chunking & Retrieval Strategies
- Document Loading & Parsing
- Chunk Size & Overlap
- Chunking Strategies
- Embedding the Chunks
- Top-K Retrieval
- Relevance & Recall
- Handling Tables, PDFs & Mixed Content
📅 Week 08: Advanced RAG 3 sessions
🧪 Mini-lab: Re-ranking Experiment · 🚀 Main build: Build a production-grade RAG app with evaluation
22Building a Production RAG Application
- End-to-End RAG Architecture
- Prompt Assembly with Context
- Source Citations in Answers
- Handling I do not know
- Conversation + Retrieval
- Caching
- Putting a UI on RAG
23Advanced Retrieval Techniques
- Hybrid Search (keyword + vector)
- Re-ranking Results
- Query Rewriting & Expansion
- Filtered Retrieval
- Multi-Query Retrieval
- Hierarchical and Parent-Child Chunks
- Reducing Irrelevant Context
24RAG Evaluation & Quality
- Retrieval Metrics (recall, precision)
- Answer Faithfulness
- Groundedness & Citations
- Building a RAG Test Set
- Detecting Hallucinations
- Continuous Evaluation
- Common RAG Failure Modes
📅 Week 09: AI Agents 3 sessions
🧪 Mini-lab: Single-Tool Agent · 🚀 Main build: Build a multi-step research and automation agent
25Introduction to AI Agents
- What Is an AI Agent?
- LLM + Tools + Memory + Loop
- Agents vs Workflows
- The ReAct Pattern (reason + act)
- Planning & Decomposition
- When Not to Use Agents
- Agent Use Cases
26Tool Use & Function Calling
- Function and Tool Calling Explained
- Defining Tools & Schemas
- Parsing Tool Calls
- Executing & Returning Results
- Multi-Tool Selection
- Error Handling in Tool Use
- Safety & Guardrails for Actions
27Agent Frameworks & Orchestration
- Orchestration Frameworks (concept)
- Agent Memory & State
- Multi-Step Reasoning
- Multi-Agent Patterns
- Human-in-the-Loop
- Observability & Tracing
- Examples: LangChain, LlamaIndex
📅 Week 10: Fine-Tuning & Customization 3 sessions
🧪 Mini-lab: Prepare a Fine-tuning Dataset · 🚀 Main build: Fine-tune a small model for a focused task
28When & Why to Fine-Tune
- Fine-tuning vs RAG vs Prompting
- What Fine-tuning Can & Cannot Do
- Cost & Effort Trade-offs
- Use Cases for Fine-tuning
- Data Requirements
- Risks & Pitfalls
- A Decision Framework
29Fine-Tuning Techniques
- Full vs Parameter-Efficient Tuning
- LoRA & PEFT (concept)
- Instruction Tuning
- Quantization Basics
- Hardware Considerations
- Hosted Fine-tuning Services
- Open-Model Fine-tuning (concept)
30Datasets & Evaluation for Fine-Tuning
- Collecting & Curating Data
- Formatting Training Examples
- Cleaning & De-duplication
- Train and Validation Split
- Evaluating a Fine-tuned Model
- Avoiding Catastrophic Forgetting
- Iterating Safely
📅 Week 11: Deployment & LLMOps 3 sessions
🧪 Mini-lab: Containerize an AI App · 🚀 Main build: Deploy a monitored, guard-railed GenAI service
31Serving AI Applications
- Building an API with FastAPI
- Request and Response Design
- Streaming to Clients
- Building UIs (Streamlit / Gradio)
- Authentication Basics
- Async & Concurrency
- Connecting Front-end to AI Back-end
32Containerization & Cloud Deployment
- Why Containers? Docker Basics
- Building a Container Image
- Secrets in Production
- Deploying to the Cloud (concept)
- Scaling Basics
- CI/CD Overview
- Free Hosting Options for Demos
33Cost, Latency, Guardrails & Monitoring
- Token Cost Optimization
- Caching & Batching
- Latency Reduction
- Input and Output Guardrails
- Prompt-Injection Awareness
- Logging & Observability
- Monitoring Quality & Privacy
📅 Week 12: Capstone & Career Showcase 3 sessions
🧪 Mini-lab: Portfolio Polish · 🚀 Main build: Ship a final capstone: a deployed, end-to-end GenAI product with demo
34Capstone Planning & Build
- Choosing a Capstone Problem
- Designing the AI Architecture
- RAG, Agent or Fine-tuning Choice
- Building the Core Pipeline
- Iterating with Evaluation
- Documentation & README
35Deployment & Demo
- Deploying the Capstone Publicly
- Building the Demo UI
- Performance & Cost Check
- Adding Guardrails
- Recording a Demo Video
- Writing the Case Study
36Portfolio & Career Showcase
- GitHub Portfolio Setup
- Showcasing Your Projects
- Writing About Your Work
- Interview Prep for AI Roles
- Building Your Personal Brand
- The CareerByteCode Showcase
🎯 Outcomes by the end of week 12 what you walk away with
🧪
25+ hands-on projects and labs
A mini-lab and a main build every week, across all 12 weeks.
🚀
1 deployed capstone
A real, public GenAI product you can show recruiters.
🧠
End-to-end AI engineering
Hands-on with LLMs, RAG, agents, fine-tuning and deployment.
💼
GitHub portfolio + demo
Proof of skill for employers, not just a certificate.
📜
AI Showcase certificate
Peer-reviewed work and a CareerByteCode AI Showcase certificate.
Ready to start week 1?
Join the next live cohort and build alongside your mentors.