MLOps Cheat Sheet

Updated 2026-04-20

Next Topic: Model Evaluation Cheat Sheet

🧠Study flashcards on this topic142 cards · spaced repetition→

MLOps (Machine Learning Operations) is a systematic discipline that extends DevOps principles to machine learning systems, enabling teams to build, deploy, and maintain production-grade AI models at scale. It bridges experimental data science and reliable production systems through automation, continuous integration, and observability. In 2026, MLOps encompasses three distinct sub-domains—traditional MLOps for classical models, LLMOps for large language models, and the emerging AgentOps for autonomous AI agents—while the EU AI Act's high-risk AI provisions (effective August 2026) and the launch of MLflow 3.0 with native GenAI and agent tracing have reshaped governance and lifecycle management across the industry.

What This Cheat Sheet Covers

This topic spans 18 focused tables and 174 indexed concepts, 142 flashcards. Below is a complete table-by-table outline of this topic, spanning foundational concepts through advanced details.

Table 1: Core MLOps PrinciplesTable 2: Model Training & ExperimentationTable 3: Data Management & VersioningTable 4: Model Deployment StrategiesTable 5: Model Serving PlatformsTable 6: Monitoring & ObservabilityTable 7: Pipeline Orchestration ToolsTable 8: Containerization & PackagingTable 9: Model Governance & ComplianceTable 10: Testing & ValidationTable 11: CI/CD for MLTable 12: Explainability & InterpretabilityTable 13: Advanced MLOps PatternsTable 14: LLMOps (Large Language Model Operations)Table 15: AgentOpsTable 16: Security in MLOpsTable 17: Cost OptimizationTable 18: Tools Ecosystem

Quick IndexSubscribe to unlock

A jump-to index of every table row in this cheat sheet.

Mind MapSubscribe to unlock

An interactive map of every table and concept in this topic.

Table 1: Core MLOps Principles

These are the foundational practices every MLOps team builds on—the same version control, CI/CD, and observability ideas borrowed from DevOps, plus the ML-specific additions of continuous training, experiment tracking, feature stores, and model lineage. Master these eleven and you have the vocabulary for everything that follows.

Principle	Example	Description
Version Control	`dvc add data/train.csv` `git commit -m "v1.2 dataset"`	Track datasets, models, and code together using Git + DVC to ensure reproducibility and enable rollback to any previous state.
Continuous Integration (CI)	`pytest tests/` `flake8 src/`	Automatically run tests and linting on every code commit to catch bugs early and maintain code quality standards.
Continuous Deployment (CD)	`mlflow models serve -m models:/prod/1` `kubectl apply -f deployment.yaml`	Automate model deployment to production with zero-downtime updates and instant rollback capability.
Continuous Training (CT)	`airflow trigger_dag retrain_model` `if drift > 0.1: retrain()`	Automatically retrain models when performance degrades or new data arrives, keeping predictions accurate over time.
Experiment Tracking	`mlflow.log_param("lr", 0.01)` `mlflow.log_metric("accuracy", 0.95)`	Record hyperparameters, metrics, and artifacts for every training run to compare experiments and reproduce best results.
Model Registry	`mlflow.register_model("runs:/abc/model", "churn_predictor")`	Centralized repository storing versioned models with metadata, lineage, and stage transitions (staging → production).
Pipeline Orchestration	`@task` `def preprocess(): ...` `@task` `def train(): ...`	Define end-to-end ML workflows as code with dependency management, scheduling, and automatic retry on failure.
Monitoring & Observability	`prometheus_client.Counter("predictions")` `evidently.metrics.DataDrift()`	Track model performance, data drift, and system health in production to detect issues before they impact users.
Automated Testing	`pytest test_model_performance.py` `assert accuracy > 0.9`	Validate data quality, model behavior, and API contracts automatically before deployment to prevent regressions.
Feature Store	`fs.get_feature_vector("user_id", 123)`	Centralized platform for storing and serving features consistently across training and inference, reducing training-serving skew.
Infrastructure as Code (IaC)	`terraform apply` `pulumi up`	Provision compute, storage, and services declaratively for consistent, repeatable environment setup across dev and prod.
Model Lineage	`SELECT * FROM lineage WHERE model_id='v3'`	Trace the full provenance of a model: which data, code version, and parameters produced it—critical for debugging and compliance.

Table 2: Model Training & Experimentation

Before a model ever reaches production it has to be trained well, and these are the levers you pull to get there. They range from squeezing the most out of your hardware—distributed training, mixed precision—to finding the best model itself through hyperparameter tuning, transfer learning, ensembles, and increasingly automated search like AutoML and NAS.

