Program Zero curriculum

Program Zero runs for 18 months (78 weeks) in 13 phases. You start with how computers work and your first programs, then learn data structures, databases, full-stack web and mobile development, machine learning, deep learning, and building, training and aligning large language models. The programme ends with cloud deployment, security and two capstone projects.

Book Your Seat Jump to the phases

What this programme is for

The goal isn't to build a ChatGPT-sized or Facebook-sized product in 18 months. No course anywhere can do that, because those products need huge compute budgets, large teams and years of work.

The goal is to give you every skill those teams use, from your first program up to research-level LLM engineering. The 18 months are training. Building India's own versions of these products starts at level One, after you pass all six tests.

The same thing, at a smaller scale

Every project uses the same architecture as the real product, just smaller. A transformer with 10 million parameters uses the same maths and code structure as one with 100 billion. A chat app built on WebSockets uses the same real-time delivery design as WhatsApp, without the global server fleet.

By the end, you will have built a transformer/LLM from scratch, run a small distributed pretraining pipeline, fine-tuned and aligned open-source models, served them efficiently, and shipped full-stack real-time social and chat apps.

The 78 weeks at a glance

Phases in teaching order. Phase 5 (maths) runs in parallel with Phases 2–4.
Phase	Weeks	Topic	Duration
Phase 0	1–5	Foundations	5 weeks
Phase 1	6–14	Programming Fundamentals	9 weeks
Phase 2	15–24	Data Structures & Algorithms	10 weeks
Phase 3	25–29	Databases	5 weeks
Phase 4	30–41	Full-Stack Web, Mobile & System Design	12 weeks
Phase 5	15–41	Math for Machine Learning (parallel track)	27 weeks (parallel)
Phase 6	42–47	Data Science & Classical Machine Learning	6 weeks
Phase 7	48–53	Deep Learning & Neural Networks	6 weeks
Phase 8	54–61	NLP, Transformers & Building LLMs (Core)	8 weeks
Phase 9	62–69	Advanced LLM Engineering (Research Level)	8 weeks
Phase 10	70–73	Cloud, MLOps & Deployment	4 weeks
Phase 11	74–75	Security — App, Network, Data & AI	2 weeks
Phase 12	76–78	Final Combined Capstone & Demo Day	3 weeks

Every phase in detail

What you'll learn in each phase, the project you'll build, and where the quarterly tests fall.

Phase 0

Foundations

Weeks 1–5 · 5 weeks

How computers work: CPU, RAM, storage, OS basics (Windows/Linux/Mac)
Linux fundamentals: file system, terminal, permissions, package managers
Command line & bash scripting basics
Git & GitHub: commits, branches, merges, pull requests
How the internet works: HTTP/HTTPS, DNS, client-server model
Binary, number systems, bits/bytes, character encoding
Logical reasoning & problem-solving (flowcharts, pseudocode)
Dev environment setup: VS Code, virtual environments
Math starts here (parallel, 2 classes/week through Week 14): algebra, functions, graphs, set theory, logic

Project: Personal static webpage, pushed to GitHub.

Phase 1

Programming Fundamentals

Weeks 6–14 · 9 weeks

Python

Variables, data types, operators, control flow, loops
Functions, recursion, scope
Built-in data structures: lists, tuples, dicts, sets, strings
File I/O, exception handling
OOP: classes, inheritance, polymorphism, encapsulation
Modules, packages, pip, virtual environments
Iterators, generators, decorators, lambdas
Regular expressions; working with APIs (requests), JSON

JavaScript (parallel)

Syntax, variables, functions, closures, scope, `this`
DOM manipulation, events
ES6+: arrow functions, destructuring, promises, async/await
Modules (import/export)

Project: CLI calculator → To-do app (Python) → Interactive quiz webpage (JS)
Test: Quarter 1 test — after month 3 (end of week 13, 10 Apr 2027); cumulative, covers weeks 1–13 (months 1–3)

Phase 2

Data Structures & Algorithms

Weeks 15–24 · 10 weeks

