Wirewalk Instituteof AI
srv-201 Intermediate Waitlist

MLOps Fundamentals

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

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
  1. The ML Lifecycle and Where Projects Stall
  2. Hidden Technical Debt: Entanglement, Training-Serving Skew and Feedback Loops
  3. MLOps Maturity Levels and Choosing Your First Investments

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
  1. Data Versioning with DVC and Object Storage
  2. Environments: Lock Files, Containers and CUDA Version Pinning
  3. Seeds, Determinism and the Limits of Reproducing GPU Training

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
  1. Tracking Experiments with MLflow: Runs, Parameters, Metrics and Artifacts
  2. Model Registry Workflows: Versions, Aliases, Lineage and Approval
  3. Model Cards and Metadata Auditors Will Ask For

Module 4: Pipelines, Features and Orchestration

Turning notebook code into repeatable pipelines and keeping feature logic consistent between training and serving.
3 lessons
  1. From Notebook to Pipeline: Steps, Artifacts and Caching
  2. Orchestrating with Kubeflow Pipelines and Apache Airflow
  3. Feature Stores with Feast: Offline, Online and Point-in-Time Correctness

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
  1. CI/CD for ML with GitHub Actions: Data Validation, Model Tests and Evaluation Gates
  2. Release Strategies: Shadow, Canary and Champion-Challenger
  3. Monitoring Drift with Evidently and Deciding When to Retrain

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
  1. LLMOps: Versioning Prompts, Retrieval Indexes and Model Choices
  2. Evaluation Datasets as Release Gates for LLM Features
  3. 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.

More in Inference, Serving and MLOps

All 6 courses in this track
srv-210 Intermediate Waitlist

Deploying Models: APIs, Containers and Autoscaling

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.

14 h · 18 lessons Join the waitlist
srv-310 Expert Available

LLM Inference and Serving: vLLM, SGLang, TensorRT-LLM and Triton

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.

22 h · 19 lessons See price at checkout
srv-320 Expert Waitlist

Quantization and Inference Optimization

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.

20 h · 20 lessons Join the waitlist