Most explanations of MLOps begin with a diagram of arrows and boxes. This one begins with a simple observation: a machine-learning model that works today may quietly stop working next month, and nothing will crash to tell you. Keeping that from happening is the whole job. The rest of this article unpacks what the work involves, in plain language and in a sensible order, for readers in IT operations who may know systems well but have not yet met models.
The problem MLOps solves
Ordinary software behaves the way its code says. If the code does not change, neither does the behaviour. A model is different, because its behaviour is learned from data, and both the data and the world it describes keep moving. A fraud score trained on last spring’s purchases meets this autumn’s shopping habits; a demand forecast meets a new supplier. The programme still runs, the service stays green, and yet its answers drift away from reality.
The Ops Atlas, in its entry for the discipline, describes MLOps as engineering work with two verbs: put trained models into production, then keep them correct. The second half of that phrase is the part that tends to be underfunded. A ride-hailing company’s 2017 write-up, which the entry cites, describes a time before it built an internal platform when there was no established path for deploying a model into production, and offline models ran as batch jobs. The platform was built because getting a model to production once is a different problem from doing it repeatably.
Three ideas that do most of the lifting
Idea one: a model is built from code and data
When administrators hear “build”, they think of a compiler turning source into a binary. The entry asks you to think of the model as a binary whose source includes the training data. Change the data and you have changed the source. That is why recording the exact dataset matters as much as recording the code version, and why the training environment, such as library versions, is written down as well.
Idea two: what you test must match what you serve
Models often fail not because the algorithm is poor but because the numbers they receive live are prepared differently from the ones they were trained on. A date may be interpreted in another time zone, or a missing value filled in with a different default. The remedy is unglamorous: compute every input using one shared piece of code, keep a log of the values received by the live service, and periodically run the same records through both routes. The expected difference is none at all.
Idea three: change is released in stages
Operations teams already know this from staged rollouts. For models, the stages have names. In shadow mode, the new model sees real requests but its answers are discarded. In a canary, a small share of traffic gets its answers. Then comes an online experiment against a business measure, because the entry points to a travel-booking case where better model metrics did not lead to a business gain.
How it differs from the operations work you know
Readers from IT operations often ask how this relates to their existing practice, and the boundaries are worth stating precisely. According to the Atlas, DevOps owns delivery culture and the software pipeline; MLOps adds data and model tests, continuous training and model release gates. AIOps is almost the mirror image: it uses machine learning to help operate IT systems, for example by grouping alerts, while MLOps is the operation of machine-learning systems. If you want to see that other side in detail, a practical roadmap of AIOps for operations teams explains how learning models are applied to operational data, and the write-up on speeding up incident resolution with AIOps shows the incident side.
Two other neighbours are worth naming. Prompts, retrieval and guardrails for language models belong to LLMOps, while the governance of a whole portfolio of models, with risk tiers and independent validation, belongs to ModelOps. Data ingestion and contracts for every consumer sit with DataOps, though MLOps keeps ownership of training snapshots and feature definitions.
A small illustration
Imagine, purely as a generic example, a warehouse team whose model forecasts weekly demand for spare parts. In January it is accurate. By June the supplier has changed packaging sizes, and a field that used to hold units now holds cartons. The service is up, the latency is fine, and the forecasts are off by a large factor. A team with only service monitoring learns about this from angry customers. A team with data monitoring sees the input distribution jump the week the supplier changed, traces it to the upstream feed, and has the supplier or the ingestion owner correct it. No retraining is needed, and none should happen, because retraining on the broken field would teach the model the wrong thing.
Contrast that with a different June, when the packaging is unchanged but a competitor’s sale draws customers away. Now the inputs look normal and the world has really moved. Here a retraining policy applies, and the staleness history shows how fast the model usually decays. The same chart can show up in both cases; only the diagnosis separates them.
What gets monitored, and why it is harder than it looks
There are three layers. The service layer is familiar: availability, latency, errors. The data layer asks whether the inputs still look sane: schema changes, missing values, shifts in distributions. The quality layer asks whether predictions are still right, and this is the awkward one, because the correct answer often becomes known only later. In the entry’s churn illustration, labels take about 30 days to mature. In the meantime, operators lean on stand-ins: how the predictions are spread out, and how often the model forecasts an event compared with a rate that has already matured.
A monitoring job can also fail quietly. The Atlas warns about a metrics gateway that never forgets: when a batch job stops, its last pushed value lingers and keeps looking healthy. The countermeasure is to watch the push timestamp as well as the value, a habit familiar to anyone who has debugged a stale dashboard.
When something changes: skew, defect or drift
The central skill is naming the problem before reaching for retraining. If the training and serving pipelines disagree, that is skew; repair the pipelines. If a feeding system started sending bad data, that is an upstream defect; repair it at the source. If the real world has shifted, that is drift, and the right reaction depends on what shifted: inputs, the frequency of outcomes, or the relationship between the two. Distinguishing these requires judgement, and the entry cautions that a single generic drift dashboard cannot do it.
Going back safely
Every release plan needs a way back. In this field the preferred method is to move an alias or traffic split to the previous version, never to retrain. Behind that sits a plain fallback that uses no learning at all, a fixed business rule for instance, and the whole thing is rehearsed about every quarter. It is the same instinct that makes operations teams test restores rather than trust backups.
Common misunderstandings in one paragraph
MLOps is not a product you buy, and a platform lacking ownership and release gates is, in the entry’s words, level zero with a nicer interface. It is not the same as putting a model behind an API, since deployment is one of seven lifecycle processes in a major cloud provider’s description. It does not demand full automation for every model, and the first rule in a well-known set of guidelines is to avoid machine learning when you do not need it.
Where to go next
If this explanation has made the subject feel manageable, the next step is to read the source itself: the Ops Atlas definition of MLOps with its scope and practices sets out the seven core practices, the worked examples and the maturity levels in detail. Begin with the smallest useful version, which is a repeatable training run, a registry that tracks where each version came from, and a way to step back. Add the rest when somebody genuinely needs it.