Time/space complexity, Big-O
Arrays, strings, searching (linear/binary)
Sorting (bubble, insertion, merge, quick, heap)
Linked lists (singly, doubly, circular)
Stacks, queues, deque, priority queue
Recursion & backtracking
Trees: binary trees, BST, tries, heaps
Hashing & hash tables
Graphs: BFS, DFS, Dijkstra, topological sort, Union-Find
Dynamic Programming: memoization, tabulation, classic problems
Greedy algorithms, divide and conquer
System design intro: scalability, complexity trade-offs

Math (parallel continues): discrete math — combinatorics, graph theory basics

Practice: Daily DSA problems (LeetCode/HackerRank style), reviewed in Sunday sessions

Project: Pathfinding visualizer / mini search engine using tries

Phase 3

Databases

Weeks 25–29 · 5 weeks

Relational DB concepts: keys, relationships, normalization
SQL: joins, subqueries, aggregates, window functions
Indexing, transactions, ACID
PostgreSQL/MySQL hands-on
NoSQL: document/key-value/column/graph concepts
MongoDB: CRUD, aggregation pipeline, schema design
Redis: caching, pub/sub, sessions
Schema design for a social/chat app
ORMs: SQLAlchemy, Prisma/Mongoose
Distributed database concepts (sharding — conceptual, revisited later)

Project: Full DB schema for a WhatsApp-like + Instagram-like app
Test: Quarter 2 test — after month 6 (end of week 26, 10 Jul 2027); cumulative, covers weeks 1–26 (months 1–6)

Phase 4

Full-Stack Web, Mobile & System Design

Weeks 30–41 · 12 weeks

Frontend

Advanced HTML/CSS: Flexbox, Grid, Tailwind, responsive design
React.js: components, hooks, state
State management (Redux/Zustand/Context)
TypeScript for React

Backend

Node.js + Express: REST APIs, middleware
Auth: JWT, OAuth2, sessions, bcrypt
WebSockets/Socket.io — real-time chat foundation
Media/file upload & storage (S3-compatible)
GraphQL basics
Microservices vs monolith; message queues intro (Kafka/RabbitMQ)

Mobile

React Native fundamentals; push notifications, offline storage

System Design

Load balancing, caching (CDN, Redis), horizontal/vertical scaling
Designing a news feed (fan-out on write/read)
Designing a chat system (delivery, read receipts, presence)
Designing scalable media storage

Math (parallel wraps up here, Weeks 30–41): linear algebra (vectors, matrices, eigenvalues, SVD), calculus (derivatives, gradients, chain rule), probability & statistics (distributions, Bayes, expectation/variance), optimization (gradient descent, Adam), information theory basics (entropy, cross-entropy, KL divergence)

Projects: Weeks 30–35: REST API + React app (auth, posts, likes, comments)
Weeks 36–38: Add real-time chat (Socket.io) — WhatsApp-lite
Weeks 39–41: Add feed/media upload — Instagram-lite; deploy mobile version
Test: Quarter 3 test — after month 9 (end of week 39, 9 Oct 2027); cumulative, covers weeks 1–39 (months 1–9)

Phase 5

Math for Machine Learning (parallel track)

Weeks 15–41 · 27 weeks · runs alongside Phases 2–4

Runs alongside Phases 2–4, two classes a week, so the maths is ready before machine learning starts.

Algebra, functions, set theory, logic (from Phase 0)
Discrete maths: combinatorics, graph theory basics
Linear algebra: vectors, matrices, eigenvalues, SVD
Calculus: derivatives, gradients, chain rule
Probability & statistics: distributions, Bayes, expectation/variance
Optimisation: gradient descent, Adam
Information theory: entropy, cross-entropy, KL divergence

Project: Worked problem sets applied in the Phase 6–7 ML projects

Phase 6

Data Science & Classical Machine Learning

Weeks 42–47 · 6 weeks

NumPy, Pandas, Matplotlib/Seaborn
Data cleaning, feature engineering, EDA
Supervised learning: linear/logistic regression, decision trees, random forests, SVM, KNN
Unsupervised learning: k-means, hierarchical clustering, PCA, DBSCAN
Ensembles: bagging, boosting (XGBoost, LightGBM)
Model evaluation: cross-validation, confusion matrix, precision/recall/F1, ROC-AUC
Hyperparameter tuning: grid/random/Bayesian search
scikit-learn pipelines; handling imbalanced data

Project: End-to-end Kaggle-style ML project with simple deployment

Phase 7

Deep Learning & Neural Networks

