dtu_mlops is a ten-week machine learning operations course you can read for free

The repository is a course, ordered by week

dtu_mlops is the repository for course 02476 at DTU, run by Associate Professor Nicki Skafte Detlefsen and Professor Søren Hauberg. It carries 5 ECTS, which corresponds to 140 hours of work, runs over a three week period in January, sits at master level, and is graded pass/fail with a project report as the assessment.

The structure of the repository is the course structure. The top-level entries are named after the sessions: s1_development_environment/, s2_organisation_and_version_control/, s3_reproducibility/, s4_debugging_and_logging/, s5_continuous_integration/, s6_the_cloud/, s7_deployment/, s8_monitoring/, s9_scalable_applications/, plus s10_extra/ for material beyond the numbered weeks.

That ordering is the main reason to look at this even if you are not enrolled. Each folder is a self-contained unit with its own exercises, and the sequence covers the whole path a model takes from a laptop to production. Supporting directories include pages/ for the written material, slides/, figures/, literature/, reports/, samples/, canvas/, and a tasks.py plus tools/ for the build automation.

The stated prerequisite is DTU course 02456 on deep learning, or equivalent experience with machine learning fundamentals, basic deep learning, and coding in PyTorch. The course provides PyTorch exercises on the first day to bring everyone's skills up to speed.

The last push was on 2026-10-19 and the repository has no GitHub releases, which is normal for a course repository.

The learning objectives are a checklist for a working MLOps setup

The README lists what a student is meant to be able to do afterwards, and the list reads like a specification for a team's practice rather than a syllabus.

Organising code so it is easy to maintain and share is first. Then understanding reproducibility and how to create reproducible containerized applications and experiments. Version control for collaboration comes next, followed by knowledge of continuous integration and continuous machine learning for automating code development.

The middle of the list is about running models rather than writing them: being able to debug, profile, visualise and monitor multiple experiments to assess model performance, using online cloud-based computing services to scale experiments, and demonstrating knowledge about different distributed training paradigms and how to apply them. Deployment of models, both locally and in the cloud, closes the technical list, followed by conducting a research project in collaboration with fellow students using the frameworks taught.

The general objective frames this as introducing coding practices that help organise, scale, monitor and deploy machine learning models in a research or production setting, with hands-on experience of frameworks both local and in the cloud for large scale machine learning models.

It is worth noticing what is absent. There is no objective about training a specific model architecture, and none about a particular cloud vendor. The subject is the surrounding engineering.

The dependency list tells you which tools the course actually uses

The project metadata separates two dependency groups, and the difference is telling. The main dependencies are the documentation toolchain: mkdocs-material and its extensions, mike, mkdocs-glightbox, mkdocs-exclude, mkdocs-same-dir, pymdown-extensions, ruff, pre-commit, ipython, invoke and codespell. The project is named dtu-mlops at version 0.1.0, it requires Python 3.11 or above, and the classifiers list Python 3.11 through 3.15.

The exercises group is where the machine learning tooling lives, and it is a long list. It includes dvc with the gdrive and gs backends for data versioning, cookiecutter for project templates, fastapi with uvicorn and prometheus-fastapi-instrumentator for serving and instrumenting a service, and prefect for workflow orchestration. Also hydra-core for configuration, pydantic, typer and click-style command line work, optuna for hyperparameter search, wandb for experiment tracking, evidently for drift and report generation, and streamlit for building interfaces.

For the model side there is torch, torchvision, pytorch-lightning, transformers, scikit-learn, onnxruntime, neural-compressor and ptflops for profiling, plus datasets for dataset loading. For measurement there is locust for load testing, pytest, coverage, mypy, nbconvert, ipykernel, matplotlib, snakeviz for profiling visualisation, httpx, requests and python-dotenv.

The spread is the point: the course deliberately touches reproducibility, tracking, orchestration, serving, monitoring and load testing, because those are the layers the objectives cover.

Serving the course locally is a two step process with pip or uv

