Start learning

Learning Roadmap

Software Engineer to ML/AI Engineer

Back to paths

A 34-module transition path for software engineers learning ML systems, LLM apps, agent engineering (context, harnesses, MCP, evals, security), MLOps, and AI system design.

Audience

Experienced software engineers who can already ship production software and need a direct bridge into probabilistic, data-dependent ML/AI work.

Outcome

Learners finish able to apply software engineering judgment to ML/AI systems and explain the transition clearly in hiring conversations.

Curriculum philosophy

This path assumes you already know how to ship software. It focuses on the parts that are different in ML work: statistics, model behavior, experiments, evaluation, retrieval, LLM systems, and ML operations.

5 phases · 34 modules · about 210 minutes total reading

1

Phase 1

ML Mental Model and Data Foundations

5 modules

Reset from deterministic software thinking into probabilistic, data-dependent systems while building the minimum Python, math, statistics, and data workflow base.

  1. 1
    Module 1BEGINNER6 min

    ML for Software Engineers: Mental Model Reset

    Transitioning engineers often treat ML like deterministic backend logic. This module corrects that early.

    Topics, prerequisites, and deliverables

    Builds on Solid software engineering background

    Depth 3-4 hrs

    How ML systems differ from deterministic softwareData dependence and probabilistic behaviorOffline versus online qualityVisual 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 an architecture memo comparing software and ML systems
    • 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 2BEGINNER5 min

    Python for Experienced Engineers

    Experienced engineers should move quickly, but not pick up weak Python habits while doing it.

    Topics, prerequisites, and deliverables

    Builds on SWE experience in any major language

    Depth 4-5 hrs

    Python idioms and ecosystemTyping and packagingTesting and dependency managementVisual 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 small typed Python library and test suite
    • 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 3INTERMEDIATE8 min

    Agentic Coding: Working With Claude Code, Codex, and Cursor

    Coding agents are now the default way software is written, and every later module goes faster if you can delegate mechanical work to one and review it well. Placed in Phase 1 so the skill compounds across the path.

    Topics, prerequisites, and deliverables

    Builds on Module 2

    Depth 4-6 hrs

    The gather, act, verify loop and why verification decides qualityCLAUDE.md and AGENTS.md context files: what belongs, what does notSkills, subagents, and hooks; when multi-agent is the wrong defaultPermission modes and plan mode; irreversible actions always askSpec-driven tasks: problem, definition of done, constraints, verificationReviewing agent output like a senior engineerVisual 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 a CLAUDE.md under 100 lines, one custom skill, and one PR produced end to end by an agent with your review notes and the rules you added afterward
    • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
    Open module
  4. 4
    Module 4INTERMEDIATE5 min

    Math and Statistics for Practical ML Judgment

    This gives enough linear algebra, probability, and optimization intuition to hold technical interviews and design discussions.

    Topics, prerequisites, and deliverables

    Builds on Basic engineering math

    Depth 6-8 hrs

    Linear algebra essentialsProbability and uncertaintyGradients and optimization 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.
    • Build a concise notebook toolkit for common ML math concepts
    • 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 5BEGINNER5 min

    Data Workflows: NumPy, Pandas, SQL, and Data Quality

    Engineers need to become fluent in data realities, not just structured service inputs.

    Topics, prerequisites, and deliverables

    Builds on Modules 1-2

    Depth 6-8 hrs

    Data wrangling and joinsValidation and leakage detectionMissingness, label quality, and reproducibilityVisual 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 data ingestion and validation pipeline
    • 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
Phase gate, readiness checks, and outcome

Assessment gate

  • Explain how ML systems differ from backend services
  • Build a clean Python repo with data validation and reproducibility
  • Demonstrate practical understanding of gradients, probability, leakage, and data quality
  • Produce a transition memo mapping existing SWE strengths to ML habits

Ready to move forward when

  • Has switched from code-only thinking to data-plus-code thinking
  • Can work with messy data comfortably and reproducibly
  • Understands why evaluation and uncertainty matter
  • Knows which SWE instincts transfer and which need adjustment

Hiring-readiness outcome