Weeks 48–53 · 6 weeks

ANN: forward pass, backprop from scratch (NumPy)
Activation functions, loss functions, optimizers
Regularization: dropout, batch norm, L1/L2, early stopping
PyTorch (primary) + TensorFlow/Keras basics
CNNs: architectures LeNet → ResNet
RNN, LSTM, GRU — sequence modeling
Autoencoders, GANs (conceptual + hands-on basics)
Transfer learning; training on GPUs, mixed precision basics

Project: CNN image classifier + LSTM text generator, trained from scratch
Test: Quarter 4 test — after month 12 (end of week 52, 8 Jan 2028); cumulative, covers weeks 1–52 (months 1–12)

Phase 8

NLP, Transformers & Building LLMs (Core)

Weeks 54–61 · 8 weeks

NLP fundamentals: tokenization, TF-IDF, embeddings (Word2Vec, GloVe)
Attention mechanism derivation; seq2seq
Transformer architecture from scratch: self-attention, multi-head attention, positional encoding, encoder-decoder, layer norm, residuals
Tokenizers in depth: BPE, WordPiece, SentencePiece — build a custom tokenizer
Build a GPT-style decoder-only LLM from scratch in PyTorch: embeddings → transformer blocks → output head, causal masking, training loop, cross-entropy loss, perplexity
Train a small LLM end-to-end on a custom dataset
BERT / encoder-only models (masked language modeling)
Fine-tuning with HuggingFace Transformers: classification, NER, summarization, Q&A
LoRA / QLoRA parameter-efficient fine-tuning
RAG: embeddings, vector DBs (FAISS/Chroma/Pinecone), building a RAG pipeline
Prompt engineering, chain-of-thought, AI agents/tool use (LangChain/LlamaIndex)
Evaluating LLMs: perplexity, BLEU/ROUGE, benchmarks

Project: Small GPT trained from scratch on a custom corpus; LoRA fine-tune of an open model (Llama/Mistral/Qwen family)

Phase 9

Advanced LLM Engineering (Research Level)

Weeks 62–69 · 8 weeks

This is the phase that closes the gap between "can build and train LLMs" and "could work on a frontier lab's pretraining/research team." It is intensive — expect these 8 weeks to demand the most self-practice hours in the whole program.

9.1 Large-Scale Data Engineering for Pretraining (Week 62)

Web-scale data collection (Common Crawl-style), deduplication (MinHash + LSH), quality filtering (heuristic + classifier-based), toxicity/PII filtering
Data mixing ratios, curriculum ordering; tokenizer training at scale
Build a full pipeline: raw data → clean → dedupe → filter → tokenize → shard

9.2 Distributed Training at Scale (Weeks 63–64)

DDP internals, gradient sync, communication overhead
FSDP and DeepSpeed ZeRO (stages 1/2/3) — sharding optimizer states/gradients/parameters
Tensor parallelism & pipeline parallelism (Megatron-LM style); 3D parallelism
Gradient checkpointing, mixed precision (fp16/bf16) at scale
NCCL basics, multi-node orchestration (Slurm/Kubernetes training jobs), checkpointing & fault tolerance for long runs

9.3 Scaling Laws & Compute-Optimal Training (Week 65)

Kaplan et al. and Chinchilla scaling laws
Compute-optimal trade-offs: model size vs. data size vs. compute budget
Estimating cost/time before committing a training run; designing an ablation plan

9.4 Modern Architecture Variants (Week 66)

RoPE, ALiBi (why they replaced sinusoidal encoding)
Grouped-Query Attention (GQA), Multi-Query Attention (MQA)
Sliding-window/sparse attention, long-context techniques
Mixture-of-Experts (MoE): routing, load balancing, sparse activation
Reading/implementing components from Llama, Mistral, DeepSeek, Qwen papers

9.5 Inference Optimization & Serving at Scale (Week 67)

KV-cache management; quantization: GPTQ, AWQ, GGUF/llama.cpp, int8/int4
Speculative decoding, continuous batching
Production serving: vLLM, TensorRT-LLM, TGI
Latency/throughput/cost-per-token trade-offs

9.6 Alignment & RLHF, Hands-On (Week 68)

