Turn ML experiments into production systems

Deploy models faster without sacrificing flexibility. Automate machine learning workflows from model training through production inference while maintaining complete visibility.

Model Training & Deployment

From experiments to production in minutes

Automate machine learning workflow deployment from model training through production inference jobs. Run parallel hyperparameter tuning that completes in minutes, not days.

Explore ML workflows

train_model.py

1from prefect import flow, task
2from prefect_dask import DaskTaskRunner
3
4@task
5def train_model(params):
6    model = XGBoost(**params)
7    model.fit(X_train, y_train)
8    return model
9
10@flow(task_runner=DaskTaskRunner())
11def tune_hyperparameters():
12    param_grid = [
13        {"lr": 0.01, "depth": 3},
14        {"lr": 0.1, "depth": 5},
15        # 350+ combinations...
16    ]
17    models = train_model.map(param_grid)

fraud_detection.py

1from prefect import flow, task
2from prefect.deployments import serve
3
4@task
5def detect_fraud(transactions, model):
6    preds = model.predict(transactions)
7    return filter_high_risk(preds)
8
9@flow(log_prints=True)
10def fraud_detection():
11    model = load_model("production")
12    txns = fetch_recent_transactions()
13    results = detect_fraud(txns, model)
14    print(f"Flagged {len(results)} suspicious")
15
16if __name__ == "__main__":
17    serve(
18        fraud_detection.to_deployment(
19            name="fraud-detection",
20            cron="*/5 * * * *"
21        )
22    )

Production ML Systems

Support high-availability models at scale

Manage production ML systems from fraud detection to recommendation engines. Track model lineage, versioning, and performance with seamless MLflow integration.

See how Cash App did it

Focus on models, not infrastructure

Build ML pipelines natively in Python

Deploy from local to production without infrastructure complexity. No rigid DAG structures or custom DSLs—just add a decorator to your existing code.

See how it works

ml_pipeline.py

1# Your existing code
2def prepare_features(data):
3    return transform(data)
4
5def train_model(features):
6    model = XGBoost()
7    model.fit(features)
8    return model
9
10# Just add decorators!
11from prefect import flow, task
12
13@task
14def prepare_features(data):
15    return transform(data)
16
17@task
18def train_model(features):
19    model = XGBoost()
20    model.fit(features)
21    return model
22
23@flow
24def ml_pipeline(data):
25    features = prepare_features(data)
26    return train_model(features)

Team Access Control

RBAC & SCIM

ML Engineers

Deploy models, manage flows

Full Access

Data Scientists

Run experiments, view results

Read + Run

Stakeholders

Monitor performance

Read Only

Scale without limits

Enable the whole ML team securely

Self-service deployment with granular object-level access controls. RBAC and SCIM integration ensure secure collaboration across data scientists, ML engineers, and stakeholders.

Explore Prefect Cloud

Complete Visibility

Monitor training progress and production performance

Track model training progress and production performance with custom drift detection. Seamless integration with MLflow and other ML tools for comprehensive observability.

Learn about observability

monitoring.py

1from prefect import flow, task
2import mlflow
3
4@task
5def monitor_drift(model_id: str):
6    recent = get_predictions(model_id, days=7)
7    baseline = load_baseline_stats(model_id)
8    drift = calculate_drift(recent, baseline)
9
10    mlflow.log_metric("drift_score", drift)
11
12    if drift > 0.15:
13        send_alert(f"{model_id} drift detected!")
14
15    return drift
16
17@flow(log_prints=True)
18def ml_monitoring():
19    models = ["fraud-v2", "recs-v3"]
20
21    for model in models:
22        drift = monitor_drift(model)
23        print(f"{model}: drift = {drift:.3f}")

Why ML teams choose Prefect

From hyperparameter tuning to production inference—built by ML engineers, for ML engineers

Actium Healthtestimonial

I used parallelized hyperparameter tuning with Prefect and Dask to run 350 experiments in 30 minutes—normally would have taken 2 days

Andrew Waterman

Machine Learning

G2 Review

Prefect helps me to automatically schedule and run data & machine learning workflows in the cloud.

Dr. Wolfgang S.

G2 Review

Prefect elegantly solves the problem of Python script automation and data/workflow orchestration.

Andreas N.

Cash Appcase-study

With Prefect, we're doing things like pulling data, transforming features, splitting data sets, and training models.

Wendy Tang

G2 Review

Prefect allows us to monitor our machine learning models efficiently. The logging is very useful.

Kamilly R.

G2 Review

Prefect provided the flexibility to choose code storage, runners, and executors.

Sunil U.

G2 Review

Prefect's flexibility with compute resources let us run different parts of our pipeline on the right infrastructure.

ML Engineering Lead

G2 Review

Prefect has enabled our team to orchestrate the execution of a variety of services, with complex interdependencies, into a single flow.

Jonathan W.

Ready to productionize your ML workflows?

Join ML teams at Cash App, Actium Health, and more building production systems with Prefect

Get Started Book a Demo

1from prefect import flow, task

2from prefect_dask import DaskTaskRunner

4@task

5def train_model(params):

6 model = XGBoost(**params)

7 model.fit(X_train, y_train)

8 return model

10@flow(task_runner=DaskTaskRunner())

11def tune_hyperparameters():

12 param_grid = [

13 {"lr": 0.01, "depth": 3},

14 {"lr": 0.1, "depth": 5},

15 # 350+ combinations...

16 ]

17 models = train_model.map(param_grid)

1from prefect import flow, task

2from prefect.deployments import serve

4@task

5def detect_fraud(transactions, model):

6 preds = model.predict(transactions)

7 return filter_high_risk(preds)

9@flow(log_prints=True)

10def fraud_detection():

11 model = load_model("production")

12 txns = fetch_recent_transactions()

13 results = detect_fraud(txns, model)

14 print(f"Flagged {len(results)} suspicious")

16if __name__ == "__main__":

17 serve(

18 fraud_detection.to_deployment(

19 name="fraud-detection",

20 cron="*/5 * * * *"

21 )

22 )

1# Your existing code

2def prepare_features(data):

3 return transform(data)

5def train_model(features):

6 model = XGBoost()

7 model.fit(features)

8 return model

10# Just add decorators!

11from prefect import flow, task

13@task

14def prepare_features(data):

15 return transform(data)

17@task

18def train_model(features):

19 model = XGBoost()

20 model.fit(features)

21 return model

23@flow

24def ml_pipeline(data):

25 features = prepare_features(data)

26 return train_model(features)

1from prefect import flow, task

2import mlflow

4@task

5def monitor_drift(model_id: str):

6 recent = get_predictions(model_id, days=7)

7 baseline = load_baseline_stats(model_id)

8 drift = calculate_drift(recent, baseline)

10 mlflow.log_metric("drift_score", drift)

12 if drift > 0.15:

13 send_alert(f"{model_id} drift detected!")

15 return drift

17@flow(log_prints=True)

18def ml_monitoring():

19 models = ["fraud-v2", "recs-v3"]

21 for model in models:

22 drift = monitor_drift(model)

23 print(f"{model}: drift = {drift:.3f}")