College Student to ML/AI Engineer

Become reliable with Python, Git, CLI workflows, data manipulation, SQL, EDA, and the math/statistics needed to understand model behavior.

1. 1

   Module 1BEGINNER7 min

   Python for ML Engineers, Not Just Programmers

   Many students know syntax but not engineering-grade Python. This module builds reliable habits before modeling starts.

   Topics, prerequisites, and deliverables

   Builds on Basic programming familiarity

   Depth 6-8 hrs

   Python data structures and functionsModules, environments, and packaging basicsTyping, debugging, notebooks versus scriptsVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Build a reusable data-processing package
   • Create a small CLI utility
   • Document setup and usage cleanly
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
2. 2

   Module 2BEGINNER7 min

   Linux, Git, CLI, and Reproducible Dev Environments

   ML engineers live in terminals, repos, and environments. Students often lack this muscle, and it slows every later module.

   Topics, prerequisites, and deliverables

   Builds on Module 1

   Depth 4-6 hrs

   Shell basics and file operationsGit workflow and branchesEnvironment management and dependency pinningMakefiles and project automationVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Set up a clean repo with scripts, pre-commit, and a repeatable README workflow
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
3. 3

   Module 3BEGINNER6 min

   Agentic Coding Tools for Students

   Coding agents will write a lot of a student's code from now on. The difference between learning faster and hiding behind the tool is a set of habits (explain-then-decide, verify, restrict permissions) best built before the rest of the path.

   Topics, prerequisites, and deliverables

   Builds on Modules 1-2

   Depth 3-4 hrs

   The rule: the agent explains, you decideThe gather, act, verify loop and why tests matterCLAUDE.md and AGENTS.md with learning rulesDelegation that teaches vs. tasks to do yourself firstPermissions, plan mode, and destructive commandsVerification habits and the interview realityVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • A CLAUDE.md with learning rules in your course project, one exercise implemented yourself then reviewed by an agent without rewriting, and a written note on what the review taught you
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.

   Open module
4. 4

   Module 4INTERMEDIATE7 min

   Math for ML I: Linear Algebra That Actually Matters

   Learners need enough linear algebra to understand what models are doing instead of memorizing formulas blindly.

   Topics, prerequisites, and deliverables

   Builds on High-school math

   Depth 8-10 hrs

   Vectors, matrices, and dot productsMatrix multiplication, norms, and projectionsEigen intuition and SVD intuitionVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Work through derivations
   • Implement core operations in NumPy
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
5. 5

   Module 5INTERMEDIATE8 minYou are here

   Math for ML II: Probability, Statistics, and Uncertainty

   Strong ML judgment needs probabilistic reasoning, uncertainty awareness, and better experiment interpretation.

   Topics, prerequisites, and deliverables

   Builds on Module 4

   Depth 8-10 hrs

   Random variables and distributionsExpectation, variance, and Bayes ruleSampling, confidence intervals, and bias-varianceVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Build simulation notebooks for uncertainty and sampling intuition
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Resume
6. 6

   Module 6INTERMEDIATE7 min

   Math for ML III: Calculus, Optimization, and Gradients

   Students need a practical understanding of derivatives and optimization before neural training makes sense.

   Topics, prerequisites, and deliverables

   Builds on Modules 4-5

   Depth 6-8 hrs

   Derivatives and partial derivativesChain rule and gradient intuitionConvexity and gradient descentVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Implement gradient descent from scratch on simple objectives
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
7. 7

   Module 7BEGINNER6 min

   NumPy, Pandas, and Data Manipulation for Model Building

   Data work is the daily job. This module turns raw tables into train-ready datasets with discipline.

   Topics, prerequisites, and deliverables

   Builds on Modules 1-2

   Depth 6-8 hrs

   Arrays and vectorizationDataframes, joins, and groupbyMissing data handling and leakage pitfallsVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Build an end-to-end data prep notebook from raw CSVs to a clean dataset
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
8. 8

   Module 8BEGINNER5 min

   SQL for Analytics and ML Pipelines

   ML engineers need to query data, validate datasets, and reason about joins and aggregates independently.

   Topics, prerequisites, and deliverables

   Builds on Modules 1-2

   Depth 5-7 hrs

   Joins, CTEs, and window functionsDataset creation queriesData quality checks and feature extraction SQLVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Write SQL for dataset creation and validation checks
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
9. 9

   Module 9INTERMEDIATE6 min

   Software Engineering Fundamentals for Data and ML Projects

   Students need stronger habits before touching larger systems. This module makes later MLOps and production work feasible.

   Topics, prerequisites, and deliverables

   Builds on Modules 1-3

   Depth 6-8 hrs

   Code organization and interfacesTesting and loggingConfig management and refactoringVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Refactor a notebook-heavy toy project into a testable package structure
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
10. 10

    Module 10BEGINNER6 min

    Data Visualization and Exploratory Analysis With Judgment

    EDA should drive decisions and reveal risk, not become a gallery of random charts.

    Topics, prerequisites, and deliverables

    Builds on Modules 5 and 7

    Depth 4-6 hrs

    Distribution inspection and imbalance analysisLeakage and outlier detectionCommunication of data findingsVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

    • Produce an EDA report with concrete modeling implications
    • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
    • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
    • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

    Open module