Ready for serious ML practice without wasting time on beginner software engineering material.

2

Phase 2

Practical ML Experimentation

5 modules

Build end-to-end ML workflows with problem framing, baselines, feature engineering, evaluation, debugging, and reproducible project structure.

  1. 6
    Module 6INTERMEDIATE14 min

    Supervised Learning End to End

    This module helps transitioners frame problems, choose baselines, and evaluate properly.

    Topics, prerequisites, and deliverables

    Builds on Modules 4-5

    Depth 8-10 hrs

    Problem framing and baselinesTrain, validation, and testRegularization 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.
    • Train and evaluate a full supervised pipeline
    • 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. 7
    Module 7INTERMEDIATE4 min

    Classical ML Model Selection and Feature Engineering

    Many product problems are solved with strong feature engineering and model selection, not deep learning.

    Topics, prerequisites, and deliverables

    Builds on Module 6

    Depth 8-10 hrs

    Trees, boosting, and linear modelsCalibration and leakage defenseFeature engineering and temporal concernsVisual 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.
    • Benchmark multiple models with explicit tradeoff rationale
    • 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. 8
    Module 8INTERMEDIATE4 min

    Evaluation, Experimentation, and Decision Metrics

    Strong product companies care deeply about evaluation rigor and business alignment.

    Topics, prerequisites, and deliverables

    Builds on Modules 4 and 6-7

    Depth 8-10 hrs

    Metric designRanking, classification, and regression metricsConfidence and A/B basicsOffline-online mismatchVisual 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 evaluation harness and experiment template
    • 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. 9
    Module 9INTERMEDIATE4 min

    ML Debugging and Iteration Loops

    Transitioners need to learn how to debug models, data, and labels instead of assuming code-level determinism.

    Topics, prerequisites, and deliverables

    Builds on Modules 6-8

    Depth 6-8 hrs

    Error analysis and slicesData bugs and label issuesAblations and retraining decisionsVisual 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 a debugging playbook on a failing model
    • 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. 10
    Module 10INTERMEDIATE4 minYou are here

    Scikit-learn Pipelines, Reproducibility, and ML Project Structure

    This module turns ad hoc experimentation into maintainable project structure.

    Topics, prerequisites, and deliverables

    Builds on Modules 2 and 6-9

    Depth 6-8 hrs

    Pipelines and preprocessingCross-validation and serializationConfig-driven experimentsRepo structureVisual 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.
    • Convert ad hoc experimentation into a reproducible project 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.
    Resume
Phase gate, readiness checks, and outcome

Assessment gate

  • Build a full supervised ML pipeline with tracked experiments
  • Choose metrics from product objectives
  • Produce error analysis, ablations, and an improvement plan
  • Package the project so another engineer can rerun it

Ready to move forward when

  • Can run practical ML loops independently
  • Has evaluation rigor, not just training familiarity
  • Can debug data and model failures systematically
  • Organizes experiments like an engineer

Hiring-readiness outcome

Credible for internal ML-adjacent work and a strong base for applied ML interviews.

3

Phase 3

Modern Models and AI Application Layer

13 modules

