Take predictive ML models from notebook to reliable, monitored, governed production on Kubernetes and cloud.
A hands-on 2026 roadmap for running predictive and deep-learning models in production. You will version data and features, track experiments and models in MLflow, automate continuous training, serve models on Kubernetes with KServe, and monitor drift, fairness and cost so models stay accurate long after launch.
MLOps applies DevOps, data engineering and software engineering discipline to the machine learning lifecycle: data and feature management, reproducible training, experiment tracking, a model registry, automated pipelines, deployment and monitoring. The goal is easy to state and hard to achieve: get models into production quickly, keep them accurate as the world changes, and be able to explain, reproduce and audit every model you ship.
In 2026 MLOps is mainstream infrastructure. Fraud scoring, forecasting, recommendations, pricing, credit risk and computer vision still deliver most of the measurable value from AI, and regulation such as the EU AI Act and frameworks such as the NIST AI RMF expect documented, monitored and governed models. The tooling has also consolidated around open standards: MLflow 3 for tracking and registry, Kubeflow and Airflow 3 for pipelines, KServe (a CNCF incubating project since 2025) for serving, and Kubernetes Dynamic Resource Allocation (GA in 1.34) for GPUs.
This path focuses on the classical and predictive ML lifecycle (tabular, time-series, vision and classic NLP models) operated on production infrastructure. If your main goal is running LLM, RAG or agent applications, continue with the LLMOps path, which builds on this foundation. MLOps also overlaps with DataOps (pipelines and data quality), Platform Engineering (self-service ML platforms) and SRE (SLOs for inference services).
7 stages · 28 topics · ~300 hours of focused learning. Work through the stages in order; optional topics are electives you can come back to.
Build the engineering and ML fundamentals every MLOps practitioner needs, and learn how the ML lifecycle differs from ordinary software delivery.
Write ML code as maintainable software: packages instead of notebooks, locked dependencies, type hints and unit tests. Every later stage (pipelines, serving, CI) assumes your training code is importable, testable and reproducible.
Learn enough ML to reason about what you operate: supervised learning, feature engineering, evaluation metrics, data leakage and the bias/variance trade-off. Engineers who understand metrics and failure modes design far better promotion gates and monitors.
ML workloads run as containers on Linux hosts, often with GPUs. Learn to build slim, reproducible images for training and inference, keep large data out of Git, and debug processes and resource limits on Linux.
Understand why ML systems accumulate hidden technical debt and how teams progress from manual notebooks (level 0) to automated pipelines (level 1) and full CI/CD for ML (level 2). This mental model frames every tool you learn next.
Milestone: You can train, evaluate and package a scikit-learn model as a tested, containerised Python project and explain MLOps maturity levels 0 to 2.
Treat data as a versioned, validated product: version datasets, enforce data contracts, and serve consistent features to training and inference.
A model is only reproducible if you can recreate the exact data it was trained on. Learn to version datasets and pipelines with DVC for project-scale work and lakeFS for data-lake scale (lakeFS took over stewardship of DVC in late 2025), and record lineage from raw data to model.
Most production ML incidents start as data problems: schema changes, missing values or silently shifted distributions. Add automated data contracts and validation suites that fail pipelines before bad data reaches training or inference.
Feature stores give training and serving one definition of each feature, which removes training/serving skew. Learn Feast: feature views, offline and online stores, materialisation and point-in-time correct joins for leakage-free training sets.
When data outgrows a single machine, feature pipelines move to distributed engines. Learn the basics of Apache Spark and Ray Data and how lakehouse platforms such as Databricks combine them with governance and MLflow.
Milestone: You can reproduce any training dataset by version, block bad data with automated checks, and serve the same features offline and online from Feast.
Make every experiment traceable and every model a governed, versioned artifact, then scale training with tuning and distributed compute.
Track parameters, metrics, artifacts and code versions for every run so results can be compared and reproduced. MLflow is the de facto open standard, and MLflow 3 adds the LoggedModel entity that links models to the runs, data and evaluations behind them.
A registry turns trained models into versioned, reviewable release candidates. Learn registry aliases (champion and challenger), model signatures, portable formats such as ONNX, and model cards that document intended use, data and limitations.
Scale training beyond a laptop: run efficient hyperparameter searches with Optuna, and distribute training with Ray Train or Kubeflow Trainer v2, which uses TrainJob and TrainingRuntime resources to run PyTorch jobs on Kubernetes.
ML needs tests beyond unit tests: data tests, model performance thresholds, invariance and slice tests, and infrastructure tests for training and serving. Use the ML Test Score rubric to judge production readiness.
Milestone: You can compare runs in MLflow, register a champion model with signature and lineage, and run a distributed hyperparameter search.
Automate the path from new data or code to a validated, registered model with pipeline orchestrators, CI/CD and GitOps.
Kubeflow Pipelines (KFP v2) packages each step as a containerised component and runs reproducible DAGs on Kubernetes, with caching, artifacts and lineage. It is also the pipeline format used by several managed cloud ML services.
Not every team runs Kubeflow. Apache Airflow 3 adds DAG versioning and asset-aware scheduling, Metaflow offers a data-scientist-friendly Python API, and ZenML provides a portable pipeline layer over many backends. Learn when each fits.
Apply CI/CD to three artifacts at once: code, data and models. Build pipelines that lint and test code, validate data, retrain, compare against the production model and promote through registry aliases with human approval where risk demands it.
Manage the ML platform itself as code: provision clusters and storage with Terraform, run Kubernetes-native workflows with Argo Workflows, and deploy serving configuration declaratively with Argo CD.
Milestone: A code or data change automatically triggers a pipeline that validates data, trains, evaluates against the champion and registers a challenger only when it wins.
Serve models reliably in batch, online and streaming modes, on Kubernetes with KServe and high-performance runtimes, and release new versions safely.
Choose the right pattern for the use case: batch scoring, online REST or gRPC inference, or streaming. Package models as services with FastAPI or BentoML and standardise request formats with the Open Inference Protocol.
KServe is the CNCF standard for serving predictive and generative models on Kubernetes. Learn InferenceService resources, model storage, request-based autoscaling with Knative including scale to zero, and transformers for feature lookup.
Squeeze latency and cost with optimised runtimes: NVIDIA Dynamo-Triton (formerly Triton Inference Server) for multi-framework GPU serving with dynamic batching, ONNX Runtime for portable CPU and GPU acceleration, and Ray Serve for Python-native model composition.
Release models like software: shadow deployments, canaries with automated analysis, blue-green switches and A/B tests that measure business impact. Combine KServe traffic splitting, Argo Rollouts and service-mesh routing.
Milestone: You can run a model behind a KServe InferenceService with autoscaling, observe it, and shift traffic to a new version with an automated canary and rollback.
Keep models healthy after launch: detect drift and quality decay, observe inference services, close the feedback loop and govern models responsibly.
Models decay silently as data and behaviour change. Monitor input data drift, prediction drift and, when labels arrive, real quality metrics. Evidently provides open-source reports, test suites and metrics for tabular, text and LLM data.
An accurate model that times out is still an outage. Instrument inference services with OpenTelemetry, collect latency, throughput, error and GPU metrics in Prometheus, and define SLOs and dashboards in Grafana.
Connect monitoring back to training: capture predictions and outcomes, build labelling pipelines, and trigger retraining on schedules, drift or performance drops while guarding against feedback loops that bias future data.
Fairness, explainability and documentation are now operational requirements. Measure group fairness with Fairlearn, explain predictions with SHAP, maintain a model inventory, and map controls to the NIST AI RMF and the EU AI Act.
Milestone: You run dashboards and alerts for service health and model quality, retrain automatically on drift, and publish fairness and explainability evidence for each model version.
Run ML as a shared platform: schedule and share GPUs on Kubernetes, use managed cloud ML services wisely, secure the model supply chain and control cost.
GPUs are the scarcest, most expensive resource in ML. Install drivers and device plugins with the NVIDIA GPU Operator, request devices precisely with Dynamic Resource Allocation (GA in Kubernetes 1.34), share GPUs with MIG or time-slicing, and queue batch jobs fairly with Kueue.
Know the managed alternatives and when they beat self-hosting: Amazon SageMaker AI, Google's Gemini Enterprise Agent Platform (formerly Vertex AI), Azure Machine Learning and Databricks. Compare pipelines, registries, endpoints, monitoring and lock-in.
Models are executable artifacts: pickle files can run arbitrary code and public models can be tampered with. Prefer safetensors, sign models with the OpenSSF model-signing tooling built on Sigstore, and describe models and datasets in CycloneDX ML-BOMs.
Training and inference can dominate a cloud bill. Allocate GPU and cluster cost to teams and models with OpenCost, use spot capacity for fault-tolerant training, right-size endpoints and track unit costs such as cost per thousand predictions.
Milestone: You can operate a multi-team ML platform with GPU quotas, signed model artifacts and cost visibility, and justify build-versus-buy choices against managed services.
47 tools and platforms used across this path. Focus on concepts first — tools change, principles don’t.
Build these to prove your skills. Publish each one on GitHub with a clear README and architecture diagram.
Package a scikit-learn churn model as a Python project with DVC-versioned data, pytest tests, MLflow tracking and a Docker image. Deliver a README that lets anyone reproduce the exact metrics with one command.
Define Feast feature views over a transactions dataset with an offline store and a Redis online store, train with point-in-time correct features, and serve real-time scores with BentoML or FastAPI reading the same online features.
Build a Kubeflow Pipelines (or Airflow 3) pipeline that validates data with Great Expectations, trains, evaluates against the current champion and registers a challenger in MLflow only if it wins. Trigger it from GitHub Actions on new data or code.
Deploy two model versions as a KServe InferenceService with canary traffic splitting, Prometheus metrics and Grafana dashboards, and automated rollback when latency or error-rate SLOs are breached.
Compute data and prediction drift on logged production traffic with Evidently, expose drift scores to Prometheus, alert in Grafana and trigger the retraining pipeline automatically. Document thresholds, fairness checks and limitations in a model card.
Provision a Kubernetes cluster with Terraform, install the NVIDIA GPU Operator, Kueue and KServe, define team quotas and GPU sharing, sign model artifacts with Sigstore, and publish a golden-path template that takes a data scientist from notebook to served model.
Certifications that validate this path’s skills. Always confirm the current exam version on the official page before booking.
Amazon Web Services
AWS's main ML engineering certification since the ML Specialty exam retired in March 2026, covering data preparation, training, deployment and monitoring with SageMaker AI; the refreshed MLA-C02 version rolls out from September 2026.
Official pageGoogle Cloud
Covers architecting, automating, serving and monitoring ML solutions on Google Cloud, now aligned to Gemini Enterprise Agent Platform (formerly Vertex AI).
Official pageMicrosoft
Replaced the retired DP-100 in 2026 and targets MLOps directly: MLOps infrastructure, model lifecycle and GenAIOps on Azure Machine Learning and Microsoft Foundry with GitHub Actions and Bicep.
Official pageDatabricks
Nearly half of the exam is ML Ops on Databricks (MLflow, feature engineering, model serving and monitoring), a strong fit for lakehouse-based teams.
Official pageCNCF / Linux Foundation
Hands-on Kubernetes administration underpins Kubeflow, KServe and GPU scheduling, so it is valuable for ML platform engineers.
Official pageDevOpsSchool
Instructor-led programme across the end-to-end MLOps toolchain (MLflow, Kubernetes, KServe, Databricks, observability) with hands-on projects and a scenario-based exam.
Official pageDevOpsSchool
Entry-level DevOpsSchool credential on the ML lifecycle, MLflow, Kubeflow, feature stores, serving and monitoring, matching the first half of this path.
Official pageRoles that hire for these skills.
Builds and runs the pipelines, registries, serving infrastructure and monitoring that move models from experiment to production, and keeps them reproducible and observable.
Turns prototypes into production-grade training and inference code, optimises models for latency and cost, and owns model quality after launch.
Designs the internal ML platform on Kubernetes and cloud: GPU scheduling, Kubeflow and KServe, feature stores and self-service golden paths for data science teams.
Develops models with experiment tracking, tests and model cards from day one so they can be promoted through automated pipelines without rewrites.
Implements model inventory, lineage, fairness and explainability checks and the audit evidence that regulators and internal risk teams require.
DevOps automates the delivery of code. MLOps must also version and validate data, track experiments, manage models as versioned artifacts and monitor statistical behaviour such as drift, because an ML system can degrade without any code change. MLOps reuses DevOps practices like CI/CD, infrastructure as code and observability, and adds continuous training and model governance on top.
Yes. Most measurable AI value in fraud detection, forecasting, recommendations, pricing and risk still comes from predictive models, and LLMOps is built on the same foundations: registries, pipelines, serving, monitoring and governance. Learn MLOps first, then add LLM-specific skills with the LLMOps path.
No. You need enough ML to understand metrics, data leakage and drift, but the job is mostly software, data and platform engineering. Many MLOps engineers come from DevOps, SRE or backend roles and partner with data scientists who own the modelling.
Start with Python, Git, Docker and MLflow, because experiment tracking and a model registry pay off immediately. Then add a pipeline orchestrator (Kubeflow Pipelines or Airflow), a serving layer (KServe or BentoML) and a monitoring tool such as Evidently. Kubernetes skills become essential once you run shared platforms or GPUs.
At about 10 hours a week this path takes roughly 30 weeks. Engineers with strong DevOps backgrounds move faster through the infrastructure stages, while data scientists usually spend more time on Kubernetes, CI/CD and observability.
Choose the one that matches your cloud: AWS Certified Machine Learning Engineer – Associate, Google Professional Machine Learning Engineer, or Microsoft's AI-300 Machine Learning Operations Engineer Associate, which replaced DP-100 in 2026. Databricks Machine Learning Professional suits lakehouse teams and the CKA strengthens the platform side. A portfolio pipeline that trains, serves and monitors a model still matters more than any badge.
Not for most of this path. Tabular models train on a laptop, and a local kind or minikube cluster is enough for Kubeflow Pipelines and KServe. Rent a cloud GPU by the hour only for the GPU scheduling and deep-learning serving exercises.
Join DevOpsSchool instructor-led programs with hands-on labs, real-world projects and certification guidance.
Roadmap reviewed October 2026 · Last updated 26 Oct 2026 · JSON