MLOps in practice: ship and monitor machine learning models

Take a model from notebook to a monitored service: reproducible training, MLflow tracking, packaging, CI, deployment and drift checks

7 ratings 1,720 students Sample

Created by Kwame Mensah

  • Updated September 2026
  • English
  • Intermediate

What you will learn

  • Refactor notebook code into a reproducible, tested training pipeline
  • Version data and models and track experiments with MLflow
  • Serve a model with FastAPI in a Docker container
  • Choose between batch and online prediction for a use case
  • Automate checks on data, code and model quality in CI
  • Monitor drift and performance and plan retraining and rollouts

Course content

5 sections, 24 lessons, 3h 59m total

From notebook to pipeline 5 lessons · 51 min
  • Video: Why models fail after the notebook Preview 8 min
  • Article: From notebook to a training pipeline Preview 14 min
  • Article: Validating data before it reaches the model 12 min
  • Article: Tracking experiments with MLflow 12 min
  • Quiz: Check your understanding 5 min
Packaging and serving 5 lessons · 53 min
  • Article: Batch or online prediction 9 min
  • Video: A nightly batch scoring job 11 min
  • Video: Serving with FastAPI 12 min
  • Video: Sharing feature code between training and serving 10 min
  • Video: Docker images for training and serving 11 min
Automation and CI 4 lessons · 41 min
  • Video: CI for ML code 11 min
  • Video: Model quality gates 11 min
  • Video: Versioning data 10 min
  • Article: Scheduling pipelines 9 min
Monitoring in production 5 lessons · 51 min
  • Video: What to monitor 10 min
  • Video: Detecting data and prediction drift 12 min
  • Video: Measuring real performance with delayed labels 11 min
  • Article: Logging predictions for later analysis 9 min
  • Article: Business metrics and feedback 9 min
Retraining and safe releases 5 lessons · 43 min
  • Video: When and how to retrain 10 min
  • Video: Shadow deployments 10 min
  • Video: Canary releases and rollback 10 min
  • Article: Documentation and ownership 8 min
  • Quiz: Final check 5 min

Requirements

  • Python, pandas and scikit-learn
  • Basic Git and command line skills
  • Docker installed

Description

A model in a notebook is an experiment. A model that makes predictions for real users, keeps working as data changes and can be retrained safely is a product. The gap between the two is where many machine learning projects stall. MLOps is the set of practices that closes that gap.

This course takes a single, realistic model, a demand forecast for a chain of bakeries, and walks it through the whole lifecycle. We keep the tooling deliberately modest and widely used, so the habits transfer to any platform your team adopts later.

What you will learn

  • Turning notebook code into a tested, reproducible training pipeline
  • Versioning code, data and models
  • Tracking experiments and registering models with MLflow
  • Packaging a model behind a FastAPI service in a Docker container
  • Batch versus online prediction, and choosing between them
  • CI pipelines that test data, code and model quality before release
  • Monitoring predictions, data drift and business outcomes
  • Retraining strategies and safe rollouts with shadow and canary releases

Philosophy

Most production problems are not exotic. They are a column that changed type upstream, a feature computed differently in training and serving, or a model nobody noticed had degraded. We focus on simple, robust checks that catch those problems early. Tools are introduced only when a problem calls for them.

You should be comfortable with Python, pandas and scikit-learn, and know the basics of Git and the command line. Docker experience helps but is introduced from the start.

Who this course is for

  • Data scientists whose models need to reach production
  • ML and backend engineers supporting ML teams
  • Tech leads planning an ML platform

Instructor

Kwame Mensah

Statistician and ML engineer teaching statistics and how to ship models responsibly

  • 4.4 instructor rating
  • 14 reviews
  • 3,860 students
  • 2 courses
  • Sample

I trained as a statistician and now work on machine learning systems, from experiment design to keeping models healthy after deployment. I spend a lot of time explaining uncertainty to people who would prefer a single number.

My courses focus on intuition first. We simulate things in Python before we use a formula, so the formula has something to stand on. Then we look at the tools teams actually use, such as scikit-learn, MLflow and FastAPI.

I want my students to be the person on the team who asks how big the sample was and how the model will be monitored.

View profile

Student reviews

4.4 7 ratings
5 star 57%
4 star 29%
3 star 14%
2 star 0%
1 star 0%
Pablo N. Oct 1, 2026
Sample

Time based split was a wake up call

Our forecast error got honestly worse after fixing the split, which is exactly what we needed to know.

Gustavo R. Sep 22, 2026
Sample

Exactly the missing piece

I could train models but never shipped one reliably. The bakery case study mirrors my job almost exactly.

Hanna L. Sep 1, 2026
Sample

Data validation lesson is excellent

pandera checks now run at the start of every pipeline we own. Two upstream changes caught already.

Ifeanyi O. Aug 7, 2026
Sample

Practical, tool light approach

I appreciated not being pushed into a big platform. More on orchestrators would have been nice.

Sophie M. Jul 12, 2026
Sample

Shadow and canary releases explained well

We now shadow every new model for two weeks. It has prevented one bad release already.

Daniel K. Jun 14, 2026
Sample

Great MLflow coverage

The registry alias approach simplified our deployments a lot. Monitoring section is strong too.

Ayumi T. May 14, 2026
Sample

Assumes some Docker

Docker is introduced, but if you have never used it the serving section moves quickly.

$69.99 Enroll now
SampleSample catalog: the instructors, courses, reviews and stats on this site are demo content.