The curriculum
Seven modules, 39 sections, 130 lessons, 6 capstones. Every lesson, every solution and progress tracking are free. Module 0 is free all the way through and has no exam and no capstone.
7 MODULES 39 SECTIONS 130 LESSONS 6 CAPSTONES
The modules are ordered and the order matters. The concept spine is continuous, so Module 4 assumes Module 3's vocabulary exactly. Take them out of order only if you already have the skills.
Module 0 - Foundations: The Machine, the Shell, and Git
3 sections, 11 lessons. Free in full. No exam and no capstone, it ends with its last lesson.
You will be able to drive a Linux machine from the command line and keep your work under version control.
| # | Section | Lessons | What it covers |
|---|---|---|---|
| 1 | The Machine and Where Things Live | 4 | How code runs as a process, memory versus storage, the filesystem tree, and how a path resolves from where you are standing |
| 2 | The Shell | 3 | Commands and the environment, redirection and pipes, then hosts, ports and local servers |
| 3 | Version Control with Git | 4 | Why a repository exists, reading history and undoing, branching and merging, then collaborating with remotes |
Module 1 - Python: From First Script to Objects
8 sections, 28 lessons. Capstone and exam: $29, or $14 at the half price.
You will be able to write, debug, structure and package real Python programs.
| # | Section | Lessons | What it covers |
|---|---|---|---|
| 1 | Python Foundations | 4 | Running Python, the core types, variables, operators and conversion |
| 2 | Control Flow | 4 | Conditionals and truthiness, the while loop and the accumulator pattern, the for loop and iterables, then break, continue and nesting |
| 3 | Functions | 4 | Defining and calling, arguments in depth, scope and side effects, then decomposition and composition |
| 4 | Collections | 4 | Lists, tuples, dictionaries and sets, then nesting, comprehensions and choosing the right one |
| 5 | Strings, Files, and Data Formats | 3 | String work, safe file reading and writing, and parsing comma separated values and JSON |
| 6 | Errors and Debugging | 3 | The three kinds of error and how to read a traceback, exception handling, then defensive code and systematic debugging |
| 7 | Modules, Packages, and Environments | 3 | Imports, the standard library and entry points, then packages, pip and virtual environments |
| 8 | Object-Oriented Programming | 3 | Classes and methods, instance versus class data and encapsulation, then inheritance, overriding and composition |
Capstone: The Run Registry. Your own leaderboard of training runs, built from nothing but the standard library, the modules that ship with Python itself.
Module 2 - Data: Queries, Arrays, and the Clean Table
7 sections, 25 lessons. Capstone and exam: $29, or $14 at the half price.
You will be able to query a database down to a table that fits in memory, compute over it, and find and fix everything wrong with it.
| # | Section | Lessons | What it covers |
|---|---|---|---|
| 1 | SQL, Reading and Shaping Data | 3 | SQLite and a first query with filtering and ordering, joins, then aggregation with GROUP BY and CTEs |
| 2 | NumPy, The Array | 5 | Installing NumPy and the ndarray, indexing and boolean masking, vectorized operations, broadcasting, then aggregation and the axis argument |
| 3 | Linear Algebra, Computed | 5 | Vectors and the dot product, matrices and matrix multiplication, distance and norms, projection and least squares, then rank and collinear columns |
| 4 | pandas, Series and DataFrame | 3 | Installing pandas and the two objects, selection and assignment, then reading and writing data including from a query |
| 5 | Data Cleaning | 4 | Missing data, types and conversion, categorical and string and datetime data, then duplicates, tidy structure and outliers |
| 6 | Transformation and Aggregation | 3 | Element-wise transformation, GroupBy with the MultiIndex and reshaping, then combining datasets |
| 7 | Describing and Visualizing Data | 2 | Center, spread, shape and correlation, then matplotlib and seaborn |
Capstone: The Dataset Autopsy. A database of scraped listings pulled out by query, cleaned into one row per listing, written back into a table that refuses a bad value, then reconciled against the database neighborhood by neighborhood until every count that differs has its reason.
Module 3 - Classical ML: Why It Works, and Why the Score Lies
8 sections, 23 lessons. Capstone and exam: $39, or $19 at the half price.
You will be able to fit a model to a table, score it on rows it never saw, and prove whether that score is real.
| # | Section | Lessons | What it covers |
|---|---|---|---|
| 1 | What a Model Is, and What Fitting Means | 4 | Installing scikit-learn, the split and what a held-out set is for, loss functions, then regression metrics and residuals |
| 2 | Feeding a Model Honest Data | 3 | Scaling and the transformer API, encoding categorical features, then pipelines and leakage-safe imputation |
| 3 | Feature Engineering | 2 | What makes a feature good and building features from the columns you have, then selection and why more is not better |
| 4 | Classification, and the Cost of Being Wrong | 3 | Logistic regression and the probability it returns, the confusion matrix and choosing a metric, then thresholds, class weights and imbalance |
| 5 | Why One Model Is Not Enough | 3 | Decision trees and why they overfit, random forests and why averaging works, then gradient boosting |
| 6 | Trusting Your Numbers | 3 | Bias, variance, capacity and learning curves, cross-validation, then hyperparameter search |
| 7 | Is the Result Real? | 2 | Sampling, confidence intervals and hypothesis testing, then offline gains against online reality |
| 8 | Structure Without a Target | 3 | k-means clustering, eigenvectors and what PCA is doing, then judging an unsupervised result |
Capstone: The Leakage Hunt. You follow your team's recipe to results that look excellent, and must find why they are wrong.
Module 4 - Deep Learning Foundations: PyTorch From the Tensor Up
5 sections, 17 lessons. Capstone and exam: $49, or $24 at the half price.
You will be able to build and train a neural network in PyTorch, having written its training loop by hand first and checked every piece of it against a number you computed yourself.
| # | Section | Lessons | What it covers |
|---|---|---|---|
| 1 | Tensors and the Derivative | 4 | Installing PyTorch and the tensor, tensor operations and the device pattern, derivatives by hand, then autograd checked against them |
| 2 | The Training Loop, Built by Hand | 3 | One neuron fitted by hand, the honest refactor into the framework, then train and validation discipline with the loss curve |
| 3 | Real Networks, MLPs and Classification | 4 | From neuron to network, classification with logits and cross-entropy, mini-batching, then optimizer choice and the learning-rate sweep |
| 4 | Regularization and the Playbook | 3 | Overfitting on purpose with capacity and weight decay, dropout and early stopping, then saving and loading models |
| 5 | The Image Bridge, FashionMNIST | 3 | Image tensors, training a fully connected network on images, then where that approach fails and why convolution exists |
Capstone: The Overfit Journal. Deliberately overfit a model, then document with evidence what each regularization tool actually did to it, and close with a recommendation that weighs cost against quality.
Every lab in this module runs on a normal laptop processor in minutes. A graphics card is never required, here or anywhere else in the bootcamp.
Module 5 - Modern Architectures and Transfer Learning
4 sections, 13 lessons. Capstone and exam: $49, or $24 at the half price.
You will be able to build a CNN (convolutional neural network) and a transformer from their parts, and fine-tune pretrained models on your own data.
| # | Section | Lessons | What it covers |
|---|---|---|---|
| 1 | Convolutional Networks, Keeping the Structure | 4 | The convolution, pooling and the conv block, building a CNN that beats your previous model, then data augmentation |
| 2 | Transfer Learning, Vision | 3 | Pretrained models and their weights interface, freezing and fine-tuning, then unfreezing, careful learning rates and error analysis |
| 3 | Attention and the Transformer | 3 | Text as tensors, self-attention built from matrix multiplications, then the transformer block |
| 4 | Text Transfer Learning and the Architecture Map | 3 | Loading a pretrained encoder, fine-tuning it with your own loop, then the architecture map and the boundary |
Capstone: The Fine-Tune Ladder. Climbing from a frozen backbone to a carefully unfrozen one, with error analysis at every rung.
This module's boundary, stated openly: architecture is in, application is out. You build and understand transformers here. Prompting, retrieval and agent systems belong to a separate AI Engineering product and are deliberately absent.
Module 6 - MLOps: From Script to Monitored Service
4 sections, 13 lessons. Capstone and exam: $59, or $29 at the half price.
You will be able to turn a trained model into a tested, containerized, deployed and monitored service.
| # | Section | Lessons | What it covers |
|---|---|---|---|
| 1 | Project Discipline and Testing | 3 | From script to project, pytest, then testing machine learning systems specifically |
| 2 | Experiment Tracking and Serving | 4 | Tracking experiments, logging and loading models, the first endpoint, then the full prediction service |
| 3 | Containers, Databases and Pipelines | 4 | Images and containers, a real database behind the service, containers done right, then automated pipelines |
| 4 | Monitoring and the Closing Loop | 2 | Logging predictions and service health, then data drift and the retraining loop |
Final project: Ship It and Watch It Rot. A complete deployed service that you then deliberately feed drifting data until the monitoring catches it.
This is the end of the bootcamp, not just the end of a module. It is the largest thing you build here and the only one that ends with something running and being watched.
The guaranteed path is a local container plus an automated pipeline. No cloud account is required at any point.
The concepts carry forward. The projects do not: every capstone starts from an empty directory and builds its own state, so nothing you skipped changes where the next one begins.