DS
Researched across the 2025-2026 DS job market, MIT & Stanford curricula & hiring data

Become an industry-ready data scientist - in 15, 30, or 60 days.

Three calibrated plans, one engine. Four parallel tracks - learn, build, drill, hunt - and every flagship course from MIT OpenCourseWare and Stanford to the modern industry stack, mapped day by day.

Choose your plan

15-Day · Job-Ready Sprint. For the strong builder who needs to convert capability into offers - fast. Advanced ML/quant practitioner. Interview-and-portfolio focused.

Start the 15-Day planBrowse the curriculum
15
day sprint
4
parallel tracks
4
deployed projects
70+
curated resources
How it works

Four tracks, every single day

Don't run these sequentially. By the first week you should be learning, building a portfolio piece, drilling interview problems, and polishing job-hunt assets at the same time. Each day ends with a concrete verification check.

L
Learn

Fill the specific weakest-link gap of the day.

B
Build

Ship deployed, documented portfolio projects.

D
Drill

Daily SQL + spaced ML-theory reps; design & behavioral later.

H
Hunt

Resume, LinkedIn, GitHub, referral outreach.

V
Verify

A concrete artifact or passing check ends every day.

The target

Know exactly what 2026 hiring screens for

The DS role is non-standardized; interview loops follow the archetype, not the title. Pick your primary - it decides which days you weight - then track the skills.

Product / Analytics DS

days 1, 2, 6, 13

SQL + A/B testing + product/metrics sense + stats. Light DSA.

ML / Algorithms DS & MLE

days 3, 5, 7, 12

ML theory breadth + ML system design + medium coding.

GenAI / Applied Scientist

days 8, 9, 10, 12

LLM apps, RAG, eval, fine-tuning + ML fundamentals.

Generalist / startup DS

days balanced + 13

Everything + a take-home assignment.

The job-ready skill checklist

tap to check off - saved in your browser

Non-negotiable core

Differentiators (capture the AI pay premium)

Proof artifacts (weighted above certificates)

The 15-Day plan

Job-Ready Sprint

Each day has a focus, a skip-if calibration, and per-track actions ending in a verification check. Switch plans anytime - progress is saved separately for each.

Foundations Audit & Core Refresh

Days 1-3

Set the target, build the tracker, and lock the #1 screened skills: SQL, statistics, experimentation, and classical-ML breadth.

1

Orientation, self-assessment, SQL ignition

Set the target, build the tracker, start the highest-ROI interview skill (SQL).

LearnBuildDrillHunt
Skip if

Never - even strong people skip the self-assessment and lose a week aiming wrong.

Learn
  • Read the job-ready target. Pick your archetype (Product/Analytics, ML/Algorithms, GenAI/Applied, or Generalist). Write a target list of 10-15 product/AI-native companies.
  • Self-audit honestly against the skill checklist, rating each 1-5. Your scores under 3 are where the 15 days go.
  • Set up the modern Python toolchain you will use all sprint: uv (docs) + ruff (docs) - one tool replaces pip/venv/poetry/black/flake8. (2026 setup guide)
Build
  • Create a GitHub repo ds-sprint-2026 with a README plan + daily log. This IS your commit-history artifact - multi-month meaningful commits are a hiring signal.
  • Create the special username/username profile README stub (finish it Day 14).
Drill
Hunt
  • Compile the target-company list; find the hiring manager or a DS team member for 3 of them (you reach out Day 15).
Verify

Archetype chosen + 10-company list written; uv+ruff working (uv init && uv add pandas && ruff check); 5 SQL problems solved; skill self-audit scored.

2

Statistics & experimentation

Inferential stats + A/B testing - the single most-tested and most-rising analytical area.

LearnBuildDrill
Skip if

You can already design an experiment with power/MDE/guardrails and explain CUPED, SRM, and peeking - then go straight to the A/B build and add causal inference depth.

