Prefect
Python-native workflow orchestration - decorated functions become scheduled, observable flows; workers connect outbound.
One-click deploy, from $13/mo on a Miget plan.
Prefect’s pitch is that orchestration should feel like Python: decorate a function, deploy it, and the server handles schedules, retries, state, and a clean UI of every run. No DAG files, no DSL - flows are code in your repo.
The architecture is PaaS-shaped by design: this template runs the server (UI + API + scheduler, basic-auth protected) on a managed Postgres, while WORKERS - the processes that execute your flow code - run as separate apps polling outbound, exactly like this catalogue’s CI runners. No ingress to workers, scale them per workload.
Prefect Cloud’s team plans start around $100/month; the open-source server is the full orchestration engine at $13.
Upstream project: Prefect 3
#what you get
- Flows as decorated Python functions - no DSL, no DAG files
- Schedules, retries, caching, and full run observability
- Outbound-polling workers: deploy anywhere with egress
- Built-in basic auth (server and clients share one string)
- Managed Postgres backend, auto-wired
- Apache-2.0; the same engine behind Prefect Cloud
#topology
| Service | Role | Public |
|---|---|---|
| prefect | server: UI + API + scheduler (:5000, basic auth) | yes |
| db | Postgres - managed service on Miget, container locally | no |
#miget sizing
// this stack needs
2 GiB RAM · 5 GB disk · 2 services
The server is light; workers carry your code and its dependencies as separate apps sized to the workload. Valkey messaging is an optional scale-out lever upstream.
Hobby - recommended fit
$13/mo
1 vCPU · 2 GiB · 50 GiB disk
Headroom for your own apps: 2 GiB at $19/mo
Professional - production
$22/mo
1 vCPU · 2 GiB · 10 GiB disk
Dedicated resources, production SLOs - plan details
One Miget plan is a fixed pool of compute - the whole stack (managed databases included) deploys inside it, and anything left over runs your other apps. No per-service or per-seat math.
#vs. the managed service
What the hosted equivalents charge, against the flat Miget plan this stack fits on. Prices as of June 2026, sources linked.
| Service | Plan | Monthly | What you get |
|---|---|---|---|
| Prefect on Miget ★ | 2 GiB plan | $13 | this whole stack, flat - no usage meters, and room left for your own apps |
| Prefect Cloud | Starter | ~$100 | past the free Hobby tier (2 users / 5 deployments) |
#vs. other PaaS
Estimated monthly cost of running this exact stack (2 GiB RAM, 5 GB disk, 2 containers) elsewhere, from published June 2026 rates.
| Platform | Est. monthly | Notes |
|---|---|---|
| Miget ★ | $13 flat | compose stacks first-class: one deploy, dedicated vCPU, managed Postgres/Valkey, volumes and TLS all included in the plan |
| Heroku | ~$100 | no volumes; nothing between 1 GB ($50) and 2.5 GB ($250) dynos - 2 GB containers cost far more than shown |
| DO App Platform | ~$29 | no persistent volumes - stateful containers need managed DBs/Spaces (base $5 Spaces included here) |
| Render | ~$26 | per-service instances (0.5 GB $7, 2 GB $25) - every container is its own paid service |
| Railway | ~$21 | usage-based ($10/GB RAM-mo); vCPU billed separately at $20/vCPU-mo on top |
| Fly.io | ~$13 | cheapest sticker price - but burstable shared CPUs (1/16 core; dedicated vCPUs cost ~2-3×), no compose deploys (one app per container, manual wiring), managed DBs billed extra |
Estimates assume RAM fully allocated at published on-demand rates - and sticker price isn't the whole comparison: the cheaper rows buy burstable shared CPUs, per-service wiring instead of a compose deploy, and managed databases billed separately. Heroku and DO App Platform have no persistent volumes at all - stateful stacks like this one need workarounds there.
#deploy it
On Miget
- Create a Compose Stack in app.miget.com pointing at the templates repository
- Set the stack path to
prefect -
Set the required variables:
PREFECT_AUTH_STRING, user:password basic auth (clients use the same value)PREFECT_SERVER_UI_API_URL, https://<domain>/api after first deploy - the UI breaks behind a proxy without it
- Deploy. Miget layers
compose.miget.yaml(RAM, privacy, volumes, managed services) automatically
Locally first?
Every template is portable, vanilla Docker Compose - the Miget overrides are ignored locally:
git clone https://github.com/deployable-sh/stacks
cd miget-compose-templates/prefect
docker compose up -dSame files, same behavior. The template README covers connection strings and scaling notes.
#faq
Kestra or Prefect - the catalogue has both?
By language of thought: Kestra is declarative YAML authored in the UI (zero code-deployment story); Prefect is Python in your repo with the ergonomics Python people expect. Data teams split on this honestly - both are flat-priced here, so taste can decide.
Where does my flow code actually run?
In workers you deploy as separate apps: an image built from prefecthq/prefect:3-latest plus your code, started with prefect worker start against http://prefect:5000/api and the shared auth string. Workers poll outbound - no ports, no ingress, scale horizontally.
How does this compare to Prefect Cloud?
Cloud’s free Hobby tier is genuinely useful (2 users, 5 deployments); paid starts around $100/month. The self-hosted server has no user or deployment caps - Cloud adds their ops, RBAC, and push-work pools on top of the same engine.
Ship Prefect today
One compose stack, 2 GiB of RAM, from $13/month flat, and it runs on your laptop with the same files.