Move from classical ML into deep learning, representations, transformers, LLM product engineering, RAG, agents, and adaptation decisions.

  1. 11
    Module 11INTERMEDIATE6 min

    Neural Networks and Optimization for Practitioners

    Transitioning engineers need practical neural intuition before modern AI systems work becomes credible.

    Topics, prerequisites, and deliverables

    Builds on Modules 4 and 6

    Depth 8-10 hrs

    MLPs and lossesOptimization and regularizationBatch norm and initializationVisual 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 and train core neural models with explained 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
  2. 12
    Module 12INTERMEDIATE5 min

    PyTorch for Real Model Development

    Practical deep learning fluency matters more than theory recital for transitioners entering AI teams.

    Topics, prerequisites, and deliverables

    Builds on Module 11

    Depth 8-10 hrs

    Tensors and dataloadersAutograd and modulesTraining loops and checkpointingDebugging unstable trainingVisual 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 PyTorch training skeleton
    • 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 13INTERMEDIATE5 min

    Representation Learning, Embeddings, and Similarity

    Embeddings sit behind search, recommendation, retrieval, and many modern AI workflows.

    Topics, prerequisites, and deliverables

    Builds on Modules 7-12

    Depth 6-8 hrs

    Embeddings and similarityMetric learning intuitionNearest neighbors and vector search basicsVisual 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 embedding-based retrieval mini-project
    • 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 14ADVANCED5 min

    CNNs or Domain Modeling Track: Vision / Time Series / Recsys

    This lets transitioners tailor their depth instead of producing generic projects only.

    Topics, prerequisites, and deliverables

    Builds on Modules 11-12

    Depth 8-10 hrs

    Domain-specific modeling choicesArchitecture tradeoffsDomain metrics and evaluationVisual 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 domain project with domain-specific metrics
    • 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 15ADVANCED5 min

    Transformers and Modern NLP for Engineers

    Modern AI work requires more than API familiarity. Engineers need model and inference intuition.

    Topics, prerequisites, and deliverables

    Builds on Modules 11-13

    Depth 10-12 hrs

    Tokenization and attentionTransformer blocksFine-tuning and inference concernsVisual 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 and evaluate a transformer model
    • 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 16ADVANCED6 min

    LLM Product Engineering

    This module is about structured outputs, tool use, fallbacks, context packing, and cost-aware product decisions.

    Topics, prerequisites, and deliverables

    Builds on Module 15

    Depth 8-10 hrs

    Prompt design and schema adherenceTool use and structured outputsContext packing, fallbacks, latency, and costVisual 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 production-style LLM endpoint with typed outputs and tests
    • 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. 17
    Module 17ADVANCED5 min

    Retrieval Systems, Vector Databases, and RAG

    RAG is common because it grounds outputs, but only when retrieval is designed and measured properly.

    Topics, prerequisites, and deliverables

    Builds on Modules 13 and 15-16

    Depth 10-12 hrs

    Chunking and embeddingsIndexing and vector DB basicsHybrid retrieval and rerankingContext assemblyVisual 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 and benchmark a retrieval system
    • 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. 18
    Module 18ADVANCED10 min

    Agents, Tools, and Workflow Graphs

    Teams need tool orchestration, traceability, and guardrails more often than fully autonomous agents.

    Topics, prerequisites, and deliverables

    Builds on Modules 16-17

    Depth 8-10 hrs

    Tool calling and workflow graphsAgent loops and planning limitsMemory and guardrailsTraceabilityVisual 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 workflow graph or tool-using agent with evaluation traces
    • 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. 19
    Module 19ADVANCED7 min

    Context Engineering: Designing What the Model Sees

    On an agent that has called fifteen tools, the prompt is a rounding error and the tool results are the context. Teams that design the context deliberately ship agents that stay coherent and cost a third less; teams that do not blame the model.

    Topics, prerequisites, and deliverables

    Builds on Modules 16-18

    Depth 8-10 hrs

    The context budget: system prompt, tools, retrieval, memory, conversation, tool resultsScoping the tool surface per task; tool search and programmatic tool callingRetrieval as recall then precision; packing with provenanceWorking, episodic, and long-term memory with separate write policiesCompaction without amnesia: retrievable artifacts, verbatim constraintsPrompt caching as a layout constraint; cache hit rate as a metricVisual 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.
    • An instrumented agent showing tokens per section, cache hit rate, and compaction events, with a 40% token reduction at equal task success 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
  10. 20
    Module 20ADVANCED7 min

    Harness Engineering: The Runtime Around the Model

    Agent = model + harness. Most agent projects die because the harness is missing: nobody can say what the agent can do, what it did, or what it cost. This module builds the runtime that answers those questions.

    Topics, prerequisites, and deliverables

    Builds on Modules 18-19

    Depth 10-12 hrs

    The five layers: tool orchestration, guardrails, verification, context and memory, observabilityA minimal harness: scoped tools, schema validation, budgets, approval pauses, traces of proposed and refused callsVerification loops: structural, executable, comparative, judgedThe never-again loop: fix the layer, not the prompt, then add the evalSandboxing and durable stateVisual 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 harness wrapping a tool-calling model with per-task tool scoping, schema validation, turn and dollar budgets, a durable approval pause, and a replayable trace, demonstrated with five traced scenarios
    • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
    Open module
  11. 21
    Module 21ADVANCED6 min

    MCP and Agent Protocols: Building and Consuming Tool Servers

    MCP is the standard way to connect agents to tools and data, supported by every major provider. Building a server is a concrete, portfolio-visible deliverable, and tool description quality is the lever most engineers miss.

    Topics, prerequisites, and deliverables

    Builds on Modules 18 and 20

    Depth 8-10 hrs

    MCP roles and primitives: host, client, server; tools, resources, prompts; stdio and HTTP transportsBuilding a server with the Python SDK; connecting it to a coding agent and to your own harnessTool design as context engineering: names, when-to-use descriptions, return shapes, side-effect warningsThird-party servers as untrusted codeWhere A2A, UI protocols, and payment protocols fitVisual 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 with at least three tools (one with a side effect) and one resource, connected to a coding agent and your harness, plus a 15-task eval of tool selection and ordering with results in the README
    • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
    Open module
  12. 22
    Module 22ADVANCED9 min

    Fine-Tuning, Adaptation, and When Not to Fine-Tune

    Strong engineers should know where fine-tuning fits and where it wastes time and money.

    Topics, prerequisites, and deliverables

    Builds on Modules 12 and 15-17

    Depth 8-10 hrs

    PEFT and LoRA intuitionInstruction tuning basicsSynthetic data concernsCost and evaluation 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.
    • Write a comparative memo: prompt-only versus RAG versus fine-tuning
    • 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
  13. 23
    Module 23ADVANCED7 min

    Reasoning Models, Post-Training, and Test-Time Compute

    Every request is a decision to pay for reasoning or not. Engineers who understand where reasoning models come from (RLVR, GRPO) and how to measure the accuracy-versus-cost curve on their own workload make that decision deliberately.

    Topics, prerequisites, and deliverables

    Builds on Modules 15 and 22

    Depth 6-8 hrs

    The post-training pipeline: SFT, DPO, RLVRGRPO: group-relative advantages, no value model, KL to referenceWhy verifiable rewards are the constraint; where reasoning gains clusterTest-time compute: longer reasoning, parallel sampling, search; diminishing returnsThe four-setting method and routing only what benefitsSynthetic data and the held-out human setVisual 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.
    • An accuracy-versus-cost table and plot for one feature across non-reasoning, low, medium, and high reasoning budgets on a 150-request eval, with a routing rule and the blended cost and accuracy of the routed system
    • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
    Open module