SFT pipeline design and instruction-data curation
Reward model training: preference data, Bradley-Terry loss
PPO implementation for RLHF (hands-on)
DPO and modern alternatives — implementation
Red-teaming methodology, safety evaluation, constitutional AI concepts, guardrail design

9.7 Research Methodology (Week 69)

Reading and reproducing a research paper end-to-end
Designing and running ablation studies; rigorous experiment comparison
Writing a technical report on a training run/ablation
Keeping up with the field critically: key labs, papers, benchmarks

Project: Execute a full, faithful (small-scale) pretraining run — build the data pipeline, choose an architecture variant, run compute-optimal sizing analysis, train with a real distributed setup (2–8 GPUs), run an SFT + DPO alignment pass, then serve the model with an optimized inference stack. Written up as a technical report exactly as a research team would produce.
Test: Quarter 5 test — after month 15 (end of week 65, 8 Apr 2028); cumulative, covers weeks 1–65 (months 1–15)

Phase 10

Cloud, MLOps & Deployment

Weeks 70–73 · 4 weeks

Cloud fundamentals: AWS/GCP/Azure — compute, storage, IAM
Docker: containerization, Dockerfiles, docker-compose
Kubernetes basics: pods, deployments, services, scaling
CI/CD: GitHub Actions, automated testing/deployment
Model serving: FastAPI/Flask APIs, TorchServe, Triton
MLOps: experiment tracking (MLflow/W&B), model/data versioning (DVC)
Serverless functions, API gateways
Monitoring/logging (Prometheus/Grafana basics)
Cost optimization for AI workloads (GPU cost awareness, quantization for cost/inference)

Project: Deploy the Phase 8/9 LLM work + RAG chatbot with a CI/CD pipeline; containerize the full-stack app

Phase 11

Security — App, Network, Data & AI

Weeks 74–75 · 2 weeks

Application/Network Security

OWASP Top 10 and prevention (SQLi, XSS, CSRF, broken auth, etc.)
HTTPS/TLS, encryption basics, hashing vs encryption
Auth best practices, secure password storage, MFA
API security: rate limiting, API keys, CORS, input validation
Network security basics: firewalls, VPNs, DDoS awareness

Data Security & Privacy

Encryption at rest/in transit, secrets management
Privacy regulation awareness (GDPR, data minimization)
Secure database practices

AI/Model Security

Prompt injection attacks & defenses
Adversarial examples, model theft/extraction awareness
Data poisoning, bias & fairness in training data
Responsible AI: hallucination mitigation, safety layers, guardrails

Project: Security audit + hardening of their capstone systems (pen-test style checklist)

Phase 12

Final Combined Capstone & Demo Day

Weeks 76–78 · 3 weeks

AI Capstone (Research-Grade): The Phase 9 pretraining pipeline (data → distributed training → alignment → optimized serving), fully polished, documented, and demoed — plus a fine-tuned/RAG-enabled application layer on top with a simple UI.
Full-Stack Capstone: The real-time social/messaging app (feed + chat + notifications + media + auth) from Phase 4, deployed to cloud, containerized, and security-hardened — mobile version included.
A GitHub portfolio (clean, documented, reproducible)
A written system design doc including a "How this scales to production" section — describing exactly what changes (more GPUs, sharded DBs, CDN, load balancers, a larger team) to take the same design to real-world scale, proving the student already knows how and only needs the resources
A live demo day presentation

Project: Final combined capstone
Test: Quarter 6 test — after month 18 (end of week 78, 8 Jul 2028); cumulative, covers weeks 1–78 (months 1–18)

Quarterly tests

There's one test every 3 months, six in total. Each test is cumulative: test 1 covers months 1–3, test 2 covers months 1–6, and so on. The final test at month 18 is theory and practical. If you don't pass, you retake the test one week later. Each quarter also ends with a live project to submit.

Month 3 · Week 13

Test 1

10 Apr 2027

Covers months 1–3

Retest 17 Apr 2027
Month 6 · Week 26

Test 2

10 Jul 2027

Covers months 1–6

Retest 17 Jul 2027
Month 9 · Week 39

Test 3

9 Oct 2027

Covers months 1–9

Retest 16 Oct 2027
Month 12 · Week 52

Test 4

8 Jan 2028

Covers months 1–12

Retest 15 Jan 2028
Month 15 · Week 65

