Curated reference set
Finish the primary source selectively, implement the exercises, build the stage project, and reach for a secondary source only for a demonstrated gap. Completion is tracked for convenience and contributes 0% to progress.
MIT · (optional)
The shell, editors and developer tooling a CS degree assumes you picked up somewhere. Optional here: take the shell lectures if the terminal still feels foreign after the practice, and leave the rest.
Microsoft · (unlabeled)
Reference for the editor itself — the integrated terminal, workspace folders and settings. Look things up as you need them; there is nothing here to work through.
Harvard · Primary
The teaching path for this stage, assuming no prior programming. Follow it in order and do the problem sets before the drills, which are the same material at a different angle.
Python Software Foundation · Reference
The official language tutorial. Use it to check exactly how a construct behaves rather than as a course — it assumes some prior programming, which is why it is a reference here and not the teaching path.
The official Python Tutorial assumes some prior programming knowledge, so use it as reference while CS50P provides the beginner teaching path.
git-scm.com · Primary/reference
The book that explains what Git is doing, not only which command to type. Chapters 1 to 3 cover this stage; read the branching chapter before the branching practice, not after it.
PostgreSQL · Primary
The official tutorial, worked in a real database rather than a browser sandbox. Do it against your own schema so the queries return data you can verify by hand.
FastAPI · Primary
The framework tutorial, in order, from first app to dependencies and testing. Build it against the database you designed in Stage 3 rather than the tutorial's toy data.
Khan Academy · Foundation
Algebra, functions, exponents and logarithms at whatever level you actually need. Use the practice exercises; watching the videos without doing them is the failure mode this stage exists to prevent.
Khan Academy · Statistics
Probability, distributions, sampling and correlation, with exercises. The conditional-probability and base-rate material is the part that decides whether later metrics mean anything to you.
Khan Academy · Linear algebra
Vectors, matrices, dot products and transformations. Work the vector and matrix-multiplication exercises by hand — shape intuition built here is what makes Stage 9 debuggable.
DeepLearning.AI · Structured ML-focused option
An optional structured course covering the same four subjects as one sequence. Take it instead of the Khan Academy path if you prefer a single guided track, not in addition to it.
Google · Primary
The teaching path for classical ML: framing, splitting, models, preprocessing and evaluation, with interactive exercises. Work it alongside your own dataset rather than only its examples.
scikit-learn · Library reference
The library you will implement in, plus a user guide that explains the methods behind it. The pipeline and model-evaluation sections are the ones that prevent leakage rather than merely describing it.
Two source links: Stage 8 links getting_started.html, the resource library links user_guide.html. Both preserved.
DeepLearning.AI · Optional structured course
An optional longer course covering this stage's material with more mathematical depth. Choose it over the crash course if you want the derivations; do not run both in parallel.
PyTorch · Primary
The official beginner path from tensors to a full training loop. Type the training loop rather than copying it — reproducing it from memory is this stage's gate.
Hugging Face · Primary
The teaching path for this stage: tokenization, attention, transformer internals and the library that exposes them. Chapters 1 to 3 cover what the gate asks you to explain.
Google · Secondary
A short, conceptual account of language models and how they are trained. Useful as a second explanation of tokens, context and fine-tuning when the primary course moves quickly.
Hugging Face · Optional agent resource
An optional course on tool use and agent loops. Take it only after your deterministic workflow works and you can show why agency was required — 24_SCOPE_CONTROL.md is explicit that frameworks come after the fundamentals.
Only after LLM + evaluation foundations.
Made With ML · Primary
The teaching path for production ML: packaging, lifecycle, serving, CI/CD and monitoring as one connected system. Apply each section to the model you already trained rather than to its example project.
Google · Secondary
Short reference chapters on production ML systems, including serving, pipelines and monitoring. Read it for the failure modes it names, then check which of them your own deployment would actually catch.
GCFGlobal
Plain-language coverage of hardware, the operating system and how files are organised, written for someone starting from nothing. Use it for the vocabulary, then move to the terminal material.
Python Packaging Authority
What a package manager does and why each project gets its own virtual environment, from the people who maintain both. Read the tutorial for the why and the venv page for the mechanics.
MDN
Client, server, addresses and what a URL is made of, at the level of intuition this stage asks for. Stage 4 supplies the protocol detail; stopping here is deliberate.
Software Carpentry
A structured, exercise-driven shell course built for people who have never used a terminal. Covers exactly the commands Stage 0 lists.
Ubuntu
A single-sitting walkthrough of navigation, paths and file manipulation. Good as a second pass if the shell still feels foreign.
explainshell.com
Paste any command and it breaks down every flag. Use it instead of copying a command you do not understand — which is the habit Stage 0's gate tests.
git-scm.com
The official introduction to the eight commands Stage 1 actually uses, and nothing beyond them. Pro Git is the Stage 2 resource; this is the smaller reference for saving and publishing work while you are still learning Python.
Al Sweigart
Free full text, strongest on files, CSV and JSON — the exact material behind the Expense CLI. Use it as a second explanation when CS50P moves too fast.
pytest
The reference for the testing tool the stage requires. Read 'Get Started' and 'How-to guides'; skip the plugin ecosystem entirely for now.
Python Software Foundation
The conventions every Python codebase assumes. Relevant the moment your code is read by someone else — which Stage 2 makes real.
Python Software Foundation
Check here before installing anything. The source's framework rule is to prefer the standard library while it is educationally useful.
learngitbranching.js.org
An interactive visualiser for branches and merges. The fastest way to build the mental model Pro Git describes in prose.
GitHub
Covers the remote half of Git, which Pro Git treats more abstractly. Needed from Week 1 since the roadmap requires a single learning repository.
conventionalcommits.org
A commit-message convention that makes the changelog required by the Stage 2 project mechanical rather than manual.
PyPA
The authority on `pyproject.toml` and dependency declaration, both required by the Stage 2 project.
PostgreSQL
The reference for the modelling half of this stage: column types, constraints, keys and what each one actually enforces. Read it while designing the schema, not after the first bad row.
pgexercises.com
Graded exercises against a real schema, with answers hidden until you attempt. Structurally the closest thing to the source's exercise-first rule.
sqlbolt.com
Short interactive lessons from SELECT through joins. Useful as a first pass before the PostgreSQL tutorial's density.
Markus Winand
Explains what an index actually does and when it fails to help. Directly supports the Stage 3 requirement to index one justified query.
postgresqltutorial.com
Worked examples for schema design, constraints and psql operation, which the official tutorial covers only briefly.
rezapirighadim/interview
Normalization through BCNF, what a B-tree index costs on writes, and how to read EXPLAIN ANALYZE — then window functions, recursive CTEs and isolation levels. Read the indexing file when the stage asks you to justify one index on one query.
The stage's PRIMARY, the PostgreSQL tutorial, never covers query plans or composite-index ordering. This fills that gap; it is not a second SQL course.
Python Software Foundation
How to replace prints with real logging: levels, formatting, and where output goes. The cookbook covers attaching request context, which is what makes a deployed failure findable.
MDN Web Docs
The practical reference for methods, status codes and headers. The source's framework rule is to learn HTTP before framework magic — this is that material.
Pydantic
FastAPI's validation layer, and the thing doing the work when a request is rejected. Also reappears for structured LLM output in Stage 11.
IETF
The specification itself. Consult for a precise answer on method semantics or idempotency; do not read end to end.
OpenAPI Initiative
What FastAPI generates on your behalf. Reading it turns the generated docs from output into a design surface.
Virginia Tech
A complete open textbook with interactive visualisations, covering every structure and algorithm Stage 5 requires you to implement.
Stage 5 has no primary resource in the canonical library. This is the closest complete substitute.
visualgo.net
Step-by-step animations of sorting, traversal, BFS and DFS. Use it to check your mental model after implementing, not before.
bigocheatsheet.com
A one-page comparison of operation costs across structures. Useful for checking the complexity claims your gate requires you to defend.
Python Software Foundation
What Python's built-ins actually guarantee. Read after implementing your own, to see which trade-offs the standard library already made.
neetcode.io
A structured problem sequence. Use sparingly — Stage 5 explicitly warns against becoming a LeetCode specialist.
Bounded by the stage's own interview constraint: use problems to reinforce decomposition and complexity, not as the goal.
scikit-learn
The canonical account of how preprocessing leaks information and why transformations must be fitted after splitting. Read it now for the habits; Stage 8 is where you apply them to a model.
NumPy
Arrays, shapes and vectorised operations from zero. The shape intuition built here is what makes Stage 9's tensor work tractable.
Stage 6 has no primary resource in the canonical library.
pandas
The reference for indexing, grouping, joining and datetime handling. Start with '10 minutes to pandas', then use the guide by topic.
Wes McKinney
Free full text by pandas' author. The data-cleaning and wrangling chapters map directly onto the Stage 6 project deliverables.
matplotlib
Enough plotting to produce the visualisations the stage project requires, without adopting a second plotting library.
Project Jupyter
Notebook mechanics, including execution order — the thing that makes notebook results irreproducible if you ignore it.
UCI · Kaggle · Our World in Data
Where to find the public dataset the Stage 6 project requires. Prefer one messy enough to need real cleaning.
pandas
The reference for reading CSV and JSON with explicit dtypes and parsers, and for the missing-data semantics every validation check depends on.
Requests
Enough HTTP client to pull a dataset from an API, including status handling. You already learned the protocol in Stage 4; this is only the client.
Made With ML
The ETL/ELT, pipeline-stage and lineage sections of a course you will return to in Stage 12. Read only the data-engineering chapter here; the deployment material is Stage 12's.
Scoped read. The rest of this course belongs to Stage 12 and would be premature now.
Pandera
One example of expressing a DataFrame schema declaratively. Write your checks as plain assertions first — this stage never requires a validation framework.
Optional example only. Adopting it before you have hand-written the checks inverts the framework rule in 24_SCOPE_CONTROL.md.
Great Expectations
A larger data-quality framework, listed so you know the category exists. Skim the concepts; do not add it as a project dependency at this stage.
Optional example only, never a required dependency.
Deisenroth, Faisal & Ong
Free textbook covering exactly the ML-relevant subset of the maths. Denser than Khan Academy; use it to go deeper on one topic, not as the main path.
3Blue1Brown
Builds the geometric intuition behind matrix multiplication and transformations, which the gate requires you to explain.
Brown University
Interactive visualisations of probability and sampling. Particularly good for conditional probability, where intuition usually fails.
43 rules from production practice, starting with 'do not use ML if you do not have to' and 'make your first model simple'. Directly reinforces the baseline discipline.
scikit-learn
The canonical writeup of data leakage through preprocessing, with code. Read before building the Stage 8 pipeline, not after.
scikit-learn
Covers grouped and time-series splitting, which is where a naive random split leaks without any obvious symptom.
Google MLCC
Worked treatment of threshold choice and the precision/recall trade-off — the material behind the gate's demand that you reject a bad metric.
Christoph Molnar
Free textbook on explaining model behaviour. Useful for the slice and error analysis the Stage 8 project requires.
Daniel Bourke
Code-first course that writes training loops out longhand — matching the gate's requirement that you recreate one without copying.
Andrej Karpathy
Builds autograd and then a transformer from scratch. The single best antidote to explaining transformers as 'magic', which Stage 10's gate forbids.
d2l.ai
Interactive textbook with runnable PyTorch. Use for depth on a specific architecture, not as a parallel course.
PyTorch
What you must control to make a training run repeatable, and what stays nondeterministic anyway. Required for a credible experiment log.
TensorFlow
Works with PyTorch and renders the learning curves the Stage 9 project requires. A plotted curve you read is enough — the tool is optional.
Jay Alammar
The clearest visual explanation of query/key/value and multi-head attention. Read alongside the HF course chapter on attention.
Hugging Face
Reference for loading models and tokenizers directly rather than through a pipeline — which the stage explicitly asks you to do.
Hugging Face
The two libraries the stage names alongside Transformers. Inspecting real token boundaries explains a surprising share of model failures.
Vaswani et al., 2017
The original paper. The roadmap targets paper-reading capability, and this is the right first paper to read properly.
DAIR.AI
Techniques catalogue for treating prompts as program inputs. Use the structured-output and tool-calling sections; skip the certification-adjacent material.
Lewis et al., 2020
The paper that named RAG. Worth reading to see how modest the original claim was compared to current usage.
Weaviate
How lexical and vector retrieval combine, and why the hybrid usually wins. Supports the stage's hybrid/reranking experiment.
Chroma
One small vector store, sufficient for the stage project. Scope control bars vector databases before Stage 8 and warns against collecting five of them.
Deliberately the only vector store listed. Learn retrieval metrics before adopting infrastructure.
Exploding Gradients
Metrics for evaluating retrieval and generation separately. Build your own eval set first — the stage requires that before optimisation.
Docker
Containers from zero, plus FastAPI's own deployment guide for the exact service you are packaging.
Bound to Stage 4, where containers are first taught, and reused in Stage 12 for ML packaging.
12factor.net
Where the rule that configuration comes from the environment originates. Short, and it settles most config-versus-secret arguments. Its logs, disposability and dev/prod-parity factors are the deployment half of this stage.
MLflow
Concrete implementations of experiment tracking and model registry, which the stage covers conceptually.
GitHub
The CI system this roadmap uses. Stage 4 needs only install, lint and test; Stage 12 adds data and model checks.
Martin Fowler
Why ML deployment differs from software deployment, plus Google's maturity levels. Read both before designing your pipeline.
Read the monitoring and incident chapters only. They are the source of the 'wrong at 3 AM' framing this stage's gate uses.
Evidently AI
Practical guides to data and prediction drift detection, which the stage lists but does not explain.
OWASP
The reference list of AI-specific risks, matching this stage's topics almost one to one. The strongest starting point for the required threat model.
Stage 13 has no primary resource in the canonical library.
OWASP
Covers the non-AI half of the attack surface — broken authorization is still the most common real-world failure.
OWASP
Short, specific guidance on authentication, secrets management and audit logging — all required by the stage project.
NIST
A structured vocabulary for describing residual risk and who accepted it, which the gate requires you to state.
MITRE
A catalogue of real attack techniques against ML systems. Use it to source the five attacks the gate requires you to demonstrate.
OpenAI
The current official documentation for defining eval datasets and graders, and for running an eval as a repeatable job. Read it for the vocabulary — datasets, graders, runs — then implement the same shape yourself.
Provider-specific documentation for a provider-independent idea. The concepts this stage requires — eval sets, graders, component vs end-to-end evals, regression evals — must be implementable without any vendor.
Anthropic
How to design task-specific evals, choose between code, human and model graders, and where LLM-as-judge stops being trustworthy. Vendor-neutral in substance.
OpenAI
A historical open-source eval harness. Kept only as a structural example of separating component and end-to-end evals; it is no longer the modern OpenAI eval reference.
Historical. Prefer the current evaluation documentation for anything you intend to build.
OpenTelemetry
A vendor-neutral field vocabulary for tracing LLM calls: prompts, tokens, latency, errors. Use it to shape your own trace schema instead of adopting a tracing product.
Deliberately vendor-neutral. No LangSmith or hosted tracing platform is required at any stage.
Sculley et al., Google
The paper showing that model code is a small fraction of a real ML system. Directly informs the capstone's architecture and trade-off documentation.
Stage 14 has no primary resource in the canonical library — by design, since it is a synthesis stage.
Eugene Yan
Curated industry write-ups of real deployed systems. Use them as reference architectures when justifying your capstone's design.
Eugene Yan
Essays on design and evaluation decisions, useful for building the interview narrative the stage requires.
Harvard (mlsysbook.ai)
Free textbook on end-to-end ML systems engineering. Useful for the architecture-document and system-design portions of the final gate.