Phase gate, readiness checks, and outcome

Assessment gate

  • Train and explain a PyTorch model
  • Build a representation/retrieval demo with measured quality
  • Build LLM, RAG, and workflow-graph features with evaluation
  • Argue when to use prompting, retrieval, fine-tuning, or classical ML

Ready to move forward when

  • Understands modern AI systems beyond wrappers
  • Can connect representation learning to retrieval and product behavior
  • Can articulate model, context, latency, and quality tradeoffs
  • Knows how to constrain agentic workflows responsibly

Hiring-readiness outcome

Ready for applied AI engineer interviews when paired with production and portfolio artifacts.

4

Phase 4

Production AI Systems and Platform Operations

8 modules

Use prior software depth to design repeatable data, training, serving, CI/CD, monitoring, evaluation, ranking, and AI system-design workflows.

  1. 24
    Module 24ADVANCED5 min

    Data Pipelines, Labeling, and Training Workflows

    Engineers need repeatable workflows around model building, not isolated experiments.

    Topics, prerequisites, and deliverables

    Builds on Modules 5 and 8-10

    Depth 8-10 hrs

    Dataset construction and labeling workflowsVersioning and metadataRetraining cadence and artifactsVisual 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 retraining-ready pipeline and artifact map
    • 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. 25
    Module 25ADVANCED8 min

    Serving Models and LLM Systems in Production

    The real job often sits in serving patterns, latency management, and system integration.

    Topics, prerequisites, and deliverables

    Builds on Modules 12 and 16-24

    Depth 8-10 hrs

    API serving and async jobsQueues, batching, and streamingCaching, packaging, and rollback 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.
    • Serve an ML or LLM system behind an API with latency measurements
    • 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. 26
    Module 26ADVANCED5 min

    MLOps and CI/CD for ML Teams

    This module lets transitioners leverage their existing engineering background as an advantage.

    Topics, prerequisites, and deliverables

    Builds on Modules 10 and 24-25

    Depth 8-10 hrs

    CI/CD and automated checksData and model validationExperiment tracking and registriesRelease workflowsVisual 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 CI for training and serving artifacts
    • 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. 27
    Module 27ADVANCED6 min

    Observability, Drift, Feedback Loops, and LLM Evals

    Many shipped AI systems break down after launch because teams underinvest in drift, evals, and user feedback loops.

    Topics, prerequisites, and deliverables

    Builds on Modules 8 and 16-26

    Depth 8-10 hrs

    Drift and data quality monitoringFailure taxonomies and feedback loopsRed teaming basics and regression testingLLM evaluation 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.
    • Create an eval and monitoring plan for a production AI system
    • 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. 28
    Module 28ADVANCED7 min

    Agent Evals: Trajectories, Tool Calls, and Regression Suites

    An agent produces a trajectory, not an answer. Grading only the end misses loops, wrong tools, and failure to recover. Evals engineering is a job title now because this work decides whether agents ship.

    Topics, prerequisites, and deliverables

    Builds on Modules 18-21 and 27

    Depth 10-12 hrs

    Three layers: final answer, trajectory, per-turn production signalBuilding a task suite from failures, successes, adversarial cases, and synthetic variationsMechanical trajectory grading: required and forbidden tools, order, budget, recovery, argument validity, world stateValidating LLM judges against human labels; known judge biasesThe suite as a CI regression gate; pass rates over repeated runs (pass^k)Production signals: corrections, escalations, abandonment, route driftVisual 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 agent eval suite with six mechanical trajectory checks and a validated judge, run five times per task, wired into CI as a gate that fails on a 2-point drop, demonstrated catching a deliberate regression with a trace diff
    • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
    Open module
  6. 29
    Module 29ADVANCED7 min

    AI Security for Agents: Prompt Injection, Excessive Agency, and Sandboxing

    Prompt injection is structurally unsolved, and agents turned it from an embarrassment into a breach. Security for agents is containment: least privilege, approval gates, sandboxes, provenance, and a red-team practice against your own harness.

    Topics, prerequisites, and deliverables

    Builds on Modules 20-21 and 28

    Depth 8-10 hrs

    Why injection cannot be reliably detectedThe OWASP agentic risk categories: injection, insecure tool execution, excessive agency, memory poisoning, identity abuse, supply chain, cascading failuresContainment architecture: per-task least privilege, approval gates, sandboxed execution, provenance labels, guardian pattern, memory write policy, agent identityRed-teaming the system, not the model; grading by unauthorized effectSecurity observability: refused calls, approval anomalies, sandbox denialsVisual 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 red-team report against your own harness: ten injection payloads per side-effect tool and untrusted source, run five times each through the real system, with the harness change that closed each unauthorized effect and all payloads added to the eval suite
    • Data/example asset: identify the concrete dataset, API trace, eval table, or project artifact this module should teach from.
    Open module
  7. 30
    Module 30ADVANCED5 min

    Search, Ranking, Recommendation, and Personalization Systems

    Many ML engineer roles live outside pure GenAI. This module broadens role fit substantially.

    Topics, prerequisites, and deliverables

    Builds on Modules 7-8 and 13

    Depth 8-10 hrs

    Retrieval and ranking pipelinesRecommendation fundamentalsCandidate generation and ranking metricsFeedback 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.
    • Design a search or recommendation system case study
    • 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. 31
    Module 31ADVANCED6 min

    AI System Design: Quality, Cost, Latency, and Safety Tradeoffs

    This module trains system thinking across quality, cost, latency, privacy, and safety constraints.

    Topics, prerequisites, and deliverables

    Builds on Modules 17-29

    Depth 10-12 hrs

    End-to-end AI architecturesTradeoff tablesPrivacy and complianceHuman-in-the-loop boundariesVisual 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 multiple design case studies with tradeoff tables
    • 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