Test 5

8 Apr 2028

Covers months 1–15

Retest 15 Apr 2028
Month 18 · Week 78

Test 6 Final

8 Jul 2028

Covers months 1–18
Theory + practical

Retest 15 Jul 2028

A normal week

Each week has 7½ hours of live classes, a 2-hour live doubt session on Sunday, and project work on Saturday, plus your own practice time. Every class is recorded, and recordings, notes, assignments and project briefs are in your member dashboard.

Day	Time (IST)	What happens
Monday – Friday	9:00 PM – 10:30 PM IST	Live class (90 minutes)
Saturday	Self-paced	Assignments and live project work
Sunday	11:00 AM – 1:00 PM IST	Doubt-clearing and backup session

Languages and tools you'll use

Language / tool	What it's for
Python	The main language: machine learning, AI, backend, scripting, data science
SQL	Relational databases and querying
JavaScript / TypeScript	Frontend and backend (Node.js) for full-stack apps
HTML / CSS	Web page structure and styling
C++ (basics)	How memory and performance work, and what's under ML frameworks and CUDA
Bash / Linux shell	Dev environments, servers, automation, cluster job scripts
Git / GitHub	Version control and collaboration
Go or Rust (optional)	High-performance backend and systems work, for advanced members

What we trimmed to fit everything into 18 months

Fitting research-level LLM engineering (Phase 9) into 18 months meant running three phases leaner than a dedicated bootcamp would:

Data structures & algorithms: 10 weeks instead of 12. It still covers everything needed for interviews and real engineering work, with extra practice problems on Sundays.
Databases: 5 weeks instead of 6. SQL, NoSQL and Redis are fully covered. Sharding comes back in the system design and data-pipeline phases.
Full-stack: 12 weeks instead of 14. All the core skills are kept, with a little less polish time on the mobile app.

Book your seat

How to join in 4 steps

1 Create your account Sign up with your name, email and Indian mobile number.
2 Verify your email Enter the 6-digit code we email you.
3 Pay the membership fee Pay ₹5,999 for all 18 months securely with Razorpay (UPI, cards, net banking).
4 Join the first live class Classes start on 9 January 2027, Monday to Friday, 9:00–10:30 PM IST.

Book your seat

Questions

Questions about the curriculum

What does the Program Zero curriculum cover?

13 phases over 78 weeks: foundations, programming (Python and JavaScript), data structures and algorithms, databases, full-stack web and mobile development, maths for machine learning, data science and classical ML, deep learning, NLP and building LLMs, advanced LLM engineering, cloud and MLOps, security, and a final capstone.

Which programming languages will I learn?

Python (the main language for AI and backend), JavaScript and TypeScript (frontend and Node.js), SQL, HTML and CSS, basic C++ to understand performance, and the Bash shell. Go or Rust are optional for advanced members.

Will I really build a large language model?

Yes, at a small scale. In Phase 8 you build a GPT-style model from scratch in PyTorch and fine-tune an open model with LoRA. In Phase 9 you run a small distributed pretraining run with an SFT and DPO alignment pass, then serve the model. The maths and code are the same as large models; only the scale differs.

How is the maths taught if I am weak at it?

Maths for machine learning runs as a parallel track from week 15 to week 41, two classes a week, starting from algebra and building up to linear algebra, calculus, probability and optimisation before the machine learning phases begin.

How long is each class?

Each weekday live class is 90 minutes, from 9:00 PM to 10:30 PM IST. That is 7.5 hours of live classes a week, plus a 2-hour Sunday doubt session and Saturday project work.

What projects will I build?

A personal website, Python and JavaScript apps, a pathfinding visualiser, database schemas for chat and social apps, a React and Node app with real-time chat and a media feed, an end-to-end ML project, a CNN and LSTM, a small GPT and a LoRA fine-tune, a full small-scale pretraining run, a CI/CD deployment and two final capstones.

When are the tests?

Six cumulative tests, one every 3 months: 10 April 2027, 10 July 2027, 9 October 2027, 8 January 2028, 8 April 2028, 8 July 2028. A failed test can be retaken one week later.

Start with Phase 0 on 9 January 2027.

Live classes Mon–Fri, 9:00–10:30 PM IST · ₹5,999 for 18 months

Book Your Seat