Technique	Example	Description
Hyperparameter Tuning	`study = optuna.create_study()` `study.optimize(objective, n_trials=100)`	Systematically search for optimal hyperparameters using Bayesian optimization, grid search, or random search to maximize model performance.

The rest of this section is part of the full cheat sheet

Table 3: Data Management & Versioning

Models are only as reliable as the data behind them, so you need Git-like discipline for datasets that are far too large for Git. The tools here bring versioning, time travel, ACID transactions, and quality validation to data lakes and feature pipelines—the difference between a reproducible experiment and one you can never run again.

Tool	Example	Description
DVC (Data Version Control)	`dvc add data/large_dataset.parquet` `dvc push`	Git-like data versioning that tracks large files in remote storage while keeping Git repo lightweight—ensures reproducibility.

The rest of this section is part of the full cheat sheet

Table 4: Model Deployment Strategies

Pushing a new model to all of production at once is asking for trouble. These strategies let you de-risk a release—shifting traffic gradually with canaries, keeping a rollback ready with blue-green, or validating silently with shadow deployments—and they also cover the inference patterns themselves, from sub-100ms real-time APIs to batch, streaming, edge, and serverless serving.

Strategy	Example	Description
Canary Deployment	`route 5% → v2, 95% → v1` `if v2_ok: increase to 100%`	Gradually shift traffic to new model (5% → 25% → 50% → 100%) while monitoring metrics to catch issues early.

The rest of this section is part of the full cheat sheet

Table 1: Core MLOps Principles

Principle	Example	Description
Version Control	`dvc add data/train.csv` `git commit -m "v1.2 dataset"`	Track datasets, models, and code together using Git + DVC to ensure reproducibility and enable rollback to any previous state.
Continuous Integration (CI)	`pytest tests/` `flake8 src/`	Automatically run tests and linting on every code commit to catch bugs early and maintain code quality standards.
Continuous Deployment (CD)	`mlflow models serve -m models:/prod/1` `kubectl apply -f deployment.yaml`	Automate model deployment to production with zero-downtime updates and instant rollback capability.
Continuous Training (CT)	`airflow trigger_dag retrain_model` `if drift > 0.1: retrain()`	Automatically retrain models when performance degrades or new data arrives, keeping predictions accurate over time.
Experiment Tracking	`mlflow.log_param("lr", 0.01)` `mlflow.log_metric("accuracy", 0.95)`	Record hyperparameters, metrics, and artifacts for every training run to compare experiments and reproduce best results.
Model Registry	`mlflow.register_model("runs:/abc/model", "churn_predictor")`	Centralized repository storing versioned models with metadata, lineage, and stage transitions (staging → production).
Pipeline Orchestration	`@task` `def preprocess(): ...` `@task` `def train(): ...`	Define end-to-end ML workflows as code with dependency management, scheduling, and automatic retry on failure.
Monitoring & Observability	`prometheus_client.Counter("predictions")` `evidently.metrics.DataDrift()`	Track model performance, data drift, and system health in production to detect issues before they impact users.
Automated Testing	`pytest test_model_performance.py` `assert accuracy > 0.9`	Validate data quality, model behavior, and API contracts automatically before deployment to prevent regressions.
Feature Store	`fs.get_feature_vector("user_id", 123)`	Centralized platform for storing and serving features consistently across training and inference, reducing training-serving skew.
Infrastructure as Code (IaC)	`terraform apply` `pulumi up`	Provision compute, storage, and services declaratively for consistent, repeatable environment setup across dev and prod.
Model Lineage	`SELECT * FROM lineage WHERE model_id='v3'`	Trace the full provenance of a model: which data, code version, and parameters produced it—critical for debugging and compliance.

Table 2: Model Training & Experimentation

Technique	Example	Description
Hyperparameter Tuning	`study = optuna.create_study()` `study.optimize(objective, n_trials=100)`	Systematically search for optimal hyperparameters using Bayesian optimization, grid search, or random search to maximize model performance.

Table 3: Data Management & Versioning

Tool	Example	Description
DVC (Data Version Control)	`dvc add data/large_dataset.parquet` `dvc push`	Git-like data versioning that tracks large files in remote storage while keeping Git repo lightweight—ensures reproducibility.

Table 4: Model Deployment Strategies

Strategy	Example	Description
Canary Deployment	`route 5% → v2, 95% → v1` `if v2_ok: increase to 100%`	Gradually shift traffic to new model (5% → 25% → 50% → 100%) while monitoring metrics to catch issues early.