Phase gate, readiness checks, and outcome

Assessment gate

  • Design training, serving, evaluation, and monitoring architecture
  • Define CI/CD, rollback, drift, feedback, and LLM eval workflows
  • Complete search/ranking and AI system design case studies
  • Draw diagrams for data lineage, request flow, and monitoring loops

Ready to move forward when

  • Can reason from data to deployment to operations
  • Shows operational maturity, not just experimentation skill
  • Can discuss quality, cost, latency, reliability, privacy, and safety together
  • Can design systems that teams could actually maintain

Hiring-readiness outcome

Strong candidate for ML Engineer, Applied AI Engineer, or AI Platform Engineer roles that value production judgment.

5

Phase 5

Hiring Conversion and Capstone Proof

3 modules

Turn prior engineering experience and new ML/AI work into portfolio evidence, project-defense stories, and a production-style capstone.

  1. 32
    Module 32INTERMEDIATE6 min

    Portfolio Conversion: Turning Engineering Work Into ML Evidence

    The transition fails if the story fails. This module converts engineering maturity into ML evidence.

    Topics, prerequisites, and deliverables

    Builds on Modules 14-31

    Depth 5-6 hrs

    Portfolio strategy and project selectionREADME and case-study writingResume reframing and metrics storytellingVisual 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 two polished flagship project case studies and updated resume bullets
    • 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. 33
    Module 33ADVANCED8 min

    Interview Readiness for ML/AI Engineering Roles

    This module is the conversion layer between capability and offer outcomes.

    Topics, prerequisites, and deliverables

    Builds on All prior modules

    Depth 8-10 hrs

    ML theory interview patternsPractical Python and experimentation interviewsSystem design and project walkthroughsBehavioral 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 mock interview bank and prep pack
    • 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. 34
    Module 34CapstoneADVANCED5 min

    Capstone: Build and Operate a Production-Style AI System

    This capstone forces learners to connect data, models, serving, evaluation, monitoring, and design defense in one coherent project.

    Topics, prerequisites, and deliverables

    Builds on All prior modules

    Depth 20+ hrs

    End-to-end build from data through servingEvaluation and monitoring planArchitecture defense and postmortemVisual 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.
    • Deliver a capstone with architecture doc, demo, tests, metrics, and postmortem
    • 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