The README recommends going through the material via the GitHub Pages version of the repository, which is more nicely rendered and includes special HTML handling provided by Material for MkDocs. The suggested starting point is the Introduction page, which gives an overview of the course and a soft introduction to MLOps.

For building the course material locally, the documented process has two options. With pip:

pip install -r requirements.txt
mkdocs serve

Or with uv:

uv sync
uv run mkdocs serve

Either way you end up with a local server at `http://127.0.0.1:8000` that updates automatically when you change the course material. Contributing then means opening a pull request, and the invitation is open, from fixing typos to adding new content.

The uv route matches the repository, which carries a uv.lock file next to pyproject.toml and a [tool.uv] section in the project file. The surrounding tooling is also checked in rather than described: there is a .pre-commit-config.yaml, a .devcontainer/ directory for a reproducible development container, a .markdownlintignore for Markdown linting, a .agents/ directory, an AGENTS.md file, and a .github/ directory.

The mkdocs.yml at the root is what ties the pages/ tree together, and the tools/ and tasks.py hold the build automation.

Apache 2.0 covers the content, and the citation is specified

The README states that the course content is free to use under the Apache 2.0 license, and the repository carries a LICENSE file at the root alongside the Apache 2.0 designation in the project metadata.

For reuse, the README asks that you cite the material, and it gives the citation in a form you can paste directly:

@misc{skafte_mlops,
    author       = {Nicki Skafte Detlefsen},
    title        = {Machine Learning Operations},
    howpublished = {\url{https://github.com/SkafteNicki/dtu_mlops}},
    year         = {2026}
}

Apache 2.0 is a permissive licence that allows copying, modification and redistribution with attribution and preservation of the notice, and it includes an express patent grant from contributors. This is a short statement of the mechanics, not advice.

That combination, a permissive licence plus an explicit citation format, is what makes the material usable in a company onboarding programme without a legal review. The course does not restrict commercial use of the exercises, and it does ask for a citation, which is a reasonable middle ground for teaching material.

A practical note for anyone lifting code from the exercises: the content licence covers the course material as written. The third-party packages the exercises use carry their own licences, and those are a separate matter from this repository's.

Where this sits against other MLOps courses

The README names the comparable material itself, which is more useful than guessing. Three alternatives are listed, and each covers different ground.

Made with ML is described as a great online MLOps course that also covers additional topics on the foundations of working with ML. Full Stack Deep Learning is another online MLOps course going through the whole developer pipeline. MLOps Zoomcamp is an online course that includes many of the same topics.

The difference with dtu_mlops is that it is built around a three week in-person course with a graded project report, so the material is sequenced for a cohort working at a common pace, with an assessment at the end. That is both its strength and its limit. The strength is that the ordering has been tested against real students over repeated runs of the course. The limit is that the exercises assume the surrounding structure of a semester, with a shared report structure and a canvas/ directory for the course administration, which is more scaffolding than a solo learner needs.

The reference list points in a similar way. It includes an introductory MLOps blog post for people who have never heard of MLOps, a Google document on the different levels of MLOps, an introduction to MLOps principles and stages from ml-ops.org, the paper on technical debt in machine learning, and an interview study that uncovers pain points ML engineers go through. Two of those five references are conceptual rather than technical, which suggests the course assumes you will be reading about MLOps as much as coding it.

Editorial conclusion

Adopt dtu_mlops as a self-study path if you want a structured MLOps curriculum with exercises rather than a reference implementation, since the repository is built as ten session folders ending in a project report. Do not expect a production framework from it, the code here is teaching material written to be read and modified. Verify first that you have the Python version the project requires, since the package metadata declares 3.11 and above, and that you can host its documentation build, because the material is delivered as an MkDocs site with a devcontainer and pre-commit configuration for the surrounding tooling.

Frequently asked questions

Official sources

1. Issues
2. License: Apache-2.0
3. Project website
4. README
5. SkafteNicki/dtu_mlops on GitHub