MLOps Coding Course: seven chapters shipped as a mkdocs site built by mise

The course ships as a documentation site, not as a Python package

The repository is a course, and the packaging metadata says so in the most literal way possible. `pyproject.toml` names the project `mlops-coding-course`, sets the version to 7.0.0, lists Méderic HURIER as the author with an fmind.dev address, and sets `requires-python` to `>=3.14`. Two entries appear under dependencies, `mkdocs>=1.6.1` and `mkdocs-material>=9.7.6`, which is the whole runtime surface: the course is a site, and MkDocs plus the Material theme are what render it.

The decisive line is `[tool.uv] package = false`. uv is told not to build or install this project as a library, so there is no `mlops-coding-course` on PyPI to import. The keywords are `mlops`, `python`, `course`, `best-practices` and `machine-learning`, and the Homepage and Documentation URLs point at the same address, the published site, with the repository itself as the third URL.

The rest of the root explains the shape: a `docs/` tree, `mkdocs.yml`, `uv.lock`, `mise.toml` and `mise.lock`, `lefthook.yml` for git hooks, `dprint.jsonc` for formatting config, `AGENTS.md`, `CODE_OF_CONDUCT.md`, `CHANGELOG.md`, `cliff.toml`, `trivy.yaml`, `.lycheeignore` and a `.python-version` file. A repository that looks like a Python project from a distance and behaves like a publishing pipeline up close.

Every task runs through mise, and `mise run all` is the CI gate

There is no Makefile and no npm scripts. The rule stated for development is that every task goes through mise, and `mise tasks` prints the full list, which is the only way to discover anything not in the table below.

mise run install

That task syncs the Python dependencies through uv and installs the git hooks through lefthook, and it is the first thing you run after cloning. Serving the course locally is the other one you will use most:

mise run serve

After it finishes the material is at `http://localhost:8000/` on your own machine. The rest of the table splits cleanly: `mise run format` handles JSON, Markdown, TOML and YAML through dprint, `mise run check` runs the static checks, `mise run build` writes the static site into `site/`, and `mise run all` is described as the canonical gate of format, check and build, identical to what CI runs. Both `mise.lock` and `uv.lock` are committed, so the tool versions and the dependency versions are pinned in the repository rather than on one machine.

Seven chapters walk a notebook into something monitored

The syllabus is seven chapters that follow one project rather than seven unrelated demos. Initializing sets up the development environment, manages Python versions and handles external dependencies. Prototyping uses Jupyter notebooks for machine learning work, explores dataset manipulation and does the first model assessments. Productionizing moves from notebooks to clean Python packages and explains modular coding and the different programming paradigms involved.

The last four chapters are about keeping the thing alive. Validating focuses on code quality through typing, linting, testing and debugging. Refining goes into CI/CD workflows, software containers and model registries. Sharing covers how to organize and document an MLOps project so other people can find and use it. Observability is the last one, aimed at understanding the behavior and performance of deployed models and the infrastructure under them.

Each chapter carries practical project instructions so you apply what you read, which is the project's answer to the criticism that most MLOps material stops at the notebook. The tools named for the whole course are uv, Ruff, ty, pytest, MLflow, mise, lefthook, GitHub and VS Code, and the pitch is aimed at both beginners and people who already ship software and want the ML side of it.

The toolchain is a short named list, which is the point

The course names its tools rather than assuming them, and the list is short enough to hold in your head: uv for dependency management, Ruff for linting, ty for typing, pytest for tests, MLflow for tracking, mise for tasks, lefthook for git hooks, GitHub for version control and VS Code for the editor.

Each name maps to a concrete decision in a later chapter. The Validating chapter is where typing and linting get their treatment, which lines up with Ruff and ty rather than with a single all-in-one checker. Productionizing is where the MkDocs site and the package layout stop being incidental and become the subject. Refining is where containers and CI/CD appear, and Observability is where MLflow belongs.

The same naming discipline shows up in the repository configuration. `lefthook.yml` is where the git hooks live, `dprint.jsonc` covers non-Python files such as Markdown and YAML, and the formatting task deliberately includes formats that have nothing to do with Python. For a course about a mixed codebase, the point is that the tool choices are inspectable in the repository rather than described in prose.

The check task scans links, secrets and vulnerabilities, not just tests

`mise run check` is where the repository's unusual configuration shows up. Its stated scope is every static check: workflows, a strict site build, formatting, secrets, scanning and vulnerabilities. That is a much wider gate than a test suite, and the root files explain which tools do what.

`trivy.yaml` is the vulnerability scanner, and the development dependency group adds `pip-audit>=2.10.1` alongside `validate-pyproject>=0.25`, which checks that the packaging metadata itself is valid. `.lycheeignore` belongs to the link checker, and a strict MkDocs build is what turns a broken internal reference into a failed check rather than a warning on the published site.

The changelog side is handled by `cliff.toml` and a committed `CHANGELOG.md`, and `AGENTS.md` sits in the root next to `CODE_OF_CONDUCT.md`. Since `mise run all` is stated to be exactly what CI runs, the practical consequence is that a contributor does not need to know which of those checks matter most: format, check and build is the whole contract, and a failure in any of them blocks the change.

Three paid paths sit next to the free course

The course text is open source under CC-BY 4.0, and the repository asks for pull requests and issues. Alongside that sit three commercial offers, all routed through the same fmind.dev contact address.

The first is one-on-one mentoring, booked through a calendar link, described as tailored guidance from the course authors. The second is group and organization training, where you contact the creators to request a personalized quote, so the price is not published. The third is the MLOps Coding Assistant, a separate tool at its own web address that provides code snippets, explanations and examples, priced at ten dollars per month and unlocked through the same address.

None of the three is required to follow the material, and the course site itself is free, but the boundary is worth seeing clearly before you start. A separate free resource sits alongside them: the Agent Skills repository, linked through agentskills.io, packages instruction sets you can add to a coding assistant so it understands the MLOps tasks this course teaches. Donations go through a Stripe link.

Python 3.14 is the floor, and the site is the versioned artifact

Two version signals line up. The published tag history runs v6.0.0 on 2026-07-07 and v7.0.0 on 2026-08-10, and the last push to the default branch was 2026-08-24, so the version in `pyproject.toml` tracks the release tags rather than drifting from them. Course material in a repository that ships releases can be referenced at a point in time, which matters when you are following instructions that depend on tool versions.

The other signal is stricter than most course repositories: `requires-python` is `>=3.14`, and a `.python-version` file sits in the root for tooling that reads it. A contributor on an older interpreter has to upgrade before `mise run install` will do anything useful, and the type checker and linter versions come from the lockfiles rather than from whatever happens to be on the machine.

For an open course that also wants contributions, the contribution path is the same pipeline as everything else: fork, change something under `docs` or the project files, then let `mise run all` decide. The repository states the license as CC-BY 4.0 with `LICENSE.txt` named in `license-files`, and the license file lives beside a code of conduct rather than being buried in a docs page.

Editorial conclusion

The MLOps Coding Course fits a developer who wants the shape of a real MLOps repository rather than a notebook tutorial, since the seven chapters and the mise gate are exactly that shape. Skip it if you need working pipeline code to copy, because the deliverable is prose and configuration. Before you start, install Python 3.14 and mise, and decide how you feel about the mentoring sessions and the ten dollar a month coding assistant, since the free course and the paid support sit in the same repository.

Frequently asked questions

Official sources

1. License: CC-BY-4.0
2. MLOps-Courses/mlops-coding-course on GitHub
3. Project website
4. README
5. Releases