Phase gate, readiness checks, and outcome

Assessment gate

  • Finish a capstone with architecture, metrics, monitoring, and postmortem
  • Convert prior SWE wins into ML/AI-relevant resume bullets
  • Build project case studies with diagrams, data summaries, and tradeoff tables
  • Practice project defense, ML theory, coding, and AI system design interviews

Ready to move forward when

  • Can tell a coherent transition story
  • Has hard artifacts that prove ML and AI depth
  • Can defend architecture, failures, and iterations under interview questioning
  • Positions SWE background as leverage instead of unrelated history

Hiring-readiness outcome

Realistically interviewable for product-company ML/AI engineering roles where software depth is valued.

Milestone gates

Gate 1

Can think in data-dependent systems

Engineer can explain how ML differs from deterministic software and can work with data, uncertainty, and reproducibility.

Gate 2

Can run practical ML experiments

Engineer can build, evaluate, debug, and package ML workflows with credible metrics and error analysis.

Gate 3

Can build modern AI application layers

Engineer can use deep learning, embeddings, transformers, LLMs, RAG, agents, and adaptation choices with real tradeoff judgment, and can design the context and harness around a model, expose tools through MCP, and decide when reasoning models and post-training are worth their cost.

Gate 4

Can operate production AI systems

Engineer can design serving, CI/CD, monitoring, evals, ranking, rollback, and system-design flows that teams can maintain, including trajectory-graded agent evals as a CI gate and a containment architecture for agent security backed by a red-team report.

Gate 5

Can convert into hiring proof

Engineer can present a transition story, project evidence, capstone architecture, and interview-ready system reasoning.