Learn
  • A/B testing (do this even if strong): Udacity Intro to A/B Testing by Google (free). Then skim the canonical reference *Trustworthy Online Controlled Experiments* (Kohavi) via experimentguide.com - guardrails, novelty/primacy, sequential testing.
  • Stats refresher as needed: StatQuest for any weak concept (p-values, distributions, CLT). Deeper: *Practical Statistics for Data Scientists* (O'Reilly).
  • Causal inference primer: correlation is not causation, DiD, propensity scoring - Causal Inference for the Brave and True (best free hands-on).
Build
  • Project A2 - end-to-end A/B test analysis (start). Hypothesis to MDE to sample-size calc to randomization to primary/secondary metrics to guardrails to result with confidence intervals. Tools: Python (scipy, pandas), Jupyter. Demonstrates the experimentation rigor product teams screen for.
Drill
Verify

You can state from memory how to size an A/B test and three ways it goes wrong (SRM, peeking, novelty); A/B scaffold committed with hypothesis + power calc; 8 stats Qs + 3 SQL done.

3

Classical ML breadth, feature engineering, evaluation

The explain-X / when-do-you-use-X breadth that ML rounds test + the evaluation discipline.

LearnBuildDrill
Skip if

You can cleanly explain bias-variance, L1 vs L2, ROC-AUC vs PR-AUC, and why GBDTs beat NNs on tabular data - then spend the day on the classical-ML build + ML-theory drilling.

Learn
Build
  • Project B1 - productionized churn prediction (start). Telco Churn (Kaggle) or synthetic; scikit-learn/XGBoost. Differentiators: probability calibration, cost-sensitive thresholding, SHAP explanation, and (Day 5) a deployed scoring endpoint.
Drill
Verify

You can whiteboard bias-variance and L1-vs-L2 in 2 min each; churn model trains + reports calibrated probabilities + SHAP plot, committed; 10 ML Qs + 3 SQL done.

Production & Modern Stack

Days 4-7

The biggest Kaggle-only to job-ready gap. SWE hygiene, MLOps, deployment, the modern data stack, and storytelling.

4

Software engineering hygiene for DS

Git/PRs, testing, type hints, project structure, packaging - the discipline that signals you ship real code.

LearnBuildDrill
Skip if

You already write tested, typed, modular, packaged Python with CI - accelerate to Day 5 and spend the time on the MLOps build.

Learn
  • Book purpose-built for this gap: *Software Engineering for Data Scientists: From Notebooks to Scalable Systems* (Catherine Nelson, O'Reilly).
  • Hands-on: Khuyen Tran - Reproducible Data Science (pytest, project structure, pre-commit).
  • Lock these: git branches/PRs/review; pytest + data validation; pydantic runtime types; mypy/pyright; modules over notebooks (data/ notebooks/ src/); uv envs; ruff + pre-commit.
Build
  • Refactor the churn project (B1) out of the notebook: src/ modules, pyproject.toml, 2+ pytest tests (preprocessing + a model-output assertion), type hints, ruff-clean, and a GitHub Actions CI workflow running the tests. The refactor itself is a portfolio signal.
Drill
  • Coding/DSA start - NeetCode 150 patterns: arrays, hash maps, two pointers, sliding window. Do 4. For product DS, also 2 pandas tasks (groupby/merge/pivot). + 2 SQL.
Verify

Churn repo has passing pytest, green CI badge, clean ruff check, type hints; 4 NeetCode + 2 SQL done.

5

MLOps: tracking, serving, containers, cloud

MLflow + Docker + FastAPI + one cloud. The biggest hiring gap = your biggest differentiator.

LearnBuildDrillHunt
Skip if

You have already shipped a tracked, containerized, served model on a cloud - otherwise do it end-to-end for an industry-DS framing.

Learn
  • Best project-based free course: MLOps Zoomcamp - DataTalks.Club. Gentlest on-ramp: Made With ML.
  • The system-design mental model: *Designing Machine Learning Systems* (Chip Huyen) - the single best production-ML book.
  • Lock: MLflow tracking + registry; Docker (a baseline expectation now); FastAPI to wrap a model as REST; one cloud ML service (SageMaker / Vertex AI / Azure ML) - go deep on ONE.
Build
  • Deploy the churn model end-to-end: train to track in MLflow to Dockerize to serve via FastAPI to a public endpoint (Railway ~$5/mo or GCP Cloud Run free tier). Report p50/p95 latency. B1 is now a deployed, live-URL project - the highest-signal portfolio item.
Drill
  • 4 NeetCode (sorting/searching, heaps, basic trees) + 2 SQL.
Hunt
  • Pick your one cloud cert target (best ROI: GCP Professional ML Engineer; alts AWS ML Specialty, Azure DP-100). Schedule it AFTER the sprint - do not cert-stack now.
Verify

curl your live FastAPI endpoint and get a prediction; MLflow UI shows tracked runs; README has live URL + latency; 4 NeetCode + 2 SQL done.

6

Modern data stack + storytelling

Warehouse SQL, dbt, orchestration awareness + the storytelling skill that gates promotions (#2 hiring skill).

LearnBuildDrill
Skip if

Data-stack only: you know dbt models/tests and can read an Airflow/Dagster DAG. Do NOT skip storytelling - the most common quant-to-DS gap.

Learn
  • Modern data stack (recognize + lightly use): query a warehouse (Snowflake/BigQuery/Databricks), read/edit dbt models (refs, sources, tests), recognize Airflow/Dagster/Prefect DAGs. Free: dbt Learn. DS footprint = fluent SQL + read dbt/DAGs, not own the pipeline.
  • Storytelling (high-leverage half): *Storytelling with Data* (Knaflic) - site. One chart = one message; lead with the decision; tailor depth to the stakeholder.
  • One BI tool: Tableau (Tableau Public is free for portfolios) or Power BI (enterprise default).
Build
  • Project A1 - SQL + dashboard business analysis (start). Real dataset to SQL transforms to a Tableau/Power BI/Looker Studio dashboard to a one-page written insight memo with a recommendation (the so-what memo is the differentiator, not the charts).
Drill
  • SQL hard - CTE+window combos, cohort/retention, top-N-per-group, gaps-and-islands (StrataScratch). Do 4. (~40% of hard SQL questions combine CTEs + windows.)
Verify

A published dashboard (Tableau Public link) + a written recommendation memo; you can explain one dbt model and what dbt test does; 4 hard SQL done.

7

Deep learning refresh + Build/Catch-up

PyTorch-level DL fluency (for ML/GenAI archetypes) OR catch-up + portfolio polish.

LearnBuildDrill
Skip if

You are deep in DL already (transformers/QLoRA) - use the whole day to finish A1/A2/B1 to deployed + documented and get ahead on the GenAI phase.

Learn
  • PyTorch is the 2026 default (~85%+ of research, most HF uploads, frontier LLM training). TF/Keras is legacy-maintenance.
  • Best deep understanding: Karpathy - Neural Networks: Zero to Hero (backprop to makemore to GPT from scratch in PyTorch). Fastest results: fast.ai. Reference: d2l.ai.
Build
  • Catch-up checkpoint. By end of today have THREE projects in flight: A2 (A/B test), B1 (deployed churn w/ MLOps), A1 (dashboard+memo) - each at runs + README + committed. If ahead, start the Day-9 RAG-with-eval marquee early.
Drill
  • 5 mixed (2 SQL, 1 NeetCode, 2 ML-theory spaced-repetition of earlier misses).
Verify

Three projects each have runnable code, a Problem-Approach-Result-Impact README, and a commit history showing iteration. This is your minimum viable portfolio.

The 2026 GenAI / LLM Layer

Days 8-10

Two-plus AI skills = +43% pay. LLM fundamentals, prompt/structured output, RAG, agents/MCP, and evaluation - the hottest hire signal.

8

LLM fundamentals + prompt engineering + structured output

Working-level transformer/embedding understanding + the reliability ladder for structured output.

LearnBuildDrill
Skip if

You understand attention/tokenization/embeddings - go straight to structured output + model-selection-as-a-skill, which many strong people under-rate.

Learn
  • Fundamentals (skim if known): Illustrated Transformer | 3Blue1Brown Transformers.
  • Model landscape as a skill (2026): no model wins everything - choosing per task is the skill. Claude Opus 4.8 leads coding + intelligence index; GPT-5.x leads creative/structured reasoning; Gemini 3 leads multimodal; open-weights (DeepSeek V3.2, Qwen 3.5, Llama 4) near-frontier at a fraction of cost. Track via Artificial Analysis.
  • Structured-output reliability ladder: L1 prompt-only JSON (80-95%) < L2 function/tool calling (95-99%) < L3 native structured output via JSON Schema (~100%). Always validate with Pydantic/Zod. Refs: Anthropic + OpenAI prompting + DeepLearning.AI Functions, Tools & Agents.
Build
  • A small LLM extraction utility: messy text to a Pydantic-validated structured object via tool calling. A building block for Day 9's RAG and proof of production-grade LLM hygiene.
Drill
  • 3 SQL + 5 ML-theory (now adding transformer/LLM-basics questions - increasingly in 2026 loops).
Verify

Your extraction utility returns 100% schema-valid output across 10 test inputs (Pydantic never raises); you can name which model you'd pick for coding vs multimodal vs cost-constrained and why.

9

RAG end-to-end - the marquee portfolio piece

Build the strongest single 2026 resume project: a RAG pipeline WITH evaluation.

LearnBuildDrill
Skip if

Never skip - even if you know RAG, the evaluation layer is what most candidates omit and what differentiates.

Learn
  • Pipeline: embeddings to vector store to retrieval to (rerank) to generation. Key 2026 insight: retrieval is the bottleneck, not generation (naive RAG fails ~40% at retrieval). Highest-leverage levers: hybrid search (BM25 + vector), chunk sizing, query rewriting, reranking.
  • Vector DB by constraint: pgvector (default <1M) | Chroma (dev) | Pinecone (managed) | Weaviate (hybrid) | FAISS (in-process at scale). Embeddings (2026): Cohere embed-v4, OpenAI text-embedding-3-large, BGE-M3 (best open).
  • Courses: DeepLearning.AI - LangChain: Chat with Your Data + Building and Evaluating Advanced RAG.
Build
  • Project F1 - RAG over a real corpus with RAGAS eval (marquee, start). Real docs (SEC filings, papers, clinical trials). LangChain/LlamaIndex + FAISS/Chroma + an embedding model + hybrid retrieval + [RAGAS](https://github.com/explodinggradients/ragas) evaluation (context precision, faithfulness, answer relevancy). Deploy on Hugging Face Spaces or Streamlit. One repo demonstrates ~6 skills - and the eval is the differentiator.
Drill
  • 3 SQL + 1 NeetCode (keep coding warm).
Verify

RAG app answers questions over your corpus with a live demo link; a RAGAS eval report (faithfulness/context-precision numbers) committed - most candidates skip this; you won't.

10

Agents + MCP + evaluation/guardrails + fine-tuning

The agentic + evaluation frontier (the 2026 hire signal) + when-to-fine-tune judgment.

LearnBuildDrill
Skip if

Fine-tuning theory only if you've done QLoRA - then deepen evaluation + observability, the genuinely hot, under-supplied skill.

Learn
  • Agents (consolidating): LangGraph is the production default (stateful, durable; Klarna, Uber, JPMorgan). LlamaIndex for doc-RAG-first; Vercel AI SDK for AI UIs; DSPy for prompt optimization. Free: LangChain Academy - LangGraph.
  • MCP (Model Context Protocol) - the tool-integration standard (USB-C for AI). Primitives: Tools, Resources, Prompts. Official spec.
  • LLM evaluation = the hot skill. Ragas (RAG) | DeepEval (eval-as-unit-testing) | LangSmith (tracing+eval) | OpenAI Evals. Master LLM-as-judge (+ its biases), hallucination = faithfulness failure, OpenTelemetry tracing. Refs: Confident AI top tools 2026 | DeepLearning.AI Quality & Safety for LLM Apps.
  • Fine-tune decision: prompt to RAG to fine-tune (simplest that works). RAG augments inputs; fine-tuning changes weights. LoRA/QLoRA + HF peft/trl + Unsloth. Refs: HF LLM Course | Unsloth guide.
Build
  • Add a DeepEval CI test to your RAG project (F1): assert faithfulness >= threshold so a regression fails the build. Stretch: wrap one retrieval tool as an MCP server. This proves production reliability, not just a demo.
Drill
  • 3 SQL + 5 ML/LLM-theory.
Verify

F1 has a passing eval gate in CI (a deliberate bad chunk makes it fail); you can articulate the prompt-RAG-fine-tune decision tree with a real example.

Interview Prep Intensive

Days 11-13

Convert capability into interview performance - SQL speed, ML system design, product sense, and behavioral storytelling.

11

SQL + coding + stats/probability blitz

Speed and pattern-recognition under pressure on the three technical-screen staples.

Learn
Learn
  • SQL (highest ROI): ~70% of SQL rounds at major firms include at least one window-function question. Timed sets on DataLemur + StrataScratch: windows, CTEs, cohort/retention, MoM growth, top-N-per-group, funnels. Target: 12 problems, timed.
  • Coding/DSA: DS rounds = easy-medium NeetCode 150; skip advanced DP/segment-trees. MLE/GenAI add implement-from-scratch (k-means, gradient descent, k-NN). Python: collections, heapq, bisect, comprehensions. Target: 5 problems.
  • Stats/probability: Ace the Data Science Interview (201 real Qs) + Nick Singh's free 40 Qs. Bayes, distributions, CLT, expected value, brain teasers - your quant edge. Target: 10 Qs.
Verify

12 SQL (timed, >=80% solved cleanly) + 5 coding + 10 stats done; log every miss for spaced repetition.

12

ML theory breadth + ML system design

The explain-X breadth + the end-to-end system-design round (30-50% of an L4+ eval).

LearnDrill
Learn
  • ML breadth: finish Chip Huyen ML-Interviews Book Part II. Whiteboard bias-variance, regularization, metric selection, explain GBDT/SVM/PCA/transformer.
  • ML system design (the differentiator): the 7-step framework - clarify requirements/scale/SLA to frame as ML problem to data/features to model + architecture tradeoffs (two-tower retrieval + ranking) to training to eval (offline + online) to serving + monitoring + retraining + drift. Primary: *ML System Design Interview* (Aminian & Alex Xu). Free precursor: Chip Huyen ML Systems Design. Best free corpus: Evidently AI - 800+ real case studies.
Drill
  • Work 2 full system-design prompts aloud, timed (35-60 min each): Design a recommendation system + Design fraud detection OR Design an LLM/RAG feature end-to-end. Mine 2-3 Evidently case studies. + 3 SQL warm-up.
Verify

You can deliver a structured 45-min design for a recommender AND an LLM-feature, hitting all 7 steps incl. monitoring/drift. Record yourself; listen back for gaps.

13

Product sense / metrics + take-home + behavioral

The product-DS rounds + the narrative layer where quant-to-DS candidates most often stumble.

LearnBuildDrill
Skip if

Skip nothing - even ML roles include behavioral, and product sense is your likely weak link.

Learn
  • Product sense / metrics: Emma Ding / Data Interview Pro. Free: Ultimate Guide to Cracking Product Case Interviews Part 1 & Part 2. Master defining metrics (north-star vs input vs guardrail) and diagnosing a metric drop (clarify to segment to internal-vs-external to quantify to recommend).
  • Take-home craft: graders weight structure/communication/trade-offs over raw accuracy. Documentation-first, business-framed, reproducible. Interview Query - 6 steps.
  • Behavioral: STAR + technical depth in the Action (KDnuggets STAR for DS). Prepare 5-6 stories that flex; have a how-I'd-improve-it for every project.
Build
  • Write your 5-6 STAR stories - deliberately translate your quant/research work into business-impact language (your highest-leverage reframing). Time-box one DataMasked take-home for rehearsal.
Drill
  • 2 metric cases aloud (define-a-metric + diagnose-a-drop) + 3 SQL.
Verify

5-6 written STAR stories with quantified results; you can run a metric-drop diagnosis in a structured 10-min answer; one take-home rehearsed with a documentation-first writeup.

Portfolio Polish & Job-Hunt Launch

Days 14-15

Turn projects into hireable signal, then launch the hunt the way roles actually fill: referrals beat cold apps ~4x.

14

Portfolio finalization + resume + LinkedIn

Turn projects into hireable signal and assets that pass ATS + the 7-second scan.

BuildHunt
Build
  • GitHub polish (per project): Problem-Approach-Result-Measured Impact README; live demo URL; real benchmark numbers (accuracy, p95 latency, RAGAS scores); honest failure analysis; requirements/.gitignore/2 tests/CI. Pin only your strongest 3-5; unpin Titanic/MNIST/tutorial repos. Finish the username/username profile README. Reviewers decide in ~40s: pinned repos to one README to first paragraph to live-demo link.
Hunt
  • Resume (ATS-clean): >=70% keyword overlap with the JD; every bullet quantified (action verb + tool + business outcome + metric); standard headers; no two-column/tables/graphics. Quantified achievements get ~40% more callbacks.
  • LinkedIn: recruiter-scannable headline + summary; link GitHub + a blog post about the RAG project; Open to work.
Verify

3-5 pinned repos each with a live URL + quantified README + green CI; a one-page ATS-plain resume where every bullet has a number; LinkedIn headline/summary updated.

15

Outreach, mocks, and the ongoing engine

Launch the job hunt the way roles actually fill, and set the post-sprint cadence.

BuildDrillHunt
Build
  • Set up the ongoing engine. Daily: 2-3 SQL warm-ups + spaced repetition. Weekly: 1 system-design rehearsal, 1 mock, 5-10 outreaches, ship 1 blog post or project upgrade. Month 1-3: finish the cloud cert (GCP PMLE), publish a 4th project, write about the RAG-with-eval build, keep the commit history alive.
Drill
Hunt
  • Referrals beat cold applications ~4x (referred = ~7% of applicants, ~40% of hires; personalized outreach 10-34% reply vs 2-10%). Send 10 personalized messages to hiring managers / DS team members at target companies (reference a specific project). Join DataTalks.Club, MLOps Community, Kaggle. Submit 5 tailored applications as a supplement.
Verify

10 outreaches + 5 applications sent; 2 mocks done with a written gap list; the weekly engine scheduled. You now meet the six-point job-ready definition.

The curriculum library

Every flagship course, with detail

The exact university and industry courses the plans pull from - MIT OpenCourseWare, Stanford, and the best of the modern industry stack. Each card says what you actually learn and where it fits.

6.S191MIT (introtodeeplearning.com)
Foundational

MIT Introduction to Deep Learning

Alexander Amini, Ava Amini · ~12h (bootcamp format, 10 lectures)

High-intensity 5-day bootcamp covering deep learning fundamentals, deep computer vision (CNNs), sequence modeling, generative modeling, reinforcement learning, and large language models, with hands-on labs in facial detection and LLM fine-tuning. Serves as the fastest complete orientation to deep learning before going deep on CS231n, and all 2025 materials are openly licensed.

Fits: Days 1–5: orientation sprint before starting CS231n
Open course
18.06MIT OpenCourseWare
Undergraduate

Linear Algebra

Prof. Gilbert Strang · ~34 hrs (34 lectures × ~1 hr)

Covers systems of equations, vector spaces, determinants, eigenvalues, singular value decomposition, and positive-definite matrices through 34 recorded lectures. SVD and eigendecomposition are the workhorses of PCA, recommender systems, and dimensionality reduction — this is the single most important math course for any DS. The canonical version on OCW with full video lectures by Strang recorded live.

Fits: First course to take; foundational prerequisite for 18.065 and all ML math
Open course
18.06SCMIT OpenCourseWare
Undergraduate

Linear Algebra (OCW Scholar)

Prof. Gilbert Strang · ~34 hrs lectures + problem-solving videos

Same content as 18.06 but packaged as an OCW Scholar course for independent study: adds summary notes, worked problem-solving videos by TAs, and complete problem sets with solutions after every lecture unit. Preferred over plain 18.06 if you are self-studying without a classroom — the scaffolding closes the loop on practice problems. Includes a recording of Strang's final 18.06 lecture before his retirement in 2023.

Fits: Use in place of 18.06 if self-studying; otherwise supplement 18.06 with its problem-solving videos
Open course
18.065MIT OpenCourseWare
Undergraduate

Matrix Methods in Data Analysis, Signal Processing, and Machine Learning

Prof. Gilbert Strang · ~39 hrs (3 sessions/week × 1 hr, spring semester)

Applies matrix theory directly to the four pillars of modern data science: linear algebra, probability and statistics, optimization, and deep learning. Topics include matrix factorizations (SVD, QR, LU), gradient descent and backpropagation geometry, and the linear-algebra underpinnings of neural networks. The closest MIT course to 'applied math for industry ML engineers'; Strang's textbook Linear Algebra and Learning from Data is the reading.

Fits: After 18.06; best taken when preparing for or entering ML-heavy roles
Open course
18.05MIT OpenCourseWare
Undergraduate

Introduction to Probability and Statistics

Dr. Jeremy Orloff and Dr. Jennifer French Kamrin · ~36–40 hrs (Spring 2022 edition)

Covers combinatorics, discrete and continuous random variables, probability distributions, Bayesian inference, hypothesis testing, confidence intervals, and linear regression using R. Taught with active-learning pedagogy (concept questions, board problems, R computing). The Bayesian inference coverage is deeper than most intro courses and directly relevant to A/B testing and probabilistic modeling in industry.

Fits: Ideal starting point for probability and statistics if you have calculus; pairs well with 18.06
Open course
6.041SCMIT OpenCourseWare
Undergraduate / Graduate (6.431 graduate version)

Probabilistic Systems Analysis and Applied Probability

Prof. John Tsitsiklis · ~25 hrs lectures + recitation and tutorial videos

Rigorous treatment of probability models, discrete and continuous random variables, random processes, laws of large numbers, and statistical inference across 25 lectures in four units. The OCW Scholar edition includes TA problem-solving videos and full recitation/tutorial solutions — making it self-contained for independent study. Tsitsiklis's approach emphasizes probabilistic modeling for engineering systems, bridging theory and real-world uncertainty quantification used in ML.

Fits: Best for learners who need deeper probability rigor than 18.05 — especially those targeting ML research, robotics, or quantitative finance roles; the graduate 6.431 level is appropriate for PhD prep
Open course
18.650MIT OpenCourseWare
Undergraduate

Statistics for Applications

Prof. Philippe Rigollet · ~33 hrs (22 recorded lectures × ~1.5 hrs/session)

In-depth theoretical foundations of statistical methods: parametric inference, maximum likelihood estimation, hypothesis testing, goodness-of-fit tests, regression, Bayesian statistics, PCA, and generalized linear models. Rigollet's lectures emphasize mathematical rigor and proof-based understanding of why statistical tools work — essential for knowing when assumptions break and for reading ML papers confidently. PCA and GLMs are directly used in industry DS work daily.

Fits: After completing a probability course (18.05 or 6.041); most valuable for those transitioning from applied DS to research-grade statistical modeling
Open course
6.036 / 6.3900MIT OpenCourseWare
Undergraduate

Introduction to Machine Learning

Prof. Leslie Kaelbling, Prof. Tomás Lozano-Pérez, Prof. Isaac Chuang, Prof. Duane Boning (Fall 2020 OCW edition); Fall 2023 live site: Duane Boning, Ike Chuang, Wojciech Matusik, Tess Smidt, Peter Szolovits, and others · ~156 hours (13 weeks × 12 hrs/week per MIT estimate)

Covers regression, classification, gradient descent, feature engineering, neural networks (CNNs, transformers), non-parametric models, MDPs, and reinforcement learning — building the full supervised-to-RL arc. Provides lecture notes, labs, and homework problems with interactive access via MIT Open Learning Library. This is the canonical MIT undergrad ML course and the direct prerequisite for 6.7960 Deep Learning; mastering it signals readiness for industry ML roles.

Fits: Best as a first serious ML course after linear algebra and Python. Replaces ad-hoc online tutorials with a rigorous, unified framework.
Open course
6.390MIT EECS (introml.mit.edu)
Undergraduate

Introduction to Machine Learning (live site, formerly 6.036 / now 6.3900)

Rotating MIT faculty team including Duane Boning, Ike Chuang, Wojciech Matusik, Tess Smidt, Peter Szolovits (Fall 2023); course runs every semester · ~130–150 hours (semester course, 2 sessions/week)

Same curriculum as 6.036 OCW but refreshed yearly: regression, classification, neural nets, CNNs, representation learning, transformers, RL; section-based recitations plus weekly partner lab checkoffs. Free public notes at introml.mit.edu/notes. The live site has the most current version of the canonical MIT intro-ML sequence and reflects the renumbered 6.3900 / 6.390 designation adopted in Fall 2022.

Fits: Use alongside or instead of the OCW frozen edition when you want the most current syllabus, problem sets, and freely available lecture notes.
Open course
6.867MIT OpenCourseWare
Graduate

Machine Learning (Graduate)

Prof. Tommi Jaakkola (lead), Rohit Singh, Ali Mohammad · ~60 hours lecture + problem sets (28 × 1.5 hr lectures; 5 problem sets + project)

Graduate-level treatment of classification, regression, SVMs, kernel methods, boosting, mixture models, EM algorithm, Hidden Markov Models, and Bayesian networks — framed through statistical inference. Lecture notes, problem sets, exams, and project guidelines all available. Jaakkola's statistical framing is especially valued for building the intuition behind probabilistic ML that underpins modern industry model evaluation and calibration.

Fits: Take after 6.036/6.390 when you need the theory behind the algorithms — essential before reading research papers or working on probabilistic modelling teams.
Open course
9.520 / 6.860MIT OpenCourseWare (Spring 2003 archive) + poggio-lab.mit.edu (Fall 2019–2022 live materials)
Graduate

Statistical Learning Theory and Applications

Prof. Tomaso Poggio, Prof. Lorenzo Rosasco, Prof. Sasha Rakhlin (recent offerings); original OCW: Poggio, Dr. Ryan Rifkin, Dr. Sayan Mukherjee, Alex Rakhlin · ~45–60 hours (semester, 2 sessions/week; 4 problem sets + final project)

Supervised learning via regularization theory: RKHSs, Tikhonov regularization, SVMs, generalization bounds via stability and VC theory, boosting, and applications to vision, NLP, and bioinformatics. Recent editions extend to deep networks (approximation + optimization theory) and connections to neuroscience. Cross-listed 9.520/6.860 brings together Brain & Cognitive Sciences and EECS; CBMM lectures also on YouTube. Understanding generalization bounds is critical for diagnosing overfit in production models.

Fits: Take when you need the mathematical foundations of why models generalize — essential for ML research roles, algorithm design, or deep-learning theory.
Open course
18.657MIT OpenCourseWare
Graduate

Mathematics of Machine Learning

Prof. Philippe Rigollet · ~45 hours (23 lectures × ~1.5 hr; 3 problem sets)

Mathematically rigorous treatment of binary classification, concentration inequalities, VC theory, covering numbers, boosting, SVMs, gradient/mirror/stochastic descent, online learning with expert advice, and stochastic/adversarial bandits. Lecture notes are publicly available as PDFs. Rigollet's course is the go-to bridge between ML and high-dimensional statistics — mastering it directly supports rigorous A/B testing, bandit-based recommendation systems, and safe deployment decisions.

Fits: Take after 18.06 Linear Algebra and 18.05 Probability when you want to reason about ML algorithms with mathematical precision, especially for research or quantitative roles.
Open course
6.7960MIT OpenCourseWare
Undergraduate / Graduate

Deep Learning

Prof. Phillip Isola, Prof. Sara Beery, Dr. Jeremy Bernstein · ~60 hours (semester course; problem sets + research project)

Fundamentals and theory of deep learning: MLPs, CNNs, RNNs, graph networks, transformers, backprop and autodiff, geometric invariances, learning theory for high-dimensional data, and applications in computer vision, NLP, and robotics. Full lecture videos, notes, and homework on OCW. The most current MIT OCW deep-learning offering (Fall 2024) with explicit 6.3900 as prerequisite — directly industry-applicable to LLM fine-tuning, vision models, and multimodal systems.

Fits: Take immediately after completing 6.036/6.390; this is the natural continuation for anyone building production deep-learning systems.
Open course
6.S897MIT OpenCourseWare
Graduate

Machine Learning for Healthcare

Prof. Peter Szolovits, Prof. David Sontag · ~45 hours (lecture videos + notes; semester course)

Clinical data structures, risk stratification, disease progression modelling, precision medicine, NLP on clinical notes, physiological time-series, causal inference, interpretability, and algorithmic fairness — with guest clinicians from the Boston area and real-cohort project data. Demonstrates how industry ML deployment constraints (class imbalance, missingness, regulatory approval, interpretability) differ from benchmark settings; invaluable for data scientists targeting healthcare, insurance, or regulated industries.

Fits: Take after core ML (6.036) when targeting healthcare, biotech, or any high-stakes regulated domain where model interpretability and fairness are mandatory.
Open course
6.0001 / 6.100AMIT OpenCourseWare
Beginner

Introduction to Computer Science and Programming in Python

Dr. Ana Bell, Prof. Eric Grimson, Prof. John Guttag · ~40 h total (half-semester, 12 lectures)

Python fundamentals — branching, iteration, recursion, OOP, data structures (lists, dicts, tuples), algorithm complexity (big-O), searching, and sorting. The course builds a computational problem-solving mindset that underpins every data pipeline and ML script a DS writes day-to-day.

Fits: First stop for anyone without a Python background or who wants to fill gaps in CS fundamentals before tackling algorithms courses.
Open course
6.100LMIT OpenCourseWare
Beginner

Introduction to CS and Programming using Python (extended pace)

Dr. Ana Bell · ~80 h total (full semester, 26 lectures)

Same content as 6.0001 / 6.100A — Python, data structures, OOP, algorithm analysis, searching and sorting — spread over a full semester with additional practice time, finger exercises, and problem sets. Textbook: John Guttag, Introduction to Computation and Programming Using Python, 3rd ed.

Fits: Prefer this over 6.0001 if you are completely new to programming and need extra practice time between concepts.
Open course
6.006MIT OpenCourseWare
Intermediate

Introduction to Algorithms

Prof. Erik Demaine, Dr. Jason Ku, Prof. Justin Solomon · ~120 h total (12-unit course, ~12 h/week over 14 weeks)

Dynamic arrays, heaps, balanced BSTs, hash tables, sorting (merge/heap/radix), graph searching (BFS/DFS/Dijkstra/Bellman-Ford), dynamic programming, and introductory complexity theory. Essential for writing efficient data processing code, optimising ML pipelines, and passing technical interviews.

Fits: Take after 6.0001 and discrete math (6.042J). Required foundation before 6.046J.
Open course
6.046JMIT OpenCourseWare
Advanced Undergraduate

Design and Analysis of Algorithms

Prof. Erik Demaine, Prof. Srini Devadas, Prof. Nancy Lynch · ~140 h total (12-unit course, 3 contact h/week + heavy problem sets)

Advanced algorithm design: divide-and-conquer, randomised algorithms, amortised analysis, dynamic programming, greedy algorithms, graph algorithms, approximation algorithms (PTAS/FPTAS), competitive analysis, and introductory cryptography. Gives the theoretical rigour needed to evaluate algorithm choices in large-scale data systems and research.

Fits: Take after completing 6.006. Best for DS roles involving significant systems work, research engineering, or algorithm-heavy interviews at top-tier tech firms.
Open course
6.5840 (formerly 6.824)MIT PDOS (live course site)
Graduate

Distributed Systems

Prof. Frans Kaashoek, Prof. Robert Morris · ~160 h total (12-unit graduate course; 5 programming labs + readings + exams)

Fault tolerance, replication, and consistency in large-scale systems; MapReduce, Raft consensus, key-value stores with sharding, and Zookeeper. Hands-on Go labs build a production-grade replicated KV store from scratch — directly relevant to understanding Spark, Kafka, Ray, and any distributed ML training infrastructure a DS depends on.

Fits: Take when moving from individual ML modelling toward ML platform / MLOps engineering, data infrastructure, or senior DS roles requiring deep systems understanding.
Open course
—MIT CSAIL (missing.csail.mit.edu)
Beginner–Intermediate

The Missing Semester of Your CS Education

Anish Athalye, Jon Gjengset, Jose Javier Gonzalez Ortiz · ~15 h total (9–11 short lectures, IAP format)

Shell scripting, Bash automation, Vim, tmux, SSH, Git internals, data wrangling with sed/awk/jq, debugging and profiling, build systems, and security/cryptography fundamentals. Bridges the gap between knowing how to code and knowing how to work like a professional engineer in a Linux/macOS environment.

Fits: Take at any stage — the earlier the better. Immediately boosts productivity in notebooks, remote GPU servers, CI pipelines, and day-to-day DS tooling.
Open course
6.S191MIT (introtodeeplearning.com)
Undergraduate / introductory graduate

Introduction to Deep Learning

Alexander Amini, Ava Amini · ~20–30 hrs (9 lectures + 3 labs; 3-unit IAP course)

Covers foundations through cutting-edge practice in nine lectures: Intro to Deep Learning, Deep Sequence Modeling (RNNs, Transformers), Deep Computer Vision (CNNs, detection), Deep Generative Modeling (VAEs, GANs, diffusion), Deep Reinforcement Learning, New Frontiers (LLMs, agents), The Three Laws of AI, AI for Science, and Secrets to Massively Parallel Training. Hands-on labs build a music generator, a facial detection system, and fine-tune an LLM. All slides, lecture videos, and lab code are fully open-sourced — the fastest on-ramp to modern deep learning for any industry DS.

Fits: Start here as your first deep learning course; also valuable as a fast refresher before interviews or before tackling 6.5940.
Open course
6.034MIT OpenCourseWare
Undergraduate

Artificial Intelligence

Patrick Henry Winston · ~60 hrs (23 lectures + recitations + assignments; full semester)

Sweeps classical AI from first principles: search algorithms (A*, minimax, alpha-beta), rule-based expert systems and goal trees, constraint propagation, knowledge representation, and a broad survey of learning — nearest neighbors, decision trees, neural nets, SVMs, boosting, and genetic algorithms. Also covers vision and language as computational problems, grounding the conceptual 'why' behind modern ML. Essential for understanding the intellectual lineage of every algorithm a data scientist uses daily.

Fits: Take after 6.S191 to develop rigorous algorithmic intuition and classical AI grounding. Especially valuable before system-design or ML-theory interviews.
Open course
6.8610 (formerly 6.806 / 6.864)MIT (mit-6861.github.io)
Graduate

Quantitative Methods for NLP (Advanced Natural Language Processing)

Jacob Andreas, Chris Tanner, Omar Khattab · ~80–100 hrs (24 lectures, 3 problem sets, quizzes, research project; full semester)

Builds NLP from mathematical foundations: n-gram and log-linear language models, word2vec, RNNs, seq2seq with attention, the Transformer architecture, pretraining paradigms (BERT, GPT, SFT, RLHF), efficient training (MoE, quantization, LoRA), prompting and chain-of-thought, multimodality, Mamba/SSMs, interpretability, structured prediction, and bias & fairness. Students complete an original research project. This is the graduate NLP course that trains you to reason rigorously about every LLM component you deploy in production.

Fits: Take after solid ML foundations (6.S191 level) when you need research-depth NLP knowledge — essential for NLP engineering, LLM fine-tuning, or ML research roles.
Open course
6.8300 (formerly 6.819 / 6.869)MIT OpenCourseWare
Graduate (TQE qualifying-exam course)

Advances in Computer Vision

Frédo Durand, Vincent Sitzmann, Peter E. Holderrieth · ~80–100 hrs (full semester; lectures + 5 problem sets + major project)

Three-module graduate curriculum: (1) Geometry & 3D — pinhole cameras, projective geometry, optical flow, point tracking, multi-view geometry, differentiable rendering, and neural scene representations (NeRF/3DGS); (2) Representation & Generation — diffusion models, classifier-free guidance, self-supervised learning; (3) Embodied Vision — robotic perception and imitation learning. The depth on 3D vision and generative models is unmatched in any free curriculum, directly relevant to autonomous systems, medical imaging, and visual AI product work.

Fits: Take after 6.S191 with PyTorch fluency and linear algebra; ideal for roles in computer vision engineering, robotics, or multimodal AI.
Open course
6.5940 (formerly 6.S965)MIT Han Lab (efficientml.ai)
Graduate

TinyML and Efficient Deep Learning Computing

Song Han · ~80–100 hrs (full semester; 5 labs, final project, no exams)

Four-chapter curriculum on making AI fast and deployable: (1) Efficient Inference — pruning & sparsity, quantization, neural architecture search, knowledge distillation, MCUNet for microcontrollers; (2) Domain-Specific Optimization — efficient Transformer/LLM deployment, LLM post-training quantization, long-context LLMs, vision Transformers, diffusion model acceleration; (3) Efficient Training — distributed data/model parallelism, on-device fine-tuning; (4) Quantum ML. Students deploy Llama2-7B on a laptop. Directly addresses the production-engineering gap — most DS courses stop at accuracy, this course teaches you to actually ship models to edge and cloud.

Fits: Take after building model-training fluency; essential for MLOps, edge AI, LLM inference optimization, or any role where model size and latency matter.
Open course
CS231nStanford University
Core

Deep Learning for Computer Vision

Fei-Fei Li, Ehsan Adeli, Justin Johnson, Zane Durante, Tiange Xiang · ~80h (10-week course + 3 assignments + project)

Full pipeline from linear classifiers and backprop through CNN architectures (AlexNet, VGG, ResNet, BatchNorm), RNNs, attention, Vision Transformers, object detection (YOLO, R-CNN), segmentation, diffusion models, and self-supervised learning (CLIP, DINO). Three hands-on PyTorch assignments covering kNN/softmax, ConvNets/visualization, and captioning/transformers/diffusion build the implementation intuition that industry ML roles demand.

Fits: Days 1–30: core track, start immediately
Open course
CS231nStanford University (cs231n.github.io)
Foundational

CS231n Lecture Notes (Deep Learning for Computer Vision)

Fei-Fei Li, Andrej Karpathy, Justin Johnson (original authors) · ~15h reading

Standalone written reference covering image classification, kNN, linear classifiers, SVM/softmax loss, SGD/optimization, backpropagation, neural network architecture, and CNNs (conv/pool layers) with an additional module on transfer learning and fine-tuning. These notes are the most-cited written introduction to ConvNets and remain the clearest explanation of gradient flow and the chain rule for practitioners.

Fits: Days 1–10: read in parallel with CS231n lectures
Open course
CS231nStanford University (YouTube)
Core

CS231n Spring 2025 YouTube Lectures

Fei-Fei Li, Ehsan Adeli, Justin Johnson, Zane Durante, Tiange Xiang · ~30h video

Free public recordings of Spring 2025 CS231n covering the full syllabus: backprop, CNNs, RNNs, attention/ViT, object detection, segmentation, video understanding, generative models (VAE, GAN, diffusion), self-supervised learning, and world modeling. Watching the lecture videos alongside the assignments is the primary free path through this course for non-enrolled learners.

Fits: Days 1–30: watch in tandem with assignments
Open course
CS224nStanford University
Core

Natural Language Processing with Deep Learning

Diyi Yang, Yejin Choi (Winter 2026); Christopher Manning (Spring 2024 and earlier editions) · ~100h (10 weeks, 10–15h/week)

The definitive NLP-with-DL course: word vectors (word2vec, GloVe), backpropagation, RNNs, LSTMs, seq2seq, attention, transformers, pretraining (BERT, GPT), post-training (RLHF, DPO), prompting, PEFT, RAG, and agents — four programming assignments culminating in implementing GPT-2. Industry DS benchmark for NLP engineering depth.

Fits: Weeks 1–10; start here for NLP depth
Open course
CS224nStanford University / YouTube
Core

CS224N Spring 2024 Lecture Playlist (YouTube — free)

Christopher Manning · ~30h video

Complete free video lectures for the Spring 2024 offering of CS224n covering word vectors, dependency parsing, RNNs, transformers, pretraining, prompting, RLHF, agents, and interpretability. The last publicly released full lecture series; the Winter 2026 course is behind Canvas.

Fits: Days 1–30; paired with official assignments from the course site
Open course
XCS224NStanford Online (SCPD)
Core

XCS224N: NLP with Deep Learning (Stanford Online Professional Certificate)

Christopher Manning · 10 weeks, ~120h total

Paid, graded online version of CS224n with community TAs, Stanford certificate on completion, and same assignments as the on-campus course. Provides accountability and credential for professionals who need proof of completion for hiring pipelines.

Fits: Alternative to free audit; choose if certificate matters for role
Open course
CS336Stanford University
Advanced

Language Modeling from Scratch

Tatsunori Hashimoto, Percy Liang · 10 weeks, 20–25h/week

Builds a full LLM pipeline from the ground up: tokenization (BPE), PyTorch/Triton kernel writing, transformer architecture, distributed training (tensor/pipeline parallelism), scaling laws, inference optimization, supervised fine-tuning, and RLHF data. Directly relevant for DS roles at LLM labs or foundation-model teams.

Fits: Day 31–60 after CS224n; for LLM engineering depth
Open course
Stanford University (free online textbook)
Foundational

Speech and Language Processing (3rd Edition Draft)

Dan Jurafsky, James H. Martin · ~60h (reference-style; read alongside CS224n)

The canonical NLP textbook, updated January 2026, covering n-gram LMs, logistic regression, embeddings, neural networks, transformers, BERT, LLMs, RAG, machine translation, RNNs, and parsing — also includes Vol II on linguistic structure. Free PDF; the recommended reading companion for CS224n.

Fits: Concurrent with CS224n from Week 1
Open course
CS224UStanford University
Advanced

Natural Language Understanding

Christopher Potts · ~80h (10 weeks)

Project-oriented companion to CS224n focusing on NLU benchmarks, pragmatic reasoning, NLI, question answering, information retrieval, LLM evaluation, grounding, and responsible NLP. Rounds out pure modeling skills with evaluation rigour needed for industry DS roles.

Fits: After completing CS224n; Day 45–60
Open course
CS246Stanford University
Core

Mining Massive Data Sets

Jure Leskovec, Charilaos Kanatsoulis · ~120h (10-week quarter)

Covers MapReduce/Spark, locality-sensitive hashing, frequent itemsets, recommendation systems, clustering, PageRank, data streams, and graph neural networks at scale. This is the definitive course for industry DS work on distributed computation and large-scale ML pipelines — skills used daily in production data systems.

Fits: Days 15–40 of a 60-day plan after Python/ML basics are solid
Open course
CS145Stanford University
Foundational

Introduction to Big Data Systems (Database Systems)

Shiva Shivakumar · ~80h (10-week quarter)

SQL fundamentals, storage engines, query processing and optimization, concurrency control, transactions, distributed database algorithms, and NoSQL vs SQL trade-offs. Every industry DS role expects solid SQL and an understanding of how databases actually work under the hood.

Fits: Days 1–15 of a 30-day plan; prerequisite before CS245 or CS246
Open course
CS224WStanford University
Advanced

Machine Learning with Graphs

Jure Leskovec, Charilaos Kanatsoulis · ~100h (10 weeks, 10–20h/week)

Graph Neural Networks (GNNs), node/graph embeddings, knowledge graphs, recommender systems via GNNs, relational deep learning, LLM + GNN integration, and social/biological network analysis. Directly applicable for recommendation engines, fraud detection graphs, and knowledge graph pipelines in industry.

Fits: Days 40–60 of a 60-day plan after CS246 and solid PyTorch basics
Open course
CS245Stanford University
Advanced

Principles of Data-Intensive Systems

Matei Zaharia · ~80h (10-week quarter)

Architecture of databases and cluster frameworks (including Spark SQL internals), transactions, concurrency control, fault recovery, distributed databases, streaming systems, cloud data systems, and differential privacy. Co-taught by Spark's creator; gives a principled understanding of why distributed data tools make the design choices they do.

Fits: Days 30–50 of a 60-day plan as a deep-dive follow-on to CS145
Open course
CS244bStanford University
Advanced

Distributed Systems

Jack Humphries, David Mazières · ~80h (10-week quarter)

Distributed OS and application protocols, distributed state sharing, consensus, fault tolerance, and high-level distributed algorithms. Industry DS roles increasingly require understanding distributed system guarantees when debugging data pipelines and coordinating ML training across clusters.

Fits: Optional deep-dive in week 7–8 of a 60-day plan for infrastructure-leaning roles
Open course
Cambridge University Press / Stanford
Core

Mining of Massive Datasets (MMDS Book)

Jure Leskovec, Anand Rajaraman, Jeff Ullman · ~60h (self-paced reading)

Free companion textbook to CS246 covering MapReduce, similarity search (LSH), streams, PageRank, clustering, recommender systems, dimensionality reduction, and large-scale ML. Available as a free PDF download; widely cited and used as the primary reference for CS246-level work in industry.

Fits: Read in parallel with CS246 lectures
Open course
CS246HStanford University
Core

Mining Massive Data Sets: Hadoop Lab

Jure Leskovec · ~30h (lab companion)

Hands-on implementation of data mining algorithms with Hadoop, Spark, Hive, Kafka, Sqoop, Avro, and Parquet — the practical big-data ecosystem stack. Directly implements the algorithms covered in CS246 using the actual tools used in production data pipelines.

Fits: Run concurrently with CS246 (days 15–40)
Open course
CS229Stanford University
Core

Machine Learning

Tengyu Ma, Chris Ré · ~80h (lecture notes + problem sets)

Broad, mathematically rigorous introduction to supervised and unsupervised learning: linear/logistic regression, SVMs, neural networks, EM, PCA, and reinforcement learning. Covers learning theory (bias-variance, VC theory, regularization) alongside practical advice, giving industry DS a principled foundation for model selection and debugging.

Fits: Week 1–3 of a 60-day plan — establishes the theoretical core before specialising
Open course
STATS214 / CS229MStanford University
Advanced

Machine Learning Theory

Tselil Schramm (Fall 2022); previously Tengyu Ma · ~60h

Proof-based theory of when and why ML algorithms generalise: uniform convergence, Rademacher complexity, deep learning theory, neural tangent kernel, non-convex optimisation, implicit regularisation, online/bandit learning. Gives an industry DS the vocabulary to read and critically evaluate research papers on model performance guarantees.

Fits: Days 45–60 of a 60-day plan — after CS229 foundation is solid
Open course
STATS305CStanford University
Advanced

Applied Statistics III: Probabilistic Models

Scott Linderman · ~70h (Spring 2026, publicly available notes and code)

Multivariate Gaussian models, probabilistic graphical models, latent variable models (mixture models, VAEs), MCMC, variational Bayesian inference, sequence models (HMMs, LDS, Transformers), and diffusion models. Directly relevant for industry DS roles requiring Bayesian modelling, uncertainty quantification, or generative model development.

Fits: Days 30–60 — after probability/stats refresher, run in parallel with deep-learning track
Open course
STATS305BStanford University
Advanced

Models and Algorithms for Discrete Data

Scott Linderman · ~60h

Generalised linear models, Bayesian inference, variational inference, HMMs, linear Gaussian state-space models, VAEs, RNNs, Transformers, and diffusion models, all implemented from scratch in Python. Bridges statistical foundations with modern deep learning architectures, highly applicable to NLP and time-series modelling in industry.

Fits: Days 30–60 — after logistic regression basics; pairs well with STATS305C
Open course
STATS305AStanford University
Core

Linear Models (and More)

Trevor Hastie (2025–26); Art Owen (earlier years) · ~50h

Rigorous treatment of the linear model from t-tests to splines and wavelets: distribution theory, geometry of least squares, model selection (Cp, AIC, cross-validation), regularisation, random effects, and causal inference basics. The definitive first-year PhD linear models course — gives an industry DS the deep understanding of regression that underpins most production models.

Fits: Days 15–30 — immediately after probability review, before tree/ensemble methods
Open course
STATS200Stanford University
Foundational

Introduction to Statistical Inference

Iain Johnstone / Guenther Walther (2024–25 sections); Zhou Fan (2016 open notes) · ~45h

Hypothesis testing, point and interval estimation, Neyman–Pearson theory, maximum likelihood, likelihood ratio tests, Bayesian analysis, and asymptotic and simulation-based methods. Essential theoretical grounding for any DS who needs to communicate uncertainty, run A/B tests rigorously, or interpret p-values and confidence intervals correctly.

Fits: Days 1–14 — the statistics bedrock before any modelling course
Open course
CS221Stanford University
Core

Artificial Intelligence: Principles and Techniques

Moses Charikar, Zachary Robertson · ~80h

Breadth-first AI: machine learning, search algorithms, Markov decision processes, game-playing agents, constraint satisfaction, Bayesian networks, and first-order logic. Gives an industry DS the classical AI vocabulary and reasoning tools needed for recommendation systems, planning, and knowledge representation tasks.

Fits: Days 15–45 — complements the ML-centric CS229 with reasoning and decision-making modules
Open course
STATS216Stanford University / edX (self-paced)
Foundational

Introduction to Statistical Learning (Statistical Learning with R / Python)

Trevor Hastie, Rob Tibshirani · ~40h (video lectures + R or Python labs)

Covers all of ISLR/ISLP: linear/logistic regression, cross-validation, ridge/lasso, splines, GAMs, trees, random forests, boosting, SVMs, PCA, and clustering. The standard applied ML curriculum used by working data scientists — lighter on proofs, heavy on intuition and hands-on R or Python coding.

Fits: Days 1–14 — the practical first course before diving into theory-heavy material
Open course
CS336Stanford University
Advanced

Language Modeling from Scratch

Percy Liang, Tatsunori Hashimoto · ~120h (10 weeks, 20-25h/week)

Students build a complete LLM from scratch: tokenization, transformer architecture, GPU kernels with Triton, distributed training/parallelism, scaling laws, data pipelines (filtering/deduplication/synthetic), and post-training alignment (SFT, RLHF, RLVR, DPO). This is the highest-signal course for a DS who needs to understand exactly what happens inside production LLMs — not just API calls, but the full engineering stack.

Fits: Days 30-60: after transformer fundamentals are solid
Open course
CS324Stanford University
Core

Large Language Models

Percy Liang, Tatsunori Hashimoto, Christopher Ré · ~60h (10 weeks)

Covers the full lifecycle of foundation models: capabilities, harms (bias/toxicity/misinformation), data sourcing, security and legality, modeling, distributed training, scaling laws, selective architectures, adaptation (PEFT/fine-tuning), and environmental impact. Essential for any DS who needs to evaluate, deploy, or govern LLMs in industry settings — not just use them.

Fits: Days 15-45: core conceptual grounding before deep implementation
Open course
CS25Stanford University
Core

Transformers United V6

Steven Feng, Karan Singh, Michael C. Frank, Christopher Manning · ~20h (10 weeks, 2h/week)

A seminar series bringing top researchers from Anthropic, Google DeepMind, Hugging Face, Mistral AI, and academia to present on the frontier of transformer research: SSMs vs. transformers, ultra-scale training, multimodal intelligence, agentic AI, and production inference. Open to anyone; no Stanford affiliation required. Keeps a DS current on what is actually being deployed.

Fits: Ongoing: skim lectures concurrently throughout the 60-day plan
Open course
CS234Stanford University
Core

Reinforcement Learning

Emma Brunskill · ~80h (10 weeks)

Rigorous treatment of RL from MDPs and tabular planning through deep RL, policy gradients, Q-learning with function approximation, offline RL, imitation learning, and RLHF/DPO — the same techniques used to align GPT-4 and Claude. Directly applicable to fine-tuning LLMs with human feedback, reward modeling, and building recommendation/control systems in industry.

Fits: Days 20-50: after ML fundamentals; pairs with LLM alignment modules in CS336
Open course
CS330Stanford University
Advanced

Deep Multi-Task and Meta Learning

Chelsea Finn · ~80h (10 weeks)

Covers multi-task learning, MAML and optimization-based meta-learning, black-box meta-learning, metric/contrastive learning, unsupervised pre-training, Bayesian meta-learning, domain adaptation, and lifelong/curriculum learning. Directly relevant for few-shot fine-tuning, domain generalization, and building models that adapt quickly to new tasks — core DS skills in fast-moving product environments.

Fits: Days 45-60: after core deep learning and transformer foundations
Open course
Springer / Stanford (Hastie, Tibshirani, Friedman)
Advanced

The Elements of Statistical Learning (ESL), 2nd ed.

Trevor Hastie, Robert Tibshirani, Jerome Friedman · ~120h

Rigorous treatment of supervised/unsupervised learning including additive models, boosting, kernel methods, graphical models, and random forests with full mathematical derivations. Industry DS engineers consult it as a reference when they need to understand why an algorithm behaves a certain way in production.

Fits: Days 31–60 of a 60-day plan, alongside ISLP
Open course
Andrej Karpathy (independent)
Foundational

Neural Networks: Zero to Hero

Andrej Karpathy · ~15h video

Eight in-depth videos building neural networks and backprop from scratch in Python: micrograd (autograd engine), character-level MLPs, activations/BatchNorm internals, becoming a backprop ninja (manual gradients through cross-entropy and batchnorm), WaveNet-style CNNs, and GPT. Gives the deepest first-principles understanding of gradient flow and training dynamics that CS231n assumes but does not teach from scratch.

Fits: Days 1–7: pre-study before CS231n assignments if backprop is rusty
Open course
fast.ai
Foundational

Practical Deep Learning for Coders

Jeremy Howard · ~40h (9 lessons × ~90 min + notebooks)

Top-down practical course using PyTorch and fastai: image classification, object detection, segmentation, NLP, tabular models, and deployment via Gradio/Hugging Face Spaces. Covers transfer learning, fine-tuning, and data augmentation in the same lecture stack. Pairs well with CS231n by providing immediate production-grade intuition before or alongside the theory.

Fits: Days 1–14: parallel fast track for applied intuition
Open course
d2l.ai (Cambridge University Press)
Core

Dive into Deep Learning — Computer Vision Chapters

Aston Zhang, Zachary C. Lipton, Mu Li, Alexander J. Smola · ~20h (chapters 7–14)

Interactive textbook chapters covering modern CNN architectures (AlexNet, VGG, NiN, GoogLeNet, ResNet, DenseNet), image augmentation, fine-tuning, object detection with anchor boxes, SSD, R-CNN, fully convolutional networks for segmentation, and neural style transfer — all with runnable multi-framework code in PyTorch/MXNet/JAX. The combination of math, code, and exercises makes it ideal for consolidating CS231n concepts.

Fits: Days 10–30: reference and exercise supplement to CS231n
Open course
Hugging Face
Advanced

Hugging Face Community Computer Vision Course

Community (60+ contributors) · ~30h (13 units)

End-to-end practical course covering CNNs, Vision Transformers (ViT, Swin, DETR), multimodal models (CLIP, BLIP, OWL-ViT), generative models (GANs, VAEs, diffusion), object detection and segmentation with YOLO and SAM, video processing, 3D vision/NeRF, model optimization and TinyML, and ethics. Directly maps CS231n theory to HuggingFace Transformers library code used in industry pipelines.

Fits: Days 30–60: bridge from theory to production HuggingFace APIs
Open course
MIT Press / deeplearningbook.org
Advanced

Deep Learning (Goodfellow, Bengio, Courville)

Ian Goodfellow, Yoshua Bengio, Aaron Courville · ~60h (reference, read selectively)

Comprehensive theoretical reference covering linear algebra, probability, ML fundamentals, feedforward networks, regularization, optimization, CNNs (Chapter 9), sequence models (Chapter 10), and generative models (Chapter 20). Chapter 9 on CNNs provides the most rigorous treatment of convolution, pooling, and receptive fields available in a free text, filling the mathematical gaps left by CS231n's engineering focus.

Fits: Days 15–60: reference chapters 6–9 alongside CS231n lecture topics
Open course
Hugging Face
Core

The Hugging Face LLM Course

Hugging Face team · ~60–80h (12 chapters, ~6–8h each)

Hands-on transformer usage via the HF ecosystem (Transformers, Datasets, Tokenizers, Accelerate): fine-tuning, dataset curation, PEFT, reasoning models, and Hub deployment. Bridges CS224n theory to production-ready NLP tooling used daily in industry.

Fits: Weeks 3–6 concurrent with CS224n pretraining and prompting lectures
Open course
O'Reilly Media
Core

Designing Data-Intensive Applications (DDIA)

Martin Kleppmann · ~50h (self-paced reading)

Reliability, scalability, and maintainability of data systems; storage engines, replication, partitioning, transactions, distributed system trade-offs (CAP theorem, eventual consistency), batch and stream processing. The single most frequently recommended book for DS/MLE interviews and system design rounds at major tech companies.

Fits: Days 10–30 of a 30-day plan; read alongside CS145 or CS245
Open course
O'Reilly Media / Databricks
Foundational

Learning Spark, 2nd Edition

Jules Damji, Brooke Wenig, Tathagata Das, Denny Lee · ~30h

Practical PySpark and Scala Spark covering DataFrames, Spark SQL, Structured Streaming, MLlib, and Delta Lake with Databricks. Bridges the theory of CS246 to production-level Spark code that data engineers and DS professionals write daily.

Fits: Days 20–35 of a 60-day plan while working through CS246 Spark assignments
Open course
Made With ML (Anyscale)
Core

MLOps Course — Made With ML

Goku Mohandas · ~40h

End-to-end production ML covering data preparation, experiment tracking (MLflow), model serving, CI/CD pipelines, monitoring, and data engineering — all through a live NLP project. Essential because it is one of the most cited free MLOps curricula that mirrors real industry workflows with software engineering discipline baked in.

Fits: Days 1–10 of 30-day plan, primary MLOps foundation
Open course
DataTalks.Club
Core

MLOps Zoomcamp

Alexey Grigorev, Cristian Martinez, Emeli Dral · ~9 weeks

Covers experiment tracking (MLflow), ML pipeline orchestration (Prefect/Mage), model deployment (batch, streaming, web), monitoring with Prometheus and Grafana, and CI/CD best practices — all using real cloud tools (AWS, Docker, GitHub Actions). Free, project-based, and mirrors a production ML engineer's actual toolchain.

Fits: Days 1–20 of 60-day plan, hands-on MLOps stack
Open course
The Full Stack
Core

Full Stack Deep Learning (FSDL 2022)

Josh Tobin, Sergey Karayev, Charles Frye, Pieter Abbeel · ~30h

Covers the full product lifecycle of ML: tooling infrastructure, data management, model testing and troubleshooting, deployment, continual learning, and team/project management. Unique in combining technical depth with product thinking and ethics — directly relevant to how DS teams ship and maintain ML products.

Fits: Days 10–25 of 30-day plan, complements tool-focused courses
Open course
O'Reilly Media
Core

Designing Machine Learning Systems

Chip Huyen · ~20h (book)

Holistic ML system design covering training data acquisition, feature engineering, model selection, deployment strategies, monitoring, and iterative improvement — grounded in real case studies from large-scale production systems. Teaches the design thinking required to make the right architectural trade-offs before coding anything.

Fits: Week 1–2 of 60-day plan, essential conceptual grounding
Open course
O'Reilly Media
Advanced

AI Engineering: Building Applications with Foundation Models

Chip Huyen · ~20h (book)

Covers building production-grade AI applications on top of foundation models: prompt engineering, RAG systems, agent architectures, evaluation frameworks, hallucination mitigation, fine-tuning decisions, and model optimization for latency/cost/security. The most read book on O'Reilly in 2025; directly maps to the LLMOps role emerging in industry.

Fits: Days 30–60 of 60-day plan, LLMOps and AI engineering layer
Open course
Google Cloud
Core

Practitioners Guide to MLOps

Google Cloud Team · ~4h (whitepaper)

Defines the three MLOps maturity levels (manual → automated CT → full CI/CD), continuous training pipelines, data and model validation, feature stores, and metadata management. Provides the conceptual framework used in industry to assess and scale an organization's MLOps posture.

Fits: Day 5–10 of any plan, read alongside tooling courses
Open course
Google Cloud
Core

MLOps on Google Cloud — Architecture Reference

Google Cloud Team · ~3h (architecture guide)

Explains CI/CD and continuous training (CT) pipelines in ML, the difference from DevOps, the 8-step ML lifecycle, and infrastructure patterns for automation. A concise, authoritative reference that helps DS understand what a well-architected MLOps system looks like before building one.

Fits: Day 3–7 of 30-day plan, quick architectural orientation
Open course
Weights & Biases
Foundational

Effective MLOps: Model Development

Hamel Husain, Darek Kłeczek, Thomas Capelle · ~4h

Hands-on introduction to building reproducible ML prototypes, experiment tracking with W&B, iterating beyond baselines, and systematic model evaluation — all free and project-based. Perfect entry point for applying W&B tooling (a standard in industry) and building the discipline of tracked, reproducible experimentation.

Fits: Days 1–5 of 30-day plan, first tool-oriented MLOps course
Open course
Weights & Biases
Advanced

CI/CD for Machine Learning (GitOps)

Thomas Capelle, Hamel Husain · ~5h

Teaches GitOps patterns for ML: automating model training, evaluation, and deployment using GitHub Actions, W&B experiment tracking, and the ghapi and wandb Python clients. Directly maps to how senior MLEs set up reliable, auditable ML pipelines that trigger on code or data changes.

Fits: Days 25–35 of 60-day plan, after deployment fundamentals
Open course
DeepLearning.AI / AWS
Foundational

Generative AI with Large Language Models

Chris Fregly, Shelbee Eigenbrode, Mike Chambers (AWS); Andrew Ng · ~16h (3 weeks)

Covers the full LLM lifecycle — transformer architecture, pretraining, PEFT/fine-tuning, RLHF, and production deployment — with AWS lab environments. Gives a practitioner the end-to-end mental model needed before touching any LLM API in industry.

Fits: Week 1 — core foundation block
Open course
DeepLearning.AI
Foundational

How Transformer LLMs Work

Jay Alammar, Maarten Grootendorst · ~2h

Deep-dives into tokenization, embeddings, self-attention, KV cache, grouped query attention, and Mixture-of-Experts with Hugging Face code examples. Essential conceptual grounding before working with open-source LLMs or debugging inference issues.

Fits: Week 1 — pair with GenAI with LLMs
Open course
DeepLearning.AI / OpenAI
Foundational

ChatGPT Prompt Engineering for Developers

Isa Fulford, Andrew Ng · ~2h

Teaches core prompting principles — summarization, inference, transformation, expansion — with OpenAI API examples and a custom chatbot walkthrough. The fastest way to move from prompt guessing to systematic prompt engineering used in every LLM-powered product.

Fits: Day 3-5 — immediate practical boost
Open course
DeepLearning.AI
Core

Retrieval Augmented Generation (RAG)

Zain Hasan · ~24h (5 modules, 49 lessons)

Full production RAG stack: BM25, semantic search, hybrid search with Reciprocal Rank Fusion, Weaviate vector DB, chunking, prompt design, and evaluation with Arize Phoenix. Directly maps to the #1 enterprise LLM use case every DS encounters on the job.

Fits: Week 2 — after LLM fundamentals
Open course
DeepLearning.AI / LlamaIndex / TruEra
Core

Building and Evaluating Advanced RAG

Jerry Liu, Anupam Datta · ~2h

Sentence-window and auto-merging retrieval, plus the RAG Triad (Context Relevance, Groundedness, Answer Relevance) for systematic evaluation using TruLens. Closes the loop between building and measuring RAG quality — critical for shipping reliable pipelines.

Fits: Week 2-3 — immediately after RAG core course
Open course
DeepLearning.AI
Core

Agentic AI

Andrew Ng · ~8h

Covers the four agentic design patterns — reflection, tool use, planning, and multi-agent coordination — with Python implementations and production evaluation frameworks. The canonical course for understanding when and how to build agents beyond single LLM calls.

Fits: Week 3 — after RAG is solid
Open course
DeepLearning.AI / LangChain / Tavily
Core

AI Agents in LangGraph

Harrison Chase, Rotem Weiss · ~2h

Builds agents from scratch then re-implements them with LangGraph's stateful graph framework, covering agentic search, state persistence, and human-in-the-loop patterns. LangGraph is the dominant production agent orchestration framework; this is the official on-ramp.

Fits: Week 3-4 — concurrent with Agentic AI
Open course
DeepLearning.AI / CrewAI
Core

Multi AI Agent Systems with crewAI

João Moura · ~3h

Role-based multi-agent design with short-term, long-term, and shared memory, tool assignment, guardrails, and parallel/sequential/hierarchical agent cooperation using CrewAI. Translates directly to automating multi-step business workflows — customer support, research, financial analysis.

Fits: Week 4 — after LangGraph intro
Open course
Hugging Face
Advanced

Hugging Face AI Agents Course

Ben Burtenshaw, Sergio Paniego · ~15h (5 units + 3 bonus)

Theory and practice of AI agents using smolagents, LlamaIndex, and LangGraph — covering tool use, observations, fine-tuning for function-calling, and agent evaluation with a benchmark competition final. Bridges LLM theory to deployed, measurable agent systems.

Fits: Week 4-6 — capstone of agents track
Open course
LangChain Academy
Core

Introduction to LangGraph (LangChain Academy)

LangChain team · ~6h (55 lessons)

Comprehensive LangGraph fundamentals: state management, memory systems, human-in-the-loop, parallelization, sub-graphs, long-term memory, and deployment strategies. The official, most thorough treatment of LangGraph — more depth than the DeepLearning.AI short course.

Fits: Week 3-4 — primary LangGraph reference
Open course
Anthropic
Core

Anthropic Courses (Prompt Engineering + Tool Use)

Anthropic team · ~6h (5 notebook-based courses)

Five Jupyter-notebook courses: API fundamentals, prompt engineering, real-world prompting, prompt evaluations, and tool use with Claude — covering the complete production Claude workflow. Free and hands-on; essential for any DS using Claude in production pipelines or agentic tasks.

Fits: Week 2 — pair with prompt engineering track
Open course
DeepLearning.AI
Advanced

Finetuning Large Language Models

Sharon Zhou · ~1h

Covers when to fine-tune vs. prompt, data preparation, training on domain-specific datasets, and weight updating in LLMs. A concise primer for DS jobs that require adapting open-source models to proprietary datasets.

Fits: Week 5-6 — after core RAG/agents track
Open course
DataTalks.Club
Core

Data Engineering Zoomcamp

Alexey Grigorev et al. (DataTalks.Club community) · ~9 weeks (self-paced available)

Free 9-week program covering Docker/Terraform infrastructure, Kestra workflow orchestration, BigQuery data warehousing, dbt analytics engineering, Apache Spark batch processing, and Kafka streaming. Ties every major DE tool together in a capstone pipeline project — the closest free equivalent to a real DE job workflow.

Fits: Primary course, start Week 1 of 60-day plan
Open course
O'Reilly Media
Foundational

Fundamentals of Data Engineering: Plan and Build Robust Data Systems

Joe Reis & Matt Housley · ~10h (447 pages)

Covers the full data engineering lifecycle — generation, storage, ingestion, transformation, and serving — plus undercurrents like security, DataOps, orchestration, and architecture trade-offs. Provides the conceptual vocabulary and vendor-agnostic mental model every DE must internalize before picking specific tools.

Fits: Read in parallel with first 2 weeks of hands-on work
Open course
dbt Labs (dbt Learn)
Core

dbt Fundamentals

dbt Labs educator team (Beth Hipple, Dan Horner, Faith McKenna and others) · ~5h

Free self-paced course covering dbt modeling, sources, tests, documentation, and deployment using dbt Cloud — the entire ELT transformation layer. Analytics engineering with dbt is now a required skill on the vast majority of DS/DE job postings, making this the fastest-ROI 5 hours in the stack.

Fits: Week 2–3 alongside the DE Zoomcamp analytics module
Open course
Confluent Developer
Core

Apache Kafka 101

Tim Berglund (Confluent) · ~1.5h (16 modules)

Free course introducing Kafka's architecture — brokers, topics, partitions, producers, consumers, and offsets — with hands-on exercises for building real-time event streaming pipelines. Understanding Kafka is essential for any DS working with streaming feature stores, ML pipelines, or real-time inference systems.

Fits: Week 4, after completing the streaming module of the DE Zoomcamp
Open course
Dagster (Dagster University)
Core

Dagster Essentials

Dagster team · 6–10h

Free 9-lesson course (plus capstone) teaching asset-based pipeline orchestration with Dagster — software-defined assets, dependencies, resources, schedules, partitions, and sensors. Dagster's asset-first model is increasingly preferred over Airflow for ML pipelines because it natively tracks data lineage alongside code.

Fits: Week 4–5 as an alternative/complement to Airflow
Open course
Astronomer Academy
Core

Airflow 101 (Airflow 3)

Astronomer team · ~3h (12 modules)

Free learning path covering Airflow core concepts, the UI, DAG authoring, scheduling, connections, XComs, sensors, and the CLI — all updated for Airflow 3. Airflow remains the dominant orchestrator in enterprise data stacks and is named in the majority of senior DS/DE job requirements.

Fits: Week 4–5 alongside or instead of Dagster Essentials
Open course
Databricks / Coursera
Core

Databricks Lakehouse Fundamentals

Noah Gift (Pragmatic AI Labs) · ~2h (4 modules, 6 labs)

Free-to-audit course on lakehouse architecture, PySpark/SparkSQL with the Catalyst optimizer, Delta Lake ACID transactions, and medallion architecture (bronze→silver→gold). Databricks is the go-to platform at data-intensive companies and shows up in most mid-to-senior DS job descriptions.

Fits: Week 5–6 after learning Spark basics
Open course
Databricks Academy
Advanced

Apache Spark Programming with Databricks

Databricks instructor team · ~16h (4 modules × 4h)

Paid instructor-led ($1,500) deep dive into Spark DataFrame API, ETL pipeline construction, Spark Structured Streaming, Delta Lake integration, Unity Catalog, and performance optimization/tuning. The authoritative preparation course for the Databricks Associate Developer certification, which is increasingly requested in JDs.

Fits: Week 6–8, after completing Lakehouse Fundamentals
Open course
OD-ESS-DNGWSnowflake University
Core

Snowflake Data Engineering Workshop (Badge 5)

Snowflake University team · 6–12h

Free hands-on badge covering date/time types, tasks, Snowpipe, merge statements, and automating data pipelines within Snowflake — graded by the DORA robot with a shareable Credly badge. Snowflake is the dominant cloud data warehouse at high-growth companies, and hands-on fluency is a differentiator in DS interviews.

Fits: Week 6–7 after Snowflake Badges 1–4 or equivalent experience
Open course
ud257Udacity / Google
Foundational

A/B Testing

Carrie Grimes, Diane Tang, Caroline Buckey (all Google) · ~6h

Covers the full A/B test lifecycle: metric selection and validation, experiment design (sample size, power), policy and ethics, and results analysis including sanity checks. This is the canonical free industry intro — designed by Google engineers who run experiments at massive scale, making it directly applicable to DS interview questions and day-one job tasks.

Fits: Days 1–3 of a 30-day plan — the entry ramp for all experimentation topics
Open course
Cambridge University Press
Core

Trustworthy Online Controlled Experiments: A Practical Guide to A/B Testing

Ron Kohavi, Diane Tang, Ya Xu · ~20h (book, 480 pages)

Covers experiment trustworthiness (SRM checks, Twyman's Law), OEC design, CUPED variance reduction, speed/novelty effects, guardrail metrics, scaling experimentation platforms, and statistical pitfalls from practitioners who ran 20,000+ experiments/year at Microsoft, Google, and LinkedIn. This is the definitive industry reference — the 'bible of A/B testing' cited in virtually every tech company's experimentation documentation.

Fits: Days 4–14: core reading alongside or after the Udacity course
Open course
Maven (live cohort course)
Core

Accelerating Innovation with A/B Testing

Ron Kohavi · ~13h (5 live sessions × 2.5h)

Interactive live course covering OEC metric design, causality hierarchy of evidence, common pitfalls, cultural/organizational maturity for experimentation, quasi-experimental methods, and the relationship between A/B testing and ML — all with real examples from Amazon, Microsoft, and Airbnb. Taught by the co-author of the Kohavi book; the Q&A format surfaces nuances rarely found in written material.

Fits: Days 15–20: after reading the Kohavi book, to consolidate and stress-test understanding
Open course
Yale University Press (free online)
Core

Causal Inference: The Mixtape

Scott Cunningham (Baylor University) · ~25h (book, free HTML)

Covers potential outcomes, DAGs, matching, IV, regression discontinuity, difference-in-differences, and synthetic control with R/Stata code examples and economics applications. The accessible writing and worked policy examples (minimum wage, education interventions) build the quasi-experimental toolkit that industry DSes use when randomization is impossible.

Fits: Days 10–25: after A/B testing basics, for the observational/quasi-experimental toolkit
Open course
Open-source (GitHub Pages)
Core

Causal Inference for The Brave and True

Matheus Facure Alves (Senior Data Scientist, Nubank) · ~20h (free online book, Python)

Python-first treatment of randomized experiments, linear regression for causal inference, IV, matching, propensity scores, DiD, synthetic control, and regression discontinuity; Part II covers heterogeneous treatment effects, meta-learners, and debiased ML for personalization. The focus on tech-industry use cases (uplift modeling, A/B test analysis in Python) makes it the most directly job-ready causal inference text for practicing data scientists.

Fits: Days 15–30: parallel to The Mixtape, for Python practitioners wanting industry framing
Open course
bradyneal.com (free, self-paced)
Advanced

Introduction to Causal Inference

Brady Neal (Mila / McGill) · ~40h (14-week course + lecture notes PDF)

Rigorous treatment of potential outcomes, graphical causal models, identification (backdoor, frontdoor, do-calculus), IV, sensitivity analysis, causal discovery, transportability, counterfactuals, and causal representation learning — integrating epidemiology, economics, and ML perspectives. Essential for DSes who need to reason formally about assumptions and limitations when designing experiments or analyzing observational data in production.

Fits: Days 20–60: deep-dive track for roles involving causal modeling or policy decisions
Open course
cd14250Udacity
Advanced

Causal Inference (Udacity — Quasi-Experimental Methods)

Jonathan Hershaff (Senior Data Scientist) · ~13h

Hands-on Python course covering interrupted time series, difference-in-differences, event studies, synthetic control, and regression discontinuity — the five quasi-experimental designs most commonly used in tech industry measurement. Includes a capstone applying these methods to a Super Bowl ad campaign, making the workflow concrete and portfolio-ready.

Fits: Days 25–40: after Mixtape/Brave-and-True theory, for Python implementation practice
Open course
Coursera / University of Pennsylvania
Foundational

A Crash Course in Causality: Inferring Causal Effects from Observational Data

Jason A. Roy (Professor & Chair of Biostatistics, Rutgers; Co-Director, Center for Causal Inference, Penn) · ~12h (5 weeks)

Covers potential outcomes notation, DAGs, matching, propensity scores, inverse probability weighting, and instrumental variables in R, with a biostatistics perspective that complements econometrics-focused texts. Provides a concise, mathematically careful foundation in the core identification assumptions that underpin all causal claims in DS work.

Fits: Days 5–15: excellent complement to Udacity A/B Testing for building causal reasoning fundamentals
Open course
MIT Press (Murphy)
Core

Probabilistic Machine Learning: An Introduction (Vol. 1)

Kevin P. Murphy · ~100h

Unified probabilistic treatment of linear models, neural networks, kernel methods, latent variable models, Bayesian inference, and modern deep learning. The free draft PDF and JAX/PyTorch notebooks make it the modern successor to Bishop for practitioners who want rigorous uncertainty quantification in industry models.

Fits: Days 15–45 of a 60-day plan
Open course
MIT Press (Murphy)
Advanced

Probabilistic Machine Learning: Advanced Topics (Vol. 2)

Kevin P. Murphy · ~120h

Covers variational inference, diffusion models, normalizing flows, graph neural networks, reinforcement learning, and causality. Essential for DS roles that work on generative models, probabilistic forecasting, or cutting-edge research at scale.

Fits: After Vol. 1, for specialized or research-track DS
Open course
Springer / Microsoft Research
Advanced

Pattern Recognition and Machine Learning (PRML)

Christopher M. Bishop · ~100h

Classic Bayesian perspective on classification, regression, neural networks, kernel methods, graphical models, mixture models, and approximate inference. The gold standard for understanding probabilistic foundations—especially Bayesian inference—that underpin modern ML systems.

Fits: Days 30–60 of a 60-day plan, alongside or after ISLP
Open course
O'Reilly Media
Core

Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow, 3rd ed.

Aurélien Géron · ~60h

End-to-end ML projects using Scikit-Learn and TensorFlow/Keras: regression, trees, SVMs, neural nets, CNNs, RNNs, transformers, diffusion models, and RL. The most practical book for building production ML pipelines quickly—directly maps to job interview coding tasks.

Fits: Days 1–20 in parallel with theory
Open course
Wiley
Foundational

Storytelling with Data: A Data Visualization Guide for Business Professionals

Cole Nussbaumer Knaflic · ~12h

Teaches data visualization principles—choosing chart types, removing clutter, directing attention, and crafting a narrative—through business-focused examples. Critical for DS practitioners who must communicate insights to non-technical stakeholders, which is a near-universal job requirement.

Fits: Days 1–5, read early for immediate project use
Open course
O'Reilly Media
Foundational

Practical Statistics for Data Scientists, 2nd ed.

Peter Bruce, Andrew Bruce, Peter Gedeck · ~30h

Covers exploratory data analysis, sampling distributions, hypothesis testing, regression, classification, and statistical machine learning using both R and Python. Provides the working statistical vocabulary and intuition that industry DS practitioners use daily—from A/B testing to model evaluation.

Fits: Days 1–10, first statistics reference
Open course
Chapman & Hall / CRC (Taylor & Francis)
Advanced

Statistical Rethinking: A Bayesian Course with Examples in R and Stan

Richard McElreath · ~60h

Builds Bayesian data analysis from the ground up: DAGs, multilevel models, MCMC, model comparison, and causal inference using Stan. Indispensable for DS roles requiring causal reasoning, experiment design, or probabilistic forecasting—teaches how to think about models, not just fit them.

Fits: Days 30–60, after foundational statistics
Open course
NeetCode
Core

NeetCode 150

Navdeep Singh (ex-Google, ex-Amazon) · ~80-120h

150 curated LeetCode-style problems across 18 DSA patterns (arrays & hashing, two pointers, sliding window, trees, graphs, dynamic programming, and more) with video walkthroughs and pattern explanations. Builds the pattern-recognition speed that SWE and MLE coding screens demand at FAANG and top DS shops.

Fits: Days 1-20 of a 30-day plan; complete before any phone screen
Open course
DataLemur
Core

SQL Interview Questions Practice

Nick Singh (ex-Facebook, ex-SafeGraph) · ~25-40h

200+ SQL interview questions from real FAANG and fintech companies, ranging from easy joins to hard window-function problems like rolling averages and Y-o-Y growth, with a built-in browser SQL editor and full solution walkthroughs. SQL is tested in nearly every DS interview loop, making this the most targeted SQL drill available.

Fits: Days 5-25 of a 30-day plan; run in parallel with coding prep
Open course
StrataScratch
Core

Coding & Analytics Interview Practice Platform

Nathan Rosidi (founder; adjunct professor, University of San Francisco) · ~30-50h

1,000+ real interview problems in SQL and Python sourced from 200+ companies (Google, Meta, Amazon, Airbnb), plus non-coding questions covering statistics, probability, product sense, and business cases. Complements DataLemur with Python analytical questions and broader coverage of DS-specific problem types.

Fits: Days 10-30 of a 30-day plan; ramp after SQL fundamentals solidified
Open course
Self-published (acethedatascienceinterview.com)
Core

Ace the Data Science Interview

Nick Singh & Kevin Huo (both ex-Facebook) · ~30-40h

201 real DS interview questions with full solutions across probability, statistics, machine learning, SQL & database design, Python coding, and product analytics — drawn from Facebook, Google, Amazon, Netflix, Two Sigma, and Citadel. The only single resource that closes the gap across every DS interview sub-topic simultaneously.

Fits: Weeks 3-4 of a 30-day plan; use as a full-loop simulation and gap-filler
Open course
huyenchip.com (open source)
Core

Introduction to Machine Learning Interviews Book

Chip Huyen (ex-Netflix, ex-NVIDIA, ex-Snorkel AI) · ~20-30h

200+ technical knowledge questions across math (algebra, calculus, probability, stats), CS fundamentals (algorithms, complexity), and ML topics (classical methods, deep learning architectures for NLP/CV/RL, training, and evaluation) alongside a practical guide to ML job roles and interview pipelines. Free and open-source; written by a practitioner who taught the Stanford ML systems course.

Fits: Days 1-15 of a 30-day plan; read Part I first for interview strategy, drill Part II questions throughout
Open course
ByteByteGo
Advanced

Machine Learning System Design Interview

Ali Aminian (ex-Google, ex-Adobe Staff ML Engineer) & Alex Xu · ~20-30h

A 7-step framework for answering any ML system design question, applied to 10 production-grade systems: visual search, YouTube video search, video recommendation, harmful content detection, ad click prediction, event recommendation, news feed personalization, and more. Directly maps to the open-ended system design round in senior DS and MLE interviews.

Fits: Weeks 5-8 of a 60-day plan; tackle after core ML fundamentals are solid
Open course
Educative.io
Advanced

Grokking the Machine Learning Interview

Educative team (ex-MAANG engineers) · ~15h (64 lessons, 6 mock interviews)

End-to-end ML system design problems — search ranking, recommendation systems, ad prediction, fraud detection, and dynamic pricing — emphasizing metrics selection, embedding design, pipeline architecture, and trade-off evaluation. Provides a structured problem-solving framework that mirrors how interviewers at Google and Meta actually score system design answers.

Fits: Weeks 5-8 of a 60-day plan; pair with the Aminian/Xu book for double coverage
Open course
Evidently AI
Advanced

ML & LLM System Design: 800 Case Studies

Evidently AI team · ~10-20h (self-paced browsing)

800 real-world case studies from 150+ companies (Netflix, Airbnb, DoorDash, and others) covering production ML and LLM systems including recommenders, search and ranking, fraud detection, RAG, and AI agents — each with design, evaluation, and deployment detail. Gives concrete vocabulary and battle-tested patterns to cite during system design rounds, turning abstract answers into grounded references.

Fits: Ongoing reference throughout weeks 4-8; read 2-3 case studies per day during system design prep
Open course
Data Interview Pro (emmading.com)
Core

Data Science Interview Mastery Course Package

Emma Ding (ex-Airbnb Data Engineer/Scientist) · ~30h total (6 courses bundled)

An end-to-end bundle covering product case/metrics, statistics, SQL, ML concepts, coding, and behavioral interviews — each as a standalone module with video lessons, quizzes, and 200+ interview questions. Gives industry DS candidates a single, structured path through every round type they will encounter at tech companies, from defining KPIs to STAR stories.

Fits: Days 1-21 of a 30-day sprint — start with Product Case and Behavioral modules first
Open course
Data Interview Pro (emmading.com)
Core

Product Case Interview Mastery

Emma Ding (ex-Airbnb Data Engineer/Scientist) · ~30h

Six modules covering metrics taxonomy, engagement and CLV metrics, A/B testing design and pitfalls, problem diagnosis, product improvement frameworks, and strategic decision-making — plus 286 practice questions and three cheat sheets. Directly addresses the product/business case round that filters out most DS candidates at top-tier tech companies.

Fits: First two weeks — before any live phone screens
Open course
Exponent (tryexponent.com)
Core

Data Science Interview Prep Course

Exponent team (practitioners from Meta, Amazon, Google, DoorDash) · Self-paced; subscription $79/mo or ~$12/mo annually

Structured lessons across statistics, experimentation, SQL, ML concepts, ML coding, product sense and case studies, and behavioral interviews — each with rubrics, real-world examples, and expert insights. Includes free peer mock interviews and paid expert coaching sessions, making it one of the only platforms that covers both content review and live practice in one subscription.

Fits: Weeks 2-4 — use mock interview feature after content review
Open course
Interview Query (interviewquery.com)
Core

Interview Query — DS Interview Platform

Jay Feng (Founder, ex-Nextdoor, ex-Monster/Jobr) · 30+ h of course content; 50+ take-home challenges

500+ real interview questions with solutions spanning SQL, Python, product metrics, A/B testing, statistics, ML system design, and business case — plus 50+ real take-home challenges from Airbnb, Amazon, Doordash, and Uber with code solutions. The 1,600+ company-specific interview guides and take-home challenge library are the most realistic simulation available for the actual hiring pipeline.

Fits: Throughout 60-day plan — daily question practice + take-home reps in week 4+
Open course
DataLemur / Teachable
Foundational

Ace the Data Job Hunt (video course)

Nick Singh (ex-Facebook, ex-Google; CEO of DataLemur) · ~5-8h (25+ video modules)

Resume optimization with critiques and templates, portfolio project strategy, cold-email networking tactics, and STAR-based behavioral interview preparation — the exact soft-skills layer most technical DS candidates neglect. Covers how to get referrals, craft a compelling personal story, and avoid the six most common portfolio mistakes that stall job searches.

Fits: Day 1 — complete before sending any applications
Open course
DataMasked (datamasked.com)
Advanced

A Collection of Data Science Take-Home Challenges (Interview Material)

Giulio Palombo (ex-Airbnb Data Scientist) · ~20-40h depending on challenge depth

20 take-home challenges with real-world datasets, 40 product/case questions with answers, and reusable frameworks for SQL, Python, and R solutions — including how to derive A/B test ideas from data. Take-home challenges are the single hardest round to prepare for without realistic data; this is the canonical resource used by DS candidates at Facebook, Pinterest, and similar companies.

Fits: Week 3-6 of a 60-day plan — after core theory is solid
Open course
Self-published (lewis-lin.com)
Core

Decode and Conquer: Answers to Product Management Interviews (5th Edition)

Lewis C. Lin (ex-Microsoft Director of PM, ex-Google AdWords PM) · ~15h (528 pages)

The CIRCLES Method, AARM Method, DIGS Method, and the new Metrics Mastery System for navigating complex KPI questions — the 5th edition (2025) adds AI Fluency Fundamentals and Enterprise vs. Consumer product thinking. Indispensable for DS candidates in product analytics or product DS roles where the interview panel includes PMs who expect structured metric definition and feature-impact reasoning.

Fits: Days 10-20 — read the metrics and A/B chapters alongside product-sense practice
Open course
DataLemur (datalemur.com)
Foundational

Data Science Behavioral Interview Questions Guide

Nick Singh · ~2h

Free guide covering the STAR framework applied to DS-specific scenarios — cross-functional conflict, data quality crises, feature engineering trade-offs, and ethical decision-making — with 18 annotated example questions and six preparation strategies. A free, focused primer that maps STAR storytelling to the situations data scientists actually face, not generic business examples.

Fits: Day 3-5 — read early, then revisit weekly to refine your stories
Open course
Kaggle
Foundational

Kaggle Learn Micro-Courses

Kaggle team (multiple instructors per course) · ~2-4h per course; 14 courses total

Bite-sized, browser-based courses covering Python, Pandas, Intro to ML, Intermediate ML, Feature Engineering, Deep Learning, NLP, Time Series, Data Cleaning, and more. Each micro-course provides a working Kaggle Notebook environment so learners immediately apply concepts — ideal for closing skill gaps before entering competitions.

Fits: Days 1-5: foundational skill sprint before first competition entry
Open course
Kaggle
Core

Kaggle Competitions Platform

Community-driven (Grandmasters, teams) · Ongoing; 40-200h per competition

Hands-on ML problem-solving across classification, regression, NLP, computer vision, time-series, and recsys tasks against global leaderboards. Studying top-ranked public notebooks and discussion threads after each competition is the fastest way an industry DS learns real-world feature engineering, ensembling, and debugging at scale.

Fits: Days 5-30+: continuous practice alongside coursework
Open course
MIT Press / incompleteideas.net
Foundational

Reinforcement Learning: An Introduction (2nd ed.)

Richard S. Sutton & Andrew G. Barto · ~80-120h (self-paced reading)

The canonical RL textbook covering MDPs, dynamic programming, Monte Carlo methods, temporal-difference learning (Q-learning, SARSA), function approximation, policy gradient, and actor-critic methods. The full PDF is freely available from the authors' site; it establishes the mathematical vocabulary every RL practitioner must know.

Fits: Days 1-30: core reading alongside DeepMind lectures
Open course
Google DeepMind / UCL Centre for AI
Core

DeepMind x UCL RL Lecture Series 2021

Hado van Hasselt, Diana Borsa, Matteo Hessel · ~20h (13 lectures)

A 13-lecture self-contained introduction to RL and deep RL at Master's level, covering MDPs, sample-based learning, Q-learning/SARSA, function approximation, off-policy learning, eligibility traces, and modern deep RL algorithms like Rainbow DQN. Delivered by active DeepMind researchers, it bridges Sutton & Barto theory to production-grade implementations.

Fits: Days 10-25: structured video complement to the Sutton & Barto text
Open course
OpenAI
Advanced

Spinning Up in Deep RL

Josh Achiam (OpenAI / UC Berkeley) · ~30-40h

A practitioner's guide to deep RL that includes clean standalone PyTorch implementations of VPG, TRPO, PPO, DDPG, TD3, and SAC alongside thorough conceptual explanations. The 'Spinning Up as a Deep RL Researcher' essay and curated paper list are especially valuable for anyone aiming to apply RL in production recommendation, robotics, or optimization problems.

Fits: Days 20-45: implementation-focused follow-on after lectures
Open course
Hugging Face
Core

Hugging Face Deep RL Course

Thomas Simonini · ~30h (8+ units, ~3-4h/week self-paced)

A free, hands-on deep RL course covering value-based methods (DQN), policy-gradient (PPO), actor-critic (A2C), multi-agent RL, and model-based RL, all with Google Colab notebooks. Uses Stable Baselines3, RL Baselines3 Zoo, Sample Factory, and CleanRL — the same libraries used in industry research pipelines.

Fits: Days 15-35: practical coding track running in parallel with theory
Open course
DataTalks.Club
Core

MLOps Zoomcamp

Alexey Grigorev, Cristian Martinez, Emeli Dral · ~9 weeks, 5-15h/week

End-to-end MLOps covering experiment tracking (MLflow), ML pipeline orchestration, model deployment (batch, web API, streaming with Flask & AWS Lambda), and production monitoring (Prometheus, Grafana, Evidently AI). A DS without MLOps skills cannot take models past notebooks — this course is the most direct free path to closing that gap.

Fits: Days 30-60: after core ML is solid, before job applications
Open course
DrivenData
Core

DrivenData Competitions

Community-driven · ~40-100h per competition

Social-impact ML competitions (health, climate, education, disaster response) where participation signals domain diversity beyond Kaggle to interviewers. Competitions typically run 2-3 months with clean data documentation and a 125K+ community, making them excellent for building a portfolio story around real-world impact.

Fits: Days 20-60: alongside or after first Kaggle competition
Open course
Calibration

Spend your days on the weakest links

These plans assume momentum, not mastery. Be ruthless: accelerate past what you own, and refuse to skip the offer-deciding gaps.

Accelerate / audit

  • DL theory (Day 7)
  • LLM fundamentals (Day 8 AM)
  • Fine-tuning theory (Day 10)
  • Classical-ML math (Day 3 AM)
  • Python tooling (Day 4 if repos already tested/typed)

Do NOT skip

  • Day 2 A/B testing + Day 13 product sense - quant is not product-experimentation framing (the #1 quant-to-DS gap)
  • Day 5 MLOps deployment end-to-end - research code is not a tracked, served, monitored model
  • Day 6 storytelling + Day 14 quantified resume - translating research to business impact (#2 hiring skill)
  • Day 11 SQL-interview speed - a separate skill from knowing SQL
  • Day 13 behavioral - rehearse alpha-research/LLM work as STAR business outcomes
  • Day 9-10 RAG WITH evaluation - the eval gate is the 2026 differentiator most skip

Unfair advantages

  • Stats/probability interviews (quant edge)
  • ML system design for ranking/retrieval (alpha pipelines map to two-tower recsys)
  • The +43% AI-skill premium - you already have 2+ GenAI skills; make them legible

The six-point “job-ready” test

Hit all six and you clear the 2026 industry-DS bar.

1Write advanced SQL incl. window functions, live
2Reason about A/B tests and causal inference
3Build + evaluate a classical ML model and a GenAI/RAG system
4Ship a model behind an API with tracking and monitoring
5Tell the business-impact story
6Present 3 deployed, documented projects you can defend end-to-end
Boil-the-ocean appendix

Every resource, in one place

The highest-leverage subset is embedded in the daily plan. This is the full reference catalog - 320+ courses, books, and tools across every area of the field.

Math foundations

Statistics & probability

Classical ML

Deep learning (PyTorch-first)

Python / SQL / tooling

Production / MLOps / SWE

GenAI / LLM

Interview prep

Practice & portfolio

Stanford CS231n — Deep Learning for Computer Vision

Stanford CS224n — NLP with Deep Learning

Stanford — Mining Massive Datasets & Databases

Stanford — ML theory, statistics & classical AI

Stanford — LLMs, Transformers & RL

Industry — MLOps & production ML

Industry — GenAI / LLM / RAG / Agents

Industry — Data engineering for DS

Industry — Experimentation, A/B Testing & Causal Inference

The data-science book canon

Interview prep — technical (coding, SQL, ML, system design)

Interview prep — product, behavioral, take-home & careers

Practice, competitions, communities & reinforcement learning

More resources