Reference: The MLOps Lifecycle

The lifecycle as a tiny state machine in Python — not production code, just a sketch of how the stages connect and where rollback plugs in:

# Sketch of the MLOps lifecycle as a state machine.
# Illustrative — not production code.

from enum import Enum

class Stage(Enum):
    TRAIN = "train"
    VERSION = "version"
    DEPLOY = "deploy"
    SHADOW = "shadow"
    CANARY = "canary"
    AB_TEST = "ab_test"
    MONITOR = "monitor"
    DRIFT_DETECT = "drift_detect"
    RETRAIN = "retrain"

# The forward path, in order.
FORWARD = [
    Stage.TRAIN, Stage.VERSION, Stage.DEPLOY,
    Stage.SHADOW, Stage.CANARY, Stage.AB_TEST,
    Stage.MONITOR, Stage.DRIFT_DETECT, Stage.RETRAIN,
]

def advance(current: Stage, health_ok: bool, drift_ok: bool) -> Stage:
    """Decide the next stage given the current one and its health signals.

    health_ok : did the candidate pass the gate at this stage?
    drift_ok  : is the production model still within drift tolerance?
    """
    # Rollback is a side-exit, not a stage: from canary, A/B, or monitor
    # you can drop back to the previous good version without retraining.
    if current in (Stage.CANARY, Stage.AB_TEST, Stage.MONITOR) and not health_ok:
        # In real code: swap the serving endpoint to the previous version.
        print("ROLLBACK: reverting to previous good version")
        return Stage.MONITOR   # back to watching the old model

    if current == Stage.MONITOR:
        # Monitor always hands off to drift-detect; drift-detect is the
        # only stage that branches on drift_ok. (A previous version of
        # this function branched here too, which made drift-detect
        # unreachable — monitor either oscillated with drift-detect
        # forever or jumped straight past it to retrain.)
        return Stage.DRIFT_DETECT

    if current == Stage.DRIFT_DETECT:
        return Stage.RETRAIN if not drift_ok else Stage.MONITOR

    if current == Stage.RETRAIN:
        return Stage.TRAIN   # loop closes: retrain feeds a new train cycle

    # Default: move to the next stage in the forward path.
    idx = FORWARD.index(current)
    return FORWARD[(idx + 1) % len(FORWARD)]


# Example walk-through of one promotion + one drift-driven retrain.
state = Stage.TRAIN
for step in range(12):
    print(f"step {step}: {state.value}")
    if state == Stage.CANARY:
        state = advance(state, health_ok=False, drift_ok=True)   # bad canary → rollback
    elif state == Stage.MONITOR:
        state = advance(state, health_ok=True, drift_ok=False)   # drift detected
    elif state == Stage.DRIFT_DETECT:
        state = advance(state, health_ok=True, drift_ok=False)  # still drifting
    else:
        state = advance(state, health_ok=True, drift_ok=True)

Verified output of the walk-through above (run as written, Python 3.x, no randomness involved):

step 0: train
step 1: version
step 2: deploy
step 3: shadow
step 4: canary
ROLLBACK: reverting to previous good version
step 5: monitor
step 6: drift_detect
step 7: retrain
step 8: train
step 9: version
step 10: deploy
step 11: shadow

The advance function is the whole lifecycle in miniature: a forward path, a drift-triggered loop on the right, and a rollback exit available from three points. Monitor always hands off to drift-detect unconditionally; drift-detect is the sole place that checks drift_ok and decides between looping back to monitor or falling through to retrain. In a real system each branch is a pipeline stage with its own failure mode and its own corpus article — which is what the roster table above maps.

Cross-references

• Building an ML pipeline that avoids train/serve skew)
• Experiment tracking done right: MLflow vs Weights & Biases)
• What is a feature store — and do you actually need one?)
• Model versioning and rollbacks: treating models like code)
• Containerizing a model with Docker and FastAPI
• CI/CD for machine learning: what should you actually automate?)
• A/B testing deployed models: shadow, canary, and full rollout)
• Is your model actually better? A plain-English guide to model comparison)
• Monitoring model performance in production without labels)
• How to detect and handle data drift in production)
• When should you retrain? Building a simple retraining policy)

Further reading

• Google Cloud / Google Research, Practitioners Guide to MLOps: A framework for efficient MLOps (whitepaper, 2023) — the reference taxonomy most MLOps stacks implicitly follow; pairs cleanly with the stage list above.
• Databricks, Introducing MLOps with MLflow — the MLflow model-registry and experiment-tracking view of the same lifecycle.
• Library docs: MLflow, Weights & Biases, Kubeflow, Evidently (drift), Grafana (monitoring).