For data scientists, ML engineers and platform engineers who need to take a model from notebook to a reproducible, versioned, monitored production asset.
The curriculum is being prepared and reviewed. Enrollment is not open yet.
About this course
Most ML projects that fail in production fail for operational reasons: nobody can reproduce the training run, the feature logic differs between training and serving, a model is promoted without a check, or accuracy quietly decays as the data shifts. This course teaches the discipline that prevents those failures, using open tooling you can run yourself — Git and DVC for versioning, MLflow for experiment tracking and the model registry, Kubeflow Pipelines and Airflow for orchestration, Feast for features, and Evidently for drift monitoring — and maps each practice onto the managed platforms (Amazon SageMaker AI, Azure Machine Learning, Google's Gemini Enterprise Agent Platform — formerly Vertex AI — and Databricks).
The final module extends the same ideas to LLM applications, where the versioned artifact is often a prompt, a retrieval index and a model choice rather than trained weights, and where evaluation datasets replace a single accuracy metric. Tool facts are stated as of October 2026.
What you will be able to do
Place an ML system on the MLOps maturity scale and identify the next practice that would most reduce its operational risk
Version data, code, environment and model together so that any production model can be traced to and reproduced from its training run
Track experiments and manage model versions, aliases and approvals in a model registry
Build a training pipeline with explicit, cacheable steps and schedule or trigger it from new data
Design a CI/CD workflow that runs data validation, model tests and evaluation gates before promotion
Detect data drift, prediction drift and performance decay and decide when to retrain
Adapt versioning, evaluation and release gates to an LLM application built from prompts, retrieval and hosted models
Syllabus
6 modules · 18 lessons · about 14 hours
1
Module 1: Why ML Systems Fail in Production
The hidden technical debt of ML systems, the roles involved, and a maturity model for deciding what to fix first.3 lessons
The ML Lifecycle and Where Projects Stall
Hidden Technical Debt: Entanglement, Training-Serving Skew and Feedback Loops
MLOps Maturity Levels and Choosing Your First Investments
2
Module 2: Reproducibility: Versioning Everything That Matters
Pinning code, data, environments and randomness so a model can be rebuilt bit-for-bit or close to it.3 lessons
Data Versioning with DVC and Object Storage
Environments: Lock Files, Containers and CUDA Version Pinning
Seeds, Determinism and the Limits of Reproducing GPU Training
3
Module 3: Experiment Tracking and the Model Registry
Logging runs so they can be compared, and managing model versions as governed release artifacts.3 lessons
Tracking Experiments with MLflow: Runs, Parameters, Metrics and Artifacts
Model Registry Workflows: Versions, Aliases, Lineage and Approval
Model Cards and Metadata Auditors Will Ask For
4
Module 4: Pipelines, Features and Orchestration
Turning notebook code into repeatable pipelines and keeping feature logic consistent between training and serving.3 lessons
From Notebook to Pipeline: Steps, Artifacts and Caching
Orchestrating with Kubeflow Pipelines and Apache Airflow
Feature Stores with Feast: Offline, Online and Point-in-Time Correctness
5
Module 5: CI/CD and Monitoring for Models
Automated gates before release and the signals that tell you a released model is degrading.3 lessons
CI/CD for ML with GitHub Actions: Data Validation, Model Tests and Evaluation Gates
Release Strategies: Shadow, Canary and Champion-Challenger
Monitoring Drift with Evidently and Deciding When to Retrain
6
Module 6: MLOps for LLM Applications and Managed Platforms
What changes when the artifact is a prompt and a retrieval index, and how the managed platforms package these practices.3 lessons
LLMOps: Versioning Prompts, Retrieval Indexes and Model Choices
Evaluation Datasets as Release Gates for LLM Features
Managed MLOps Compared: SageMaker AI, Azure Machine Learning, Google Agent Platform and Databricks
Exam and certificate
The exam unlocks once you have completed every lesson. It draws 20 questions from a larger bank, spread across the modules, with the answer options shuffled for each attempt. You have 45 minutes and need 80% to pass. After a failed attempt you can try again after 24 hours, up to 3 attempts in total. Feedback is given per module, never as the answer key.
Passing earns a certificate of completion and assessment from the Wirewalk Institute of AI with a unique ID that anyone can check at institute.wirewalk.com/verify. It is not an accredited qualification or a vendor certification. How certification works.
The Wirewalk Institute of AI is independent. This course teaches publicly documented products and is not affiliated with or endorsed by MLflow, DVC, Git, GitHub Actions, Kubeflow, Apache Airflow, Feast, Weights & Biases, Evidently, Docker, Amazon SageMaker AI, Azure Machine Learning, Gemini Enterprise Agent Platform, or Databricks. Product and company names are trademarks of their respective owners.
A practical path from a model file to a production service: designing the inference API, packaging it in a lean GPU-ready container, running it on Kubernetes with KServe, autoscaling it on the right signal, and rolling out new versions safely. Focused on general ML models; LLM-specific engines are covered in srv-310.
The engineering of LLM inference from first principles to production: why decode is memory-bound, how to size the KV cache, how continuous batching, PagedAttention, prefix caching, quantization and speculative decoding change the economics, and how to run vLLM, SGLang, TensorRT-LLM and Dynamo at scale. Ends with load testing, Kubernetes autoscaling and a defensible cost per million tokens.
The numerics and engineering of making models cheaper to run: number formats from FP16 to FP4, post-training quantization algorithms such as GPTQ, AWQ and SmoothQuant, quantization-aware training, KV cache quantization, and the compiler and kernel work (torch.compile, TensorRT, fused attention, CUDA graphs) that turns smaller numbers into real speed. Every technique is paired with a way to measure what it costs in quality.