Most machine learning projects do not fail in the notebook. They fail in the months after launch, when the data changes, nobody can reproduce the model that is running, and a quiet drop in accuracy goes unnoticed until a customer complains. MLOps is the discipline that exists to prevent exactly that. This guide explains what MLOps is, how it differs from DevOps, what each stage of the machine learning lifecycle needs, how to judge your team's maturity, and what changes when the model is a large language model.
What is MLOps? A working definition
MLOps (machine learning operations) is the set of practices, tools and team habits that take a machine learning model from experiment to production and keep it reliable there. It borrows continuous integration and delivery from DevOps, adds the parts DevOps never had to deal with (data versioning, experiment tracking, model registries, drift monitoring, retraining) and wraps them in governance so you can answer, at any time, which model is serving, what data trained it and whether it still performs.
Google's architecture guide frames it as applying continuous integration (CI), continuous delivery (CD) and continuous training (CT) to ML systems. That last term is the clue: in ordinary software, a release stays correct until someone changes the code. In ML, a model can become wrong while the code stays identical, because the world it was trained on keeps moving.
A useful way to hold the definition in your head: MLOps manages three things that change at different speeds. Code changes when engineers commit. Data changes every day, whether you like it or not. The model changes when you retrain, and it decays between retrainings. DevOps was built for the first. MLOps exists for all three.
Why machine learning needs its own operations discipline
In 2015, a group of Google engineers published Hidden Technical Debt in Machine Learning Systems at NeurIPS. Its central observation still holds: the model code is a small part of a real ML system, surrounded by much larger amounts of data collection, feature extraction, configuration, serving infrastructure and monitoring. The paper names the risks that make ML maintenance expensive, among them entanglement (change one input and everything shifts), hidden feedback loops, undeclared consumers of a model's outputs, unstable data dependencies and changes in the external world.
Those risks translate into failures every ML team recognises:
- Nobody can reproduce the production model. The notebook used a dataset snapshot that no longer exists, a library version nobody pinned and a random seed nobody recorded.
- Training and serving disagree. A feature is computed one way in the training pipeline and another way in the live service, so the model sees inputs at inference time that it never saw in training. This is training-serving skew, and it can silently cost accuracy from day one.
- Performance decays without an error. The service returns 200 OK while predictions get worse, because the customers, prices, fraud patterns or language in the input data have changed.
- Releases are manual and scary. A data scientist emails a model file to an engineer, who wraps it in an API. Rolling back means finding the old file.
MLOps answers each of these with a practice: versioned data and environments, a shared feature definition, monitoring of the model's inputs and outputs, and an automated, reversible release path.
MLOps vs DevOps: what is the same and what is new
MLOps is not a replacement for DevOps; it is DevOps extended to systems whose behaviour is learned from data. The table shows where the two overlap and where ML adds work.
| Concern | DevOps | MLOps adds |
|---|---|---|
| What is versioned | Code, configuration, infrastructure | Plus datasets, features, trained models, experiment runs |
| What is tested | Unit, integration, end-to-end | Plus data validation, model quality against a baseline, fairness and slice checks |
| What triggers a release | A code change | A code change, new data, a schedule or detected drift |
| What "healthy" means | Uptime, latency, error rate | Plus prediction quality, input drift, output distribution |
| Typical artifacts | Container images | Container images, model files, feature definitions, model cards |
Day to day, the biggest difference is testing. A DevOps pipeline asks "does the code do what it did yesterday?" An MLOps pipeline also asks "is today's data shaped like the data we trained on?" and "is the new model actually better than the one in production, on the cases that matter?"
The MLOps lifecycle, stage by stage
The lifecycle is a loop, not a line: monitoring feeds back into data and retraining. Each stage below has one job and one artifact it hands to the next.
These stages, with the tools and the decisions behind each, are the structure of our MLOps: The Machine Learning Lifecycle in Production course, which goes from experiment tracking to drift detection and continuous training with hands-on exercises.
1. Data ingestion and validation
Everything downstream inherits the quality of the data. A production pipeline validates every new batch before training touches it: schema (expected columns and types), ranges, missing-value rates, category sets and basic distribution checks. A batch that fails is quarantined, not silently trained on. Labels deserve the same scrutiny: inconsistent annotation guidelines produce a model that learns the inconsistency.
The engineering side of this stage, from pipelines to data quality contracts, is covered in Data Engineering for AI.
2. Experiment tracking and reproducibility
Every training run should log its parameters, metrics, code version, data version and environment, so any result can be traced and rerun. Experiment trackers such as MLflow or Weights & Biases record runs; tools such as DVC version the datasets that live outside git. The test of this stage is simple: could a colleague retrain last month's best model from the logged information alone, without asking you?
3. Training pipelines
A notebook is a good place to explore and a bad place to produce a model you will ship. A training pipeline turns the steps (extract data, validate, build features, train, evaluate) into code that runs the same way every time, usually on an orchestrator such as Airflow, Kubeflow Pipelines or Metaflow. The point is not the tool; it is that training becomes a repeatable job instead of an event that depends on one person's laptop.
4. Model registry and versioning
The model registry is the source of truth for which models exist, which version is approved and which is serving. Each registered version links back to the run, data and code that produced it. In MLflow, aliases such as champion and challenger act as movable pointers to specific versions, so the serving code loads "the champion" and promotion becomes a pointer change, not a redeploy. Rollback is the same operation in reverse.
5. CI/CD for machine learning
Continuous integration for ML runs the usual code tests plus data tests and model tests: does the pipeline still produce a model, does that model beat the current baseline on a held-out set, does it hold up on important slices (a region, a customer segment, a rare class) rather than only on the average? Continuous delivery then packages the approved model and its serving code and moves it through environments. Continuous training, the part DevOps has no word for, reruns the training pipeline automatically when new data or a trigger arrives.
6. Serving and deployment strategies
Models are served in one of three patterns: batch (score a table overnight), online (a request-response API with a latency budget) or streaming (score events as they arrive). New versions should reach users gradually:
- Shadow deployment: the new model receives real traffic and its predictions are logged, but users still get the old model's answers. Good for catching surprises at zero user risk.
- Canary release: a small share of traffic goes to the new model, with automatic rollback if metrics degrade.
- A/B test: traffic is split deliberately to measure business impact, not only model metrics.
7. Monitoring and drift detection
ML monitoring goes beyond uptime. You watch the inputs (are feature distributions shifting? this is data drift), the outputs (is the share of positive predictions moving?), and, when ground-truth labels arrive, the actual quality. Concept drift is the harder case: the relationship between inputs and the correct answer changes, as when fraudsters adapt to the model. Labels often arrive late, days or weeks after the prediction, so input and output drift are your early warning while you wait for real accuracy numbers.
8. Retraining and the feedback loop
When monitoring shows decay, or on a schedule, the training pipeline runs again on fresh data, the new candidate is evaluated against the champion, and only a better model is promoted. Automated retraining needs guardrails: a minimum data quality bar, a mandatory comparison with the current model, and a human approval step for high-stakes systems. Retraining automatically on bad data is a faster way to ship a worse model.
MLOps maturity levels: where is your team?
Two public maturity models are widely used to place a team on the path.
Google Cloud's MLOps guide describes three levels:
- Level 0, manual process. Data scientists train models by hand, often in notebooks, and hand a model file to engineering. Releases are rare and there is no CI/CD or monitoring of model quality. Google notes this is the most common starting point.
- Level 1, ML pipeline automation. The training pipeline is automated, which enables continuous training: the model is retrained on new data without manual steps. The pipeline code itself is still deployed by hand.
- Level 2, CI/CD pipeline automation. The pipelines themselves are built, tested and deployed automatically, so teams can ship new pipeline versions quickly and safely.
Microsoft's MLOps maturity model (linked in the sources below) uses five levels, from 0 (no MLOps: data scientists working in isolation) through DevOps without MLOps, automated training and automated model deployment, up to fully automated operations. It also scores people and processes, not only technology, which is a useful reminder that a team with good tools and no ownership is still at level 0.
How to use a maturity model honestly: do not aim for the top level by default. A model retrained twice a year for an internal report does not need continuous training. A fraud model facing adversaries every day does. Pick the level that matches how fast your data changes and how costly a wrong prediction is, then close the gaps one at a time.
The MLOps tool stack in 2026
There is no single MLOps product; there is a stack of categories, and most teams combine open-source tools with their cloud provider's managed services. The categories matter more than the brand names:
| Category | Job | Common examples |
|---|---|---|
| Experiment tracking | Log runs, parameters, metrics | MLflow, Weights & Biases |
| Data versioning and lineage | Version datasets, trace origins | DVC, lakeFS |
| Feature store | One definition of each feature for training and serving | Feast, Tecton |
| Orchestration | Run pipelines on schedule or trigger | Airflow, Kubeflow Pipelines, Metaflow |
| Model registry | Versions, approvals, aliases | MLflow Model Registry, cloud registries |
| Serving | Expose models as APIs or batch jobs | KServe, BentoML, NVIDIA Triton |
| Monitoring | Drift, quality, data checks | Evidently, cloud monitoring services |
The managed platforms (Amazon SageMaker, Google Vertex AI, Azure Machine Learning, Databricks) bundle several of these categories. They cost less engineering time to start and more flexibility later; open-source stacks are the reverse. For a small team, the managed route plus one good experiment tracker is usually the faster path to level 1.
MLOps for large language models: what changes
Teams that build on large language models often ask whether MLOps still applies when they never train a model. It does, with a different centre of gravity, often called LLMOps:
- Prompts are versioned artifacts. A prompt change can alter behaviour as much as a retrained model, so prompts belong in version control and in a registry, with an evaluation run before each change ships.
- Evaluation replaces accuracy. Outputs are open text, so quality is measured with curated test sets, rubric-based grading and human review rather than a single metric. Our guide to LLM evaluation covers how to build those test sets, and the LLM Evaluation and Testing course goes deeper into evaluation pipelines.
- The provider can change the model under you. Model versions are retired on the provider's schedule, so pinning versions and re-running evaluations before a migration is a routine operation, not an emergency.
- Cost is a first-class metric. Token usage, cache hit rates and cost per request sit on the dashboard next to latency.
- Fine-tuning brings classic MLOps back. The moment you fine-tune, you have datasets, training runs, model versions and a registry again.
Monitoring also shifts: instead of feature drift, you watch for changes in the kinds of questions users ask, refusal rates, hallucination reports and the share of answers that fail your automated checks.
Who does MLOps?
In small teams, MLOps is a responsibility shared by whoever builds the model and whoever runs the infrastructure. As teams grow, dedicated roles appear: ML engineers who turn experiments into production pipelines, MLOps or ML platform engineers who build the shared infrastructure (registry, feature store, serving) that every model team uses, and data engineers who own the pipelines feeding them. Site reliability engineers bring incident response practice; our article on AIOps for DevOps and SRE covers the neighbouring discipline of using AI to run infrastructure, which is easy to confuse with MLOps but solves a different problem. If you are weighing these roles as a career move, see What Is an AI Engineer? for how they compare.
A minimal MLOps setup for a small team
You do not need a platform team to stop the most common failures. This sequence gets a two-to-five-person team from level 0 to a solid level 1:
- Put everything in git except the data: training code, feature code, configuration, and a pinned environment file.
- Track every experiment with one tool, logging parameters, metrics, the git commit and a pointer to the data version.
- Version the training data with a data versioning tool or immutable, dated snapshots in object storage.
- Turn the winning notebook into a pipeline that runs end to end with one command, then on a schedule.
- Register models with a registry and serve "the champion" alias instead of a file path.
- Share feature code between training and serving, so the same function computes each feature in both places.
- Add a release gate: a new model must beat the champion on a fixed evaluation set and on your critical slices before promotion.
- Monitor inputs and outputs from day one, with alerts on drift and on prediction distribution changes.
- Write down rollback and test it once, before you need it.
Each step removes a specific failure from the list at the top of this article, which makes the case to management easier than "we need MLOps".
Common MLOps mistakes
- Buying a platform before defining the process. Tools amplify a process; they do not create one.
- Monitoring only infrastructure. Latency and error rate stay green while the model degrades.
- Evaluating only on the average. A model can improve overall and get worse on the customer segment that matters most.
- Automating retraining without a gate. Continuous training without a comparison step can promote a worse model automatically.
- Ignoring governance until an audit. Model cards, data lineage and approval records are cheap to keep from the start and expensive to reconstruct. For systems in scope of the EU AI Act, documentation and logging are legal obligations, not nice-to-haves.
Frequently Asked Questions (FAQ)
What is MLOps in simple terms? MLOps is the set of practices and tools that take a machine learning model from an experiment to a reliable production service and keep it working: versioning data and models, automating training and deployment, and monitoring the model so it is retrained when its performance decays.
What is the difference between MLOps and DevOps? DevOps automates building, testing and releasing code. MLOps applies the same ideas to machine learning and adds what code-only systems do not need: versioning datasets and models, testing data and model quality, monitoring for drift, and continuous training when new data arrives.
What are the MLOps maturity levels? Google describes level 0 (manual process), level 1 (automated training pipeline with continuous training) and level 2 (automated CI/CD for the pipelines themselves). Microsoft's model uses five levels, from no MLOps to fully automated operations, and also assesses people and processes.
Is MLOps the same as LLMOps? LLMOps is MLOps adapted to large language models. Many practices carry over, such as versioning, evaluation gates and monitoring, but the focus shifts to prompt versioning, evaluation of open-ended outputs, provider model changes and token cost, unless you fine-tune, in which case classic MLOps applies again.
Which tools do I need to start with MLOps? Start with git, one experiment tracker, a way to version data, a pipeline that runs end to end and a model registry. Monitoring for drift should follow before or right after the first production launch. A managed cloud ML platform can provide several of these in one place.
Conclusion
MLOps is what turns a model that worked once into a system that keeps working. It extends DevOps to cover data, experiments, model versions, drift and retraining, and its value shows up as failures that never happen: the model nobody can reproduce, the training-serving skew nobody noticed, the accuracy that decayed for months behind a green dashboard. Start by placing your team honestly on a maturity model, pick the level your data and risk actually require, and close the gaps one stage at a time, beginning with tracking, versioning, a release gate and monitoring.
Sources
- MLOps: Continuous delivery and automation pipelines in machine learning, Google Cloud Architecture Center
- Hidden Technical Debt in Machine Learning Systems, D. Sculley et al., NeurIPS 2015
- Machine Learning operations maturity model, Microsoft Azure Architecture Center
- MLflow Model Registry, MLflow documentation
Verified on 15 November 2026 against the cited documentation. Tool names are examples of each category, not endorsements; check current documentation before adopting one.
The course that continues this article
MLOps: The Machine Learning Lifecycle in Production
You have read the theory. In the course you put it into practice: written lessons structured in modules, with examples and exercises, quizzes, the AI Professor in every lesson and progress saved automatically. Once you complete the lessons and reach the minimum quiz score, you get the Certificate of Completion, a private attestation.
From the course syllabus
- MLOps Foundations and Maturity in 2026
- Experiment Tracking and Reproducibility
- Data and Feature Management
- Training Pipelines and Orchestration
+ 6 more modules in the full syllabus
€99 per month for this course, VAT included · or pick it in a subscription of 3, 5 or 10 courses, from €199 per month, together with other IT courses; you can change them at every renewal (see what you learn across the whole track).
Monthly subscription with automatic renewal · stop the renewal anytime from your account · digital content with immediate access, see the withdrawal conditions. The certificate confirms that you completed the course and is private: it is not a diploma or a state-recognised qualification.