MLflow Model Registry Deep Dive: Promotion, Stage Operations & Deployment

The MLflow Model Registry is the Databricks core feature that centralizes trained-model version management, promotion flows (Challenger → Champion), permission management, and deployment to Model Serving. Since 2024 Databricks has been pushing the migration from the Workspace Model Registry to the Unity Catalog (UC) Model Registry. The UC version adds enhancements such as aliases and cross-workspace sharing.

This article walks through the big picture of the Model Registry, the differences between the Workspace and UC versions, how to implement model registration and alias workflows, and how to design promotion flows.

Model Registry Overview

The Model Registry is the 'model catalog' component of the MLflow ecosystem. Once you register a model artifact from an MLflow Tracking experiment Run, the following management capabilities become available.

• Version management: multiple versions live under the same model name. Each version keeps a link to the original MLflow Tracking Run and its Model Signature.
• Alias / stage management: the UC version uses aliases (Champion / Challenger) while the legacy Workspace version uses stages (Staging / Production / Archived) to track model state.
• Permission management: the UC version controls model access with GRANT / DENY. You can strictly govern who can register, read, or promote each model.
• Model Serving integration: registered models deploy directly to Model Serving endpoints. Reassigning an alias automatically updates the inference model.

Legacy Workspace vs UC: Comparison Table

Implementing Model Registration

Here is the basic flow for registering a model in the Model Registry.

import mlflow
from mlflow import MlflowClient

# 1. Point the Registry URI at UC
mlflow.set_registry_uri("databricks-uc")

# 2. Train and record with Tracking
with mlflow.start_run() as run:
    mlflow.autolog()
    model = train_model(X_train, y_train)  # training logic
    mlflow.sklearn.log_model(
        model,
        artifact_path="model",
        input_example=X_train[:5],
        signature=mlflow.models.infer_signature(X_train, y_pred)
    )

# 3. Register in the Model Registry
model_uri = f"runs:/{run.info.run_id}/model"
mv = mlflow.register_model(
    model_uri=model_uri,
    name="prod_catalog.ml_schema.churn_predictor"
)
print(f"Registered: version {mv.version}")

# 4. Attach an alias
client = MlflowClient()
client.set_registered_model_alias(
    name="prod_catalog.ml_schema.churn_predictor",
    alias="Challenger",
    version=mv.version
)

Aliases vs Legacy Stages: Detailed Comparison

Model Promotion Flow

Here is the end-to-end promotion flow recommended for real-world use.

[Step 1: Train & Experiment]
  |  mlflow.start_run() -> autolog() -> log_model()
  |  => Recorded into an MLflow Tracking Run
  |
  v
[Step 2: Register]
  |  mlflow.register_model("runs:/{id}/model", "catalog.schema.model")
  |  => Version N is created in the Model Registry
  |
  v
[Step 3: Attach Challenger alias]
  |  client.set_registered_model_alias(..., "Challenger", N)
  |  => Marked as a production candidate
  |
  v
[Step 4: Validation (automated)]
  |  |- Accuracy tests (AUC >= 0.85 / RMSE <= threshold)
  |  |- Data drift detection (PSI / KS statistics)
  |  |- Latency test (p99 < 100ms)
  |  \- Fairness test (prediction gap across protected attributes)
  |
  v
[Step 5: Approval (manual or automated)]
  |  |- All tests pass -> ML lead approves
  |  \- Tests fail -> rejected with feedback
  |
  v
[Step 6: Champion promotion]
  |  client.set_registered_model_alias(..., "Champion", N)
  |  => Model Serving automatically switches to the new version
  |
  v
[Step 7: Previous Champion -> Archived]
     client.delete_registered_model_alias(..., "Champion")  # old version
     => Kept for reference, removed from inference

Integration with Model Serving

Models in the UC Model Registry deploy directly to Databricks Model Serving. If you specify an alias when creating the endpoint, simply reassigning that alias updates the inference model end-to-end.

# Load the model via its alias (inference time)
import mlflow

model = mlflow.pyfunc.load_model(
    "models:/prod_catalog.ml_schema.churn_predictor@Champion"
)
predictions = model.predict(new_data)

Exam Focus Points

• 'Which Databricks feature provides model versioning and promotion flows?' → UC Model Registry
• 'What is the biggest difference between the UC and Workspace versions?' → aliases vs stages, three-level namespace, and cross-workspace sharing
• 'What does mlflow.register_model() do?' → registers the model artifact from a Tracking Run into the Registry so it becomes a versioned object
• 'How do you update a model on Model Serving?' → reassign the Champion alias to the new version
• 'What is the model reference URI format?' → models:/catalog.schema.model_name@Champion

Check with a Practice Question

Frequently Asked Questions