Skip to main content
AI & ML OpsLast reviewed 2026-09-20

MLOps

Operating the training-to-serving lifecycle of models you build: reproducible training, versioned data and features, tested deployment, and monitoring for the drift that degrades a model nobody touched.

Overview

Read the full MLOps guidance
WHAT IT IS MLOps is the engineering discipline for taking a machine-learning model from training to production and keeping it working: versioned data and features, reproducible training runs, automated evaluation, deployment through a tested pipeline, and monitoring that watches the model's inputs and outputs rather than only its uptime. It is /devops applied to a system whose behaviour depends on data as much as on code. **Not this:** MLOps is not ModelOps: it owns the engineering lifecycle of building and serving a model, not the governance of the portfolio of models an organisation is accountable for. WHY IT EXISTS A deployed model degrades without anyone changing it. The world moves, the input distribution shifts, and a model that was accurate at launch quietly becomes wrong — while every infrastructure dashboard stays green. Meanwhile the path from a notebook to production is, in most organisations, a person. MLOps exists because models fail in ways that application monitoring cannot see, and because a training run nobody can reproduce is a result nobody can defend. WHEN TO USE IT Adopt it as soon as a model influences a production decision. The threshold is not model count or team size — it is consequence. A single recommendation model serving real users needs reproducible training and drift monitoring more than ten experimental models nobody depends on. WHO OWNS IT Data science owns model quality and the evaluation criteria. ML engineering owns the pipelines, serving infrastructure and monitoring. The product owner owns the decision that the model is fit for its purpose and the threshold at which it must be pulled. Where a model carries regulatory or material business risk, an independent validation function reviews it — that is where MLOps hands off to /modelops rather than doing governance itself. WHAT GOOD LOOKS LIKE Any production model can be retrained from recorded data, code and configuration to the same result. Features are computed identically in training and serving, because the gap between them is the most expensive recurring bug in the field. Deployment is automated and includes an evaluation gate that can block a worse model from shipping. Inputs and predictions are monitored for drift with defined thresholds and an owner. Rollback to the previous model version is a routine operation, and someone has done it recently. HOW TO IMPLEMENT Start with reproducibility: version the training data alongside the code and record the configuration of every run. Add an evaluation step that compares a candidate against the incumbent on a held-out set and fails the pipeline rather than reporting into a void. Establish a model registry so "what is in production" has a single answer. Add input-distribution and prediction monitoring with thresholds and an owner. Automate the serving deployment last — automating an unreproducible process just makes it faster. The deployment safety practices in /devops and the alerting discipline in /observability-engineering transfer directly. HOW TO ASSESS YOURSELF Pick a production model and try to reproduce its training result; time how long it takes. Ask what would alert you if its accuracy halved overnight. Ask how you would roll back, and when that was last exercised. Take the scored self-assessment at /assess, then plan the gaps with /roadmaps.

Capabilities

  • Automated evaluation gate

    A pipeline step that compares a candidate model with the incumbent on a held-out set and blocks a regression from shipping.

  • Drift monitoring

    Watching input distributions and prediction behaviour against defined thresholds, because a model degrades while every infrastructure dashboard stays green.

  • Model Deployment

    Versioned, evaluated, progressively rolled-out ML models with rollback.

  • Model deployment and rollback

    Shipping and reverting model versions as a routine, exercised operation rather than an emergency improvisation.

  • Model registry

    A single authoritative answer to which model version is in production, where it came from and what it was approved for.

  • Training reproducibility

    Recording data version, code and configuration for every training run so a production model's result can be reproduced and therefore defended.

  • Training/serving feature consistency

    Computing features identically in training and serving, closing the gap that is the most expensive recurring defect in production machine learning.

Practices

  • Champion/challenger comparison

    Evaluating a candidate against the incumbent on the same data before promotion, so 'better' is a measurement rather than a belief.

  • Retraining cadence

    A decided, reviewed schedule or trigger for retraining, rather than retraining when someone remembers or when a complaint arrives.

Metrics

  • Drift detection latency

    Time between a meaningful shift in input or prediction distribution and someone being told about it.

    Unit: days. Good direction: down.

  • Model deployment lead time

    Time from an approved candidate model to it serving traffic, which is what determines how quickly a degraded model can be replaced.

    Unit: hours. Good direction: down.

  • Model rollback time

    Measured time to return to the previous model version, from an exercise rather than an estimate.

    Unit: minutes. Good direction: down.

  • Training reproducibility rate

    Share of production models whose training result can be reproduced from recorded data, code and configuration.

    Unit: percent. Good direction: up.

Tools

  • Evidently

    Open-source evaluation and monitoring for data and model quality, including drift reporting.

    Visit site ↗
  • Feast

    Feature store that serves the same feature definitions to training and inference, closing the training/serving gap.

    Visit site ↗
  • Kubeflow

    Machine-learning workflow toolkit for building and running training and serving pipelines on Kubernetes.

    Visit site ↗
  • MLflow

    Experiment tracking and model registry giving a single answer to what is in production and where it came from.

    Visit site ↗

Architecture patterns

Reference architectures and their trade-offs live in the blueprints library.

Maturity

  1. L1 ReactiveModels reach production by hand from a notebookrequired stage

    Deployment is a person copying artifacts; the training run behind a live model cannot be reproduced and nothing watches its accuracy.

  2. L2 RepeatableTraining runs are recorded and rerunnablerequired stage

    Data version, code and configuration are captured for each run, so a production model's result can be reproduced and defended.

  3. L3 StandardizedAn evaluation gate stands in the deployment pipeline

    Candidates are compared with the incumbent on a held-out set and a regression blocks the pipeline rather than reporting into a void.

  4. L4 MeasuredInput and prediction drift are monitored to thresholds

    Distribution shift is detected against defined thresholds with a named owner, rather than surfacing as a business complaint months later.

  5. L5 OptimizedRollback and retraining are exercised operations

    Reverting to a previous model version and triggering a retrain are routine, recently practised procedures with measured durations.

Maturity for mlops is measured, not guessed — every score traces to your answers. See how maturity is scored.

Put it to work

Sources