Prefect Data Orchestration Cheat Sheet

Updated 2026-05-15

Prefect is a modern Python workflow orchestration framework designed to turn any Python function into a reliable, observable data pipeline. Unlike legacy orchestrators that require complex YAML DAG specifications, Prefect uses native Python decorators (@flow, @task) to add orchestration capabilities while keeping code testable and intuitive. The framework embraces dynamic, event-driven workflows where tasks map over runtime data, flows pause for human approval, and automations trigger on custom events — all without forcing your logic into rigid graph structures. Prefect's hybrid execution model (client-side task orchestration with server-side tracking) means flows run anywhere — a laptop, Docker container, Kubernetes pod, or cloud function — with full observability into every state transition, retry, and cache hit.

What This Cheat Sheet Covers

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

Table 1: Core Decorators and Flow DefinitionTable 2: Retry and Cache ConfigurationTable 3: Deployments and Execution InfrastructureTable 4: Scheduling PatternsTable 5: Automations and Event-Driven TriggersTable 6: State Handlers and Lifecycle HooksTable 7: Artifacts and Result DisplayTable 8: Concurrency and ParallelismTable 9: Logging and ObservabilityTable 10: Prefect Cloud Workspace and RBACTable 11: Prefect Server Self-Hosted DeploymentTable 12: Advanced Flow and Task PatternsTable 13: Deployment and Production PatternsTable 14: Comparing Prefect to Other OrchestratorsTable 15: CLI Commands and Developer WorkflowTable 16: Prefect 3.0 Features (as of 2026)

Table 1: Core Decorators and Flow Definition

Everything in Prefect starts with two decorators — @flow wraps a function as an orchestrated workflow and @task marks the discrete units of work inside it. Master these and you understand the whole mental model: parameters are typed and validated at runtime, subflows compose pipelines from smaller flows, and async variants unlock concurrent execution for I/O-bound work.

Decorator	Example	Description
@flow	`@flow(name="etl_pipeline")` `def etl(): ...`	• Wraps a Python function as an orchestrated workflow • creates a flow run when called with full state tracking and observability
@task	`@task(retries=3)` `def extract(): ...`	• Wraps a function as a discrete unit of work within a flow • task runs are client-side, can be retried and cached individually
flow parameters	`@flow` `def my_flow(param: int): ...`	• Defines typed inputs to a flow • validated at runtime, visible in the UI, and can be overridden per deployment
task parameters	`@task` `def process(data: list): ...`	• Standard function arguments passed to tasks • serialized for caching and logging, used in cache key computation

Table 1: Core Decorators and Flow Definition

Decorator	Example	Description
@flow	`@flow(name="etl_pipeline")` `def etl(): ...`	• Wraps a Python function as an orchestrated workflow • creates a flow run when called with full state tracking and observability
@task	`@task(retries=3)` `def extract(): ...`	• Wraps a function as a discrete unit of work within a flow • task runs are client-side, can be retried and cached individually
flow parameters	`@flow` `def my_flow(param: int): ...`	• Defines typed inputs to a flow • validated at runtime, visible in the UI, and can be overridden per deployment
task parameters	`@task` `def process(data: list): ...`	• Standard function arguments passed to tasks • serialized for caching and logging, used in cache key computation