MLOpsThe MLOps lifecycle · MLflow 3.17 · DVC 3.67 · FastAPI · Docker · GitHub Actions · Evidently · Python 3.11+
Dashboard
0%
1
Curious builder0 XP earned · 300 to level 2
0 daysFinish a lesson to begin
Badge collection0 of 6 unlocked
50 small wins to finish your pathNext lesson →

MLOps logoMLOps overview

MLOps is the set of practices for taking a trained model out of a notebook and operating it: a project structure that scales, tracked experiments, versioned data, the model served as an API in a container, a build and deploy that runs itself, and the drift you watch once real traffic reaches it.

Last updated: 19 Oct, 2026 · MLOps

The name is machine learning plus operations, the same way DevOps is development plus operations. The end-to-end project video makes the shape of the work visible before a line of model code is written: it starts with a GitHub repository, then a script that creates the project folders, then logging, exceptions and config, and only then the components that read data and fit a model. The model is one stage among many, and the rest of the stages are what this course teaches.

What MLOps adds to a finished model · from the Complete RoadMap To Learn AIOPS or MLOPS · 0:13 to 1:30

The video says AIOps where this course says MLOps; the two names are used for the same practice, and MLOps is the one this course keeps to.

What you will build

One example grows through the course: a student-performance service that predicts a maths score from a student record. The dataset is the one from the end-to-end machine learning project repository, loaded straight from its URL, so nothing is downloaded by hand. It starts as a folder tree and a logger, becomes a pipeline of components driven by config, then gets tracked runs in MLflow, versioned data in DVC, a FastAPI service, a Docker image, a GitHub Actions workflow and a drift report. Every metric, log line and image on these pages comes from a real run of that project.

Alongside it sits the kidney-disease classifier the end-to-end deep learning video deploys. That project is the worked case: where it appears, its code carries its own saved output and is captioned as such, because the course installs no deep learning stack and downloads no model weights. The student-performance service is the one you run yourself.

The learning path of the MLOps course in nine parts, read left to right then down: 1 What MLOps is, 2 Setting up the project, 3 The project architecture, 4 The running example end to end, 5 Experiment tracking with MLflow, 6 Versioning data and pipelines with DVC, 7 Serving the model, 8 Automating with CI/CD, 9 Running it after it ships, with every lesson listed under its part and arrows joining each part to the next. 51 lessons in all.

The nine parts

PartLessons
1. What MLOps isMLOps overview, Why models stall in notebooks, MLOps vs DevOps, The MLOps lifecycle, MLOps maturity levels, The MLOps toolchain
2. Setting up the projectInstalling the MLOps toolkit, The project template script, Packaging with setup.py, The logging module, Custom exceptions
3. The project architectureConfig files, not constants, Reading config with ConfigBox, Entity classes for stage config, The configuration manager, Stage components, The training pipeline
4. The running example end to endData ingestion, Data validation, Data transformation with ColumnTransformer, The model trainer, The prediction pipeline
5. Experiment tracking with MLflowExperiment tracking, Logging params and metrics, Logging a model with MLflow, Comparing runs in the MLflow UI, The model registry, A remote tracking server
6. Versioning data and pipelines with DVCWhy git cannot hold data, Tracking data with DVC, DVC remote storage, dvc.yaml stages, deps and outs, dvc repro and the cache, DVC metrics and plots
7. Serving the modelServing the model with FastAPI, Request and response schemas, Dockerising the service, Smaller images with layer caching, Pushing to a container registry
8. Automating with CI/CDCI/CD for a model service, A GitHub Actions workflow, Building the image in CI, Deploying with a self-hosted runner, Secrets and what never goes in git
9. Running it after it shipsWhy a live model decays, Data drift with Evidently, The signals to monitor, Retraining strategies, Orchestrating with Airflow, The operated model service

Who this course is for

  • A data scientist whose models stop at the notebook, who wants the path from a fitted model to a service someone else can call.
  • A software or DevOps engineer moving onto a model team, who knows CI/CD and containers and needs the parts that are specific to models: experiment tracking, data versioning, drift and retraining.
  • Anyone preparing for a machine learning engineer interview, where the end-to-end project is the question, and the structure of the project is most of the answer.

What to know first

  • Python, including classes and imports, because the project is written as modules rather than cells.
  • One trained model: fit, predict and a metric. The Machine Learning course covers that ground if you need it.
  • Git basics help, since the project lives in a repository from the first lesson of the next part. The Git and GitHub course covers them.
  • No cloud account, no API key and no GPU. Every runnable lesson works on a laptop. Where a cloud step cannot be run without spending money, the page shows the commands and the output the provider's own documentation gives, and says so.

What you will be able to do

  • Explain the MLOps lifecycle and place a team on the maturity levels
  • Structure a model project as config, entities, components and pipelines
  • Track experiments, compare runs and register a model with MLflow
  • Version data and reproduce a pipeline with DVC
  • Serve a model as a FastAPI service and ship it in a Docker image
  • Automate test, build and deploy with GitHub Actions and handle secrets
  • Detect data and target drift and choose a retraining strategy

How a lesson reads

  • A definition first, then why the thing exists, then the build in small pieces with a comment on each piece.
  • Code you can paste. Every runnable block was run on the pinned versions in the install lesson, and its output is what that run printed.
  • The current library, not the one in the video. MLflow, Evidently, Airflow and scikit-learn have all changed since the videos were recorded. Each lesson follows the release it pins and names what moved.
  • An ending you can change: two or three small edits to try, so the next run is yours rather than a copy.

The videos and their repositories

This course is assembled from the channel's MLOps and end-to-end project videos. The two that carry the most weight, and the repositories they build, are worth keeping open alongside the lessons:

Where this course stops. It operates a model you train yourself. Running an application built on a large language model is a different job, with prompts, tokens and fuzzy evaluation in place of weights and accuracy, and it has its own course: LLMOps starts from the practices here and names what changes.
Back toAll courses

Every expert started right here.