Learn the complete supervised ML loop: problem framing, baselines, model choice, feature engineering, evaluation, debugging, and representation basics.

1. 11

   Module 11INTERMEDIATE7 min

   Supervised Learning Foundations

   This is the real entry into ML, with concepts tied directly to engineering choices and baselines.

   Topics, prerequisites, and deliverables

   Builds on Modules 4-7

   Depth 8-10 hrs

   Problem framingRegression and classificationLoss functions, regularization, and overfittingVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Train and compare baseline supervised models
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
2. 12

   Module 12INTERMEDIATE6 min

   Classical ML Algorithms and When to Use Them

   Learners need model selection judgment, not just library usage.

   Topics, prerequisites, and deliverables

   Builds on Module 11

   Depth 8-10 hrs

   Linear models and logistic regressionTrees, random forests, and boostingSVMs, kNN, and Naive BayesVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Run a benchmark on a real tabular dataset and defend model choice
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
3. 13

   Module 13INTERMEDIATE7 min

   Feature Engineering and Data Leakage Defense

   Real-world ML performance often comes from feature design and leakage control, not model complexity alone.

   Topics, prerequisites, and deliverables

   Builds on Modules 10-12

   Depth 6-8 hrs

   Encodings and normalizationTemporal and target leakageDomain signal design and slicingVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Create a leakage-safe feature pipeline with documented assumptions
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
4. 14

   Module 14INTERMEDIATE7 min

   Evaluation, Metrics, and Experimental Design

   Accuracy is not enough. Learners need to define success through metrics, costs, and evaluation context.

   Topics, prerequisites, and deliverables

   Builds on Modules 5 and 11-13

   Depth 8-10 hrs

   Precision, recall, F1, ROC, PRCalibration and ranking metricsOffline versus online evaluationExperiment framingVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Build a metric-selection memo and reusable evaluation harness
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
5. 15

   Module 15INTERMEDIATE7 min

   Model Debugging and Error Analysis

   Strong practitioners know how to improve models methodically instead of guessing.

   Topics, prerequisites, and deliverables

   Builds on Modules 11-14

   Depth 6-8 hrs

   Residuals and confusion analysisSlice-based evaluationLabel issues and ablation thinkingVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Produce an error analysis report with prioritized next actions
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
6. 16

   Module 16INTERMEDIATE8 min

   Unsupervised Learning, Representation, and Dimensionality Reduction

   Needed for clustering, anomaly work, and later representation learning intuition.

   Topics, prerequisites, and deliverables

   Builds on Modules 4-7 and 11

   Depth 6-8 hrs

   Clustering and anomaly detectionPCA and dimensionality reductionRepresentation quality intuitionVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Complete a clustering analysis and dimensionality reduction walkthrough
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module

Build neural-network, PyTorch, vision, sequence, transformer, and representation intuition before moving into LLM applications.

1. 17

   Module 17INTERMEDIATE6 min

   Neural Networks From Scratch

   Deep learning becomes much more intuitive when learners build the primitives themselves.

   Topics, prerequisites, and deliverables

   Builds on Modules 4-6 and 11

   Depth 8-10 hrs

   Perceptrons and activationsForward pass and backprop intuitionLoss and optimization loopsVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Implement a tiny neural net in NumPy
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
2. 18

   Module 18INTERMEDIATE6 min

   Deep Learning With PyTorch

   This module turns neural intuition into practical training loops, checkpoints, and reusable code.

   Topics, prerequisites, and deliverables

   Builds on Module 17

   Depth 8-10 hrs

   Tensors and autogradTraining loops and optimizersBatching, regularization, and checkpointsVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Train an MLP or CNN in PyTorch with reusable training code
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
3. 19

   Module 19INTERMEDIATE6 min

   CNNs, Vision Pipelines, and Transfer Learning

   Vision work teaches transfer learning, augmentation, and domain adaptation patterns that generalize well.

   Topics, prerequisites, and deliverables

   Builds on Modules 17-18

   Depth 8-10 hrs

   CNN intuition and convolutionsData augmentationTransfer learning and fine-tuningVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Complete an image classification project using transfer learning
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
4. 20

   Module 20INTERMEDIATE6 min

   Sequence Models, Attention, and the Road to Transformers

   Learners need the pre-transformer intuition without getting lost in historical detail.

   Topics, prerequisites, and deliverables

   Builds on Modules 17-18

   Depth 6-8 hrs

   RNN and LSTM intuitionSequence tasks and attentionEncoder-decoder framingVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Build a simple sequence model and attention demo
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
5. 21

   Module 21ADVANCED7 min

   Transformers and Modern NLP Fundamentals

   This is the gateway into modern AI engineering and needs more than a buzzword-level treatment.

   Topics, prerequisites, and deliverables

   Builds on Modules 18 and 20

   Depth 10-12 hrs

   Tokenization and embeddingsSelf-attention and positional encodingPretraining versus fine-tuningEncoder versus decoder modelsVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Fine-tune a small transformer for a text task and explain architecture choices
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
6. 22

   Module 22ADVANCED6 min

   Fine-Tuning and Post-Training: LoRA, SFT, DPO, and Reasoning RL

   The college path had no adaptation module. This one closes the gap and adds where reasoning models come from, so students can read a model card, make the prompt-vs-retrieval-vs-fine-tune decision, and run a complete post-training project on one GPU.

   Topics, prerequisites, and deliverables

   Builds on Modules 18 and 21

   Depth 10-12 hrs

   What fine-tuning changes (behavior) and does not (knowledge)The decision order: prompt, retrieval, fine-tune, RLLoRA and QLoRA: parameter-efficient adaptationSFT data quality and coverage; synthetic data with verificationDPO from preference pairsRLVR and GRPO: why reasoning models reasonVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • A repository with data generation and verifier-filtering, a LoRA training script for a small open-weight model on a narrow verifiable task, an eval script, and a README table comparing base, fine-tuned, and large model on accuracy, latency, and cost
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.

   Open module

Turn model knowledge into product systems: LLM features, RAG, agents, data pipelines, serving, MLOps, monitoring, evals, and system design tradeoffs.

1. 23

   Module 23ADVANCED15 min

   LLM Application Engineering

   Learners need to understand what teams actually ship with LLMs: structured outputs, failure handling, and cost-aware prompting.

   Topics, prerequisites, and deliverables

   Builds on Modules 21-22

   Depth 8-10 hrs

   Prompting strategiesContext windows and structured outputsTool calling basicsHallucination, latency, and cost tradeoffsVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Build a robust LLM feature with typed outputs and fallback handling
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
2. 24

   Module 24ADVANCED6 min

   Embeddings, Retrieval, and RAG Systems

   RAG systems demand representation thinking, retrieval quality judgment, and realistic failure analysis.

   Topics, prerequisites, and deliverables

   Builds on Modules 14, 21, and 23

   Depth 10-12 hrs

   Embeddings and vector searchChunking and indexingReranking and retrieval pipelinesRetrieval failure modesVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Implement a RAG pipeline with retrieval benchmarks
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
3. 25

   Module 25ADVANCED10 min

   Agents, Tool Use, and Workflow Orchestration

   Modern AI systems often need tools and orchestration, but indiscriminate autonomy creates brittle products.

   Topics, prerequisites, and deliverables

   Builds on Modules 23-24

   Depth 8-10 hrs

   Agent loops and tool selectionPlanning limits and workflow graphsMemory patterns and guardrailsVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Build a constrained tool-using agent with trace logs and guardrails
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
4. 26

   Module 26ADVANCED6 min

   Context and Harness Engineering

   The agent loop is the model's contribution; the context and the harness are the student's. This module builds both: what the model sees under a budget, and the runtime that validates, gates, verifies, and traces what it does.

   Topics, prerequisites, and deliverables

   Builds on Modules 23-25

   Depth 10-12 hrs

   The context budget; scoping tools per task; reducing tool results in codeWorking, episodic, and long-term memory with write policiesCompaction without amnesia; layout for prompt cachingThe five harness layers and a minimal harness with scoped tools, validation, budgets, approval pauses, and tracesVerification loops; the never-again loop; sandboxingVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • The agent from the previous module wrapped in a persistent harness, with traces demonstrating a refused out-of-scope call, a refused invalid-args call, an approval pause resumed in a new process, a budget stop, and a corrected verification failure, plus a 40% token reduction on a fixed 20-task set
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.

   Open module
5. 27

   Module 27ADVANCED5 min

   MCP: Building a Tool Server

   MCP is the standard way agents reach tools, and a working server is one of the most visible student portfolio projects available: concrete, pluggable into tools recruiters use, and evidence of understanding how agents connect to the world.

   Topics, prerequisites, and deliverables

   Builds on Modules 25-26

   Depth 6-8 hrs

   Roles and primitives: host, client, server; tools, resources, prompts; stdio and HTTPBuilding a server with the Python SDK; testing with the inspector; connecting to a coding agent and your harnessDescriptions as the interface: when-to-use, return shape, side-effect flagsInput validation and small returnsThird-party servers as untrusted code; where A2A fitsVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • A published MCP server for a system you use with three tools (one side-effecting) and a resource, tested in the inspector, connected to a coding agent, with a 15-task tool-selection eval in the README
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.

   Open module
6. 28

   Module 28ADVANCED4 min

   Data Pipelines, Feature Pipelines, and Training Workflows

   Students need to understand how models get built repeatedly inside teams, not just once in a notebook.

   Topics, prerequisites, and deliverables

   Builds on Modules 8 and 11-15

   Depth 8-10 hrs

   Batch pipelines and lineageData versioning and artifactsFeature pipelines and training jobsVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Design a training pipeline with reproducible steps and artifact tracking
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
7. 29

   Module 29ADVANCED5 min

   Model Serving, APIs, Inference, and Performance Tradeoffs

   The model is not the product. Inference systems, APIs, and hardware tradeoffs matter.

   Topics, prerequisites, and deliverables

   Builds on Modules 18 and 23-28

   Depth 8-10 hrs

   Batch versus online inferenceREST and serving patternsPackaging, caching, and benchmarkingCPU and GPU tradeoffsVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Serve a model behind an API and benchmark latency
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
8. 30

   Module 30ADVANCED5 min

   MLOps, CI/CD, Testing, and Safe Releases for ML Systems

   This module formalizes data tests, model tests, deployment safeguards, and release workflows.

   Topics, prerequisites, and deliverables

   Builds on Modules 28-29

   Depth 8-10 hrs

   Data and model validationCI/CD for MLExperiment tracking and registriesRollback and canary ideasVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Create a CI-tested ML repo with validation steps
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
9. 31

   Module 31ADVANCED5 min

   Observability, Monitoring, Drift, and LLM Evals

   Shipping is not enough. Learners must know how models and LLM systems degrade in production.

   Topics, prerequisites, and deliverables

   Builds on Modules 14 and 23-30

   Depth 8-10 hrs

   Drift and monitoring signalsAlerting and feedback loopsHuman evaluation and LLM eval harnessesVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Build a monitoring plan and evaluation dashboard spec
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
10. 32

    Module 32ADVANCED6 min

    Agent Evals and AI Security

    Two questions decide whether an agent ships: does it work reliably after the next change, and what happens when someone tries to misuse it. Both are answered by the same artifact, a task suite with adversarial cases that runs on every change.

    Topics, prerequisites, and deliverables

    Builds on Modules 25-27 and 31

    Depth 10-12 hrs

    Three eval layers: final answer, trajectory, productionTask suites from failures, successes, adversarial cases, synthetic variationsMechanical trajectory checks; validated judges; the suite as a CI gate with pass ratesWhy injection is unsolved; the OWASP agentic categoriesContainment: least privilege, approval gates, sandboxes, provenance, memory policy, identityRed-teaming the system and security observabilityVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

    • A 30-task suite with seven mechanical trajectory checks and a validated judge, run five times per task and wired into CI, plus a red-team report with payloads, outcomes, and the harness fix for each unauthorized effect, all payloads added to the suite
    • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.

    Open module
11. 33

    Module 33ADVANCED5 min

    AI System Design and Product Tradeoffs

    This module prepares the learner for system design interviews and architecture planning conversations.

    Topics, prerequisites, and deliverables

    Builds on Modules 14 and 24-32

    Depth 10-12 hrs

    Architecture tradeoffsBuild versus buyLatency, cost, and quality tradeoffsPrivacy, compliance, and failure containmentVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

    • Produce three AI system design writeups
    • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
    • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
    • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

    Open module

Convert the accumulated learning into a coherent portfolio, interview packet, project defense, and flagship capstone.

1. 34

   Module 34INTERMEDIATE4 min

   Portfolio Architecture, Project Storytelling, and Resume Evidence

   Students need proof of work and a coherent story, not scattered repos.

   Topics, prerequisites, and deliverables

   Builds on Modules 19-33

   Depth 6-8 hrs

   Case-study writingResume bullet constructionDemo strategy and evidence framingVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Build a polished portfolio with two to three flagship case studies
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module
2. 35

   Module 35CapstoneADVANCED6 min

   Interview Readiness and Capstone Launch

   Final consolidation into hireability requires integration, defense, and reflection under pressure.

   Topics, prerequisites, and deliverables

   Builds on All prior modules

   Depth 10-12 hrs + capstone

   ML interview patternsPractical coding and experimentation discussionSystem design and project defenseVisual reasoning: know what diagram or flowchart would make this module easier to understand.Data grounding: know what concrete example, table, metric, or trace should anchor the lesson.

   • Complete a flagship capstone plus an interview prep packet
   • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
   • Flowchart: add one visual diagram for the module workflow, system design, or decision process.
   • Portfolio artifact: produce a small reusable note, table, diagram, repo, or case-study section.

   Open module