Skip to content

Control Plane vs Fly.io

ComparisonFly.io
Last updated
First published
6 min read
Control Plane
vs
Fly.io
Managed infra or your own accounts/on-prem
Where workloads run
Fly's edge network only
Runs across clouds
Yes
Scale-to-zero
Auto-stop
Consumption-based
Cost model
Usage on Fly
Containers, VMs, Sandboxes
Workload types
Machines / apps
PCI L1, SOC 2, HIPAA
Compliance built in
SOC 2, HIPAA

Control Plane runs the same containers and full VMs across the major clouds and on-prem as one virtual cloud, on managed infrastructure by default or in your own accounts, with control over where each workload runs, geo-intelligent routing to the nearest deployment, no cluster you have to operate, and scale-to-zero. It adds platform-level PCI DSS Level 1 for regulated workloads. Fly.io hosts your app as Fly Machines on its own global edge network. Both get a container running close to users, but if you need control over where workloads run, virtual machines, multi-cloud portability, or PCI DSS Level 1, Control Plane is the layer that covers it, where a single-vendor edge stops at its own network.

Both platforms take a standard container and get it running close to your users without you managing servers. They differ on functionality and portability. Control Plane is a multi-cloud runtime: it runs the same container on hardened, managed infrastructure by default, or in your own AWS, GCP, Azure, and on-prem accounts, stitched into one virtual cloud with geo-intelligent routing, full VMs, and platform-level compliance. You control where each workload runs and stay portable across the major clouds. Fly.io deploys your app as Fly Machines onto its own global edge network, tied to Fly's platform and region footprint.

The core difference: a portable multi-cloud runtime vs a single-vendor edge

Control Plane is a runtime that unifies clouds. By default it runs your standard containers on hardened, managed clusters in its own cloud accounts, in the regions you choose. It can also run them across any mix of clouds, regions, Kubernetes clusters, and on-prem servers in your own accounts, stitched into one virtual cloud, with placement, identity, networking, security, and scaling handled uniformly on top. Requests are steered by geo-intelligent DNS with health-based failover to the nearest healthy deployment, typically around 20 to 30 milliseconds away. You get edge-like proximity while keeping control over which cloud and region each workload runs in, plus full VMs and platform-level compliance.

Fly.io works differently: you hand it a container, pick some regions, and it runs your app as Fly Machines on its own edge infrastructure, working at the machine level for each instance. The infrastructure is Fly's own, so workloads run on Fly's network rather than in your cloud accounts, and your global footprint is limited to Fly's region list. The question is whether you want an app tied to a single vendor's edge or a compliance-grade layer that unifies clouds, runs VMs, and lets you own where each workload runs.

Why teams look past Fly.io

The reasons teams weigh Control Plane against Fly.io come down to functionality, control, and portability. The first is control over where workloads run: teams that need data, compute, and spend to sit inside their own AWS, GCP, or Azure agreements, or in specific regions, cannot commit everything to a third party's edge. The second is data residency and compliance, where you must be able to say exactly which cloud and region a workload runs in, backed by controls like PCI DSS Level 1, SOC 2 Type II, HIPAA, and GDPR. The third is portability beyond a single provider's footprint: if your users or your regulators require specific regions across the major clouds, running across those clouds beats being limited to one network's edge locations. The fourth is scale and workload mix, when you need containers, VMs, cron, and stateful services, plus Sandboxes for AI agents and untrusted code, under one model. Fly.io hosts an app on its own edge; Control Plane covers those functionality, control, and portability requirements that a single-vendor edge does not.

Which one should you pick?

Choose Control Plane if...

  • You want control over where the app runs, on managed infrastructure or in your own AWS, GCP, Azure, and on-prem accounts.
  • You need data residency and compliance: PCI DSS Level 1, SOC 2 Type II, HIPAA, GDPR, with control over which cloud and region runs each workload.
  • You want global reach across the major clouds, with geo-routing to the nearest deployment around 20 to 30 milliseconds away.
  • You want no cluster or machines to operate by default, with the option to run Managed Kubernetes (MK8s) or Bring Your Own Kubernetes (BYOK) when you want a cluster, plus scale-to-zero and automatic right-sizing.
  • You run a mix of containers, VMs, cron, and stateful services, plus Sandboxes for AI agents and untrusted code, under one model.

Where Fly.io differs

  • It hosts your app as Fly Machines on its own global edge network.
  • It works at the machine level, where you size and configure each instance.
  • Its footprint is Fly's own region list, not your cloud accounts.

These are single-vendor edge characteristics. Control Plane gives you geo-routing to the nearest deployment across the major clouds and on-prem, without giving up control over placement, compliance, VMs, or multi-cloud portability.

When a region, a cloud, or an account goes down

Every platform has outages, and so do the clouds underneath all of us. On Control Plane, a workload runs in every location of its Global Virtual Cloud (GVC™) at the same time, across AWS, GCP, Azure, and OCI regions and your own clusters. Traffic goes to the nearest healthy location using latency-based DNS geo-routing. When a location stops passing health checks, it drops out of routing and the others keep serving.

One workload on three clouds. The AWS location fails its health checks, leaves routing, and GCP and Azure keep serving.
  • A region fails

    The GVC routes around it. Users who were reaching that region land on the next-nearest healthy location. If you want a specific backup instead of the closest one, priority tiers send traffic to the location you chose.

  • A cloud provider fails

    With locations on more than one provider, a provider-wide outage takes out only that provider's locations. Your GCP and Azure locations keep serving the same workload behind the same endpoint while AWS recovers.

  • A cloud account fails

    Locations can run in Control Plane's cloud accounts or in your own accounts and clusters (BYOK). Spread a GVC across more than one account, and an account that is suspended or misconfigured becomes one more location for the GVC to route around.

Two conditions apply. Failover needs at least two replicas in at least two locations, which is also the condition on our 99.999% SLA. And data does not move by itself: each replica gets its own volume, so a database that has to survive the loss of a location needs replication at the application level, such as Postgres WAL streaming between locations.

Fly.io's public incident reports

Control Plane vs Fly.io, side by side

58 capabilities, scored from each vendor's public documentation with the same rules applied to both columns. Hover a capability for what it measures, or a verdict for the reason behind it.

Workload placement & topology5
Can one logical environment span two different cloud providers at once?Yes: One environment spans locations across AWS, GCP and Azure; a workload deploys to all of them at onceNo: Own hardware
Number of publicly published regions or locationsYes: Around 30 managed regions across AWS, GCP, and Azure, plus any location you bringYes: 18 published
Can you attach your own Kubernetes cluster as a managed target?Yes: Registers a customer's own Kubernetes clusters as first-class locations, equal to native onesNo: FKS is Fly-managed only, closed beta
Automatic failover of a running workload to another locationYes: DNS geo-routing drops unhealthy locations automaticallyPartial: Anycast plus app-driven fly-replay
Fine-grained traffic steering across locations (priority, latency bias)Yes: routingTier priority groups, latency offset and tolerance per locationPartial: Anycast plus RTT
Getting to first deploy6
Git push to a branch triggers build and deploy with no external CIYes: Builds directly from a connected GitHub or GitLab repositoryNo: No native branch-push deploy; GitHub Actions is the documented path
Built-in image builder (no Dockerfile required)Yes: CLI build using Buildpacks with language auto-detection; Heroku, Google and Paketo builders; builds locally or remotelyYes: Remote builders; Dockerfile optional if a scanner matches
Named framework guides (Next.js, Django, Rails, Laravel…)Partial: Buildpack language conventions for Node, Python, Go, Java, Ruby, PHP, Rust — not per-framework guidesPartial: 14 total: 7 in-depth plus 7 starters
One-click template or app catalogYes: Template catalog, 87 entries (databases, queues, analytics, and more); deployable from the UI, CLI, Terraform, or PulumiNo: No marketplace
Documented free tierYes: The account is free to create and set up, with no cloud account required; you pay only once workloads use computeNo: No true free tier; card required; $25 prepaid minimum
Local development story (emulator, local run, tunnel)Partial: Deploys a docker-compose project directly; port-forward and shell for working against remote instancesNo: Not documented
Migration in1
Import from an existing platform (Heroku, compose, Kubernetes manifests)Yes: Consumes docker-compose files directly, and converts Kubernetes manifests with a preview of the translationPartial: Heroku guide, manual
Scaling & efficiency5
Metric-driven horizontal autoscalingYes: concurrency, rps, cpu, latency percentile, memory, KEDA, multi-metricNo: autostop/autostart never creates Machines
Automatic vertical resizing of a running workloadYes: Analyses historical usage and resizes container CPU and memory in place, without a restart; update frequency is throttleablePartial: Resizing replaces the VM rather than adjusting it in place; their agent-sandbox product does grow memory automatically under pressure
Scale to zero with automatic wakeYes: Request-rate or concurrency triggers on serverless workloads; event-driven via KEDA for long-running and stateful onesYes: Stop or suspend; resume from suspend in a few hundred ms
Published cold-start or wake latency figuresNo: No figures publishedYes: ~2 s cold, a few hundred ms from suspend
Spot or preemptible instance supportPartial: Spot allocation in Managed Kubernetes node poolsNo: Not documented
Networking & edge7
First-party CDN or edge cachingNo: Docs cover configuring an external CDN; no first-party CDNNo: Anycast routing to instances, not edge caching
First-party managed WAFNo: External CDN/WAF compatible; none first-partyNo: Not documented
Egress control: restrict which destinations a workload may reachYes: Outbound CIDR allow and block, hostname allowlist, port restrictionPartial: Port and protocol allow-lists; a DNS hostname allowlist exists only inside their agent-sandbox product, not on the main platform
Private connectivity into a customer VPC or on-prem networkYes: An agent inside the private network tunnels TCP and UDP from workloads to internal endpoints; newer protocol adds HA across agent instances and bi-directional trafficPartial: WireGuard 6PN, self-operated
Encrypted service-to-service networking as a platform defaultYes: Sidecar-based service mesh providing mTLS between workloads by defaultYes: WireGuard 6PN mesh, org-wide
Application-layer request authentication at the edgeYes: JWT validation at the edge: multiple issuers, remote JWKS, claim-to-header mapping, per-path rulesNo: Not documented
Static IP addresses for inbound or outbound trafficYes: Reserved static public IP per location, attachable to a load balancerYes: Per-region pairs, 64 machines per IP
Storage & data services6
Managed relational or key-value databases as a first-party productYes: Postgres, Redis, MySQL, and more from the template catalogPartial: Managed Postgres v2 beta; others via partners
Persistent volumes attachable to a scaled-out workloadYes: One volume per replica, preserved when the workload scales downPartial: Strict 1 volume per Machine, 500 GB max
Automatic volume growth before capacity is exhaustedYes: Expands on a free-space threshold, and also projects a growth rate from recent usage to expand ahead of needPartial: Auto-extend on threshold
Backup and restore with scheduled retentionPartial: Snapshot and restore are available as commands; no scheduled backup or retention policy documentedYes: Daily, 5-day default, configurable 1-60 days
Static site hosting as a first-class productNo: Not documentedNo: Docs say plainly 'a static site isn't an app'
First-class background jobs, queues and cronPartial: Cron workload type and one-off runs; no managed queue primitiveNo: No first-class managed cron or queue primitive
Identity & secrets6
How a workload authenticates to external cloud servicesYes: A single identity grants a workload least-privilege access to resources in AWS, GCP and Azure simultaneously, with no credentials stored in the workloadPartial: OIDC tokens for AWS, Azure, GCP and Vault, but you mint and refresh them yourself
Secrets management with access control on retrievalYes: Typed secret kinds with a runtime permission gate — a workload without an explicitly granted identity cannot read a secret at allPartial: Vault-backed env vars
Role-based access control granularityYes: Permissions expressed as verbs per resource type, granted to users, service accounts, groups, or workload identitiesNo: 2 roles
Audit trail of platform changesYes: Tamper-proof audit trail covering platform actions, and extensible so an application can write its own entries into the same trailNo: Audit logs do not exist
Third-party compliance certificationsYes: SOC 2 Type II, PCI DSS Level 1, HIPAA, GDPRPartial: SOC 2 Type 2 and HIPAA, but no audit logs
Multi-tenancy for the customer's own end customersPartial: Top-level tenancy boundaries give hard isolation, but per-end-customer tenancy is not positioned as a use caseYes: A dedicated doc recommending one app per end customer
Operations & observability8
Metrics with a queryable interfaceYes: Scrapes Prometheus-format metrics from containers on a 30s interval with regex filtering; queryable through a per-org GrafanaYes: Managed Prometheus plus Grafana
Distributed tracingYes: Distributed tracing with custom tags and a configurable sampling rate, set at environment levelNo: Not documented
Managed log export to third-party destinationsYes: Datadog, CloudWatch, Coralogix, Logz.io, S3, Stackdriver, SyslogNo: DIY Vector shipper
Default log retentionYes: 30 days by default, adjustable per orgPartial: 30 days, not configurable
Built-in alerting with notification channelsYes: Pre-provisioned alert rules with configurable contact points; notifications are off until a contact point is addedNo: No built-in alerting; Sentry only
Shell, file copy and port-forward into a running workloadYes: Interactive shell into a replica, file copy in and out, and local port-forwarding — all from the CLIYes: fly ssh console, fly sftp, fly proxy
Progressive delivery: weighted traffic between versionsYes: Route-level traffic splitting by integer weight across workload versions; weighting everything to the new version performs a blue/green cutoverPartial: Four selectable strategies, no percentage weighting
Ephemeral preview environment per pull requestYes: Per-PR preview environmentsPartial: A blueprint recipe, not a product
Automation & extensibility6
First-party infrastructure-as-code provider (Terraform or equivalent)Yes: First-party Terraform and Pulumi providers, plus a Kubernetes operator exposing platform resources as CRDs for ArgoCDNo: Archived by Fly in Mar 2024
Complete public API referenceYes: Full API and CLI referenceYes: Machines REST API with OpenAPI
MCP server for AI-agent operation of the platformYes: First-party, with documented setup for Claude, Codex, Cursor, Gemini CLI, VS Code and AntigravityPartial: A CLI-backed MCP server plus a second remote one for the sandbox product; scaling operations are absent from both tool sets
Machine-readable documentation (llms.txt, per-page markdown)Yes: llms.txt published and referenced from every pageYes: llms.txt plus an AI-Agent header convention
Ephemeral sandboxes for running untrusted or AI-generated codeYes: Sandboxes documentedYes: Firecracker microVMs with checkpoint and in-place restore, a DNS-based egress allowlist, four language SDKs and published wake latencies (branded Sprites)
Core product available as open sourceNo: Not open sourcePartial: The CLI is Apache 2.0; the platform itself is not
Specialized compute2
Run full virtual machines, not just containersYes: VMs run with their own guest OS and kernel while sharing the same mesh, identity, firewall and observability as containers; supports Windows guests and lifting existing VM disk imagesPartial: Compute units are Firecracker microVMs, but there is no path to lift an existing VM disk image
Run GPU workloads alongside standard servicesYes: NVIDIA T4 and A10G requested per container in the standard workload spec, drivers managed by the platform, billed at standard unit rates; GPU capacity from any provider, including neoclouds, joins through attached or provisioned Kubernetes clusters; automatic right-sizing does not apply to GPU workloadsNo: GPU Machines were sunset July 31, 2026; GPU docs and pricing removed
Commercial terms6
Published compute and memory unit pricesNo: No price list in the documentation snapshotPartial: Machine presets, not unit rates
Published uptime SLA with a numberYes: 99.999% uptime SLAYes: 99.9% at $2,500+/mo support
Documented path to migrate off the platformPartial: Environment export produces a portable spec, and workloads are OCI images that can run on the customer's own clusters; no migration-out guide publishedNo: Not documented
Public community channelPartial: Support via Slack and Discord referenced in docs; no public community forum documentedYes: Large public Discourse forum
Named reference customers publishedPartial: Customer stories exist off-docs; none named in the documentation snapshotYes: Supabase, Tailscale, Upstash, Turso, Mailgun
Vendor continuity risk signalsPartial: Independent; funding and headcount not documented in the snapshotNo: Reversed an explicit GPU continuity promise within ~2 years and left docs stale past EOL

Scored from public documentation as of September 2026. “No” means not documented, not necessarily absent; breadth is not a quality ranking, and specialists doing one thing well score narrow by design.

Which fits your scenario

Control Plane fits: a company running in regulated AWS and Azure accounts that is expanding into new regions. The same standard containers run across AWS, GCP, Azure, and on-prem in the company's own accounts under one identity and network model, with geo-routing to the nearest deployment and no cluster it has to operate. Fly.io would host that workload on its own edge instead of the company's regulated accounts, so data residency and cloud-agreement ownership become hard to guarantee. Control Plane also reaches native cloud services credential-free through Universal Cloud Identity, so a workload in one cloud uses another cloud's services on temporary, least-privilege session credentials.

What Fly.io is. Fly.io is a single-vendor edge platform: you hand it a container and it runs as Fly Machines on Fly's own global network, working at the machine level in Fly's regions. Control Plane delivers the same edge-like proximity through geo-intelligent routing to the nearest deployment, and also runs across AWS, GCP, Azure, and on-prem in your own accounts, adds full VMs, and carries PCI DSS Level 1, so you keep placement control and portability instead of committing everything to one network.

Why teams consolidate on Control Plane. The moment regulated data, virtual machines, or workloads spanning more than one cloud and on-prem enter the picture, a single-vendor edge stops being enough. Control Plane gives you the same edge-like proximity through geo-routing to the nearest deployment, and adds control over which cloud and region each workload runs in, platform-level compliance, full VMs, and one identity and network model across every cloud, so you do not outgrow it and end up running two platforms.

"Before Control Plane, our releases were unpredictable, sometimes taking over an hour. Now, our deployments happen in a matter of minutes, drastically improving our engineering efficiency."
Pete TorresSVP of Engineering, Linker FinanceDeploys: hours to minutes

Frequently asked questions

What is the difference between Control Plane and Fly.io?

Fly.io hosts your app on its own global edge infrastructure, deploying containers as Fly Machines to Fly's regions with machine-level control. Control Plane is a multi-cloud runtime. By default it runs your standard containers on hardened, managed clusters in Control Plane's own cloud accounts, in the regions you choose. It can also run them in your own AWS, GCP, Azure, and on-prem accounts, all as one virtual cloud with geo-intelligent routing to the nearest deployment, no cluster you have to operate, scale-to-zero, and compliance. Short version: Fly.io ties you to its edge network; Control Plane gives you a portable multi-cloud runtime with control over where workloads run across the major clouds.

Does Control Plane run on my own cloud accounts?

It can. By default Control Plane runs your workloads on hardened, managed clusters in its own cloud accounts, in the regions you pick. As an option, through BYOK or managed Kubernetes, it runs them inside your own AWS, GCP, Azure, and on-prem accounts, so data, compute, and spend stay under your ownership and cloud agreements. Fly.io runs your app on Fly's own edge infrastructure and does not offer that choice.

Can Control Plane route traffic globally like Fly.io?

Yes. Control Plane uses geo-intelligent DNS with health-based failover to send each request to the nearest healthy deployment, typically around 20 to 30 milliseconds away. The difference is reach: instead of Fly's own edge regions, Control Plane routes across deployments you place in AWS, GCP, Azure, and on-prem regions, so your global footprint follows the major clouds rather than a single provider's network.

Do I have to operate Kubernetes or machines with Control Plane?

You do not have to. Control Plane is built on Kubernetes, and by default you never touch it: there is no cluster, node pool, or machine to configure, because the platform places, scales, and heals each workload for you. If you do want a cluster, you can run one through Managed Kubernetes (MK8s), where Control Plane operates the cluster on your behalf, or Bring Your Own Kubernetes (BYOK), where it runs inside a cluster you already have. On Fly.io you work at the machine level, configuring and sizing Fly Machines, which is more to manage than Control Plane's default model.

Does Control Plane support scale-to-zero and right-sizing?

Yes. Serverless workloads scale to zero when idle and back up on demand, and Standard and Stateful workloads can scale on demand through KEDA. Capacity AI right-sizes CPU and memory automatically and bills on consumed or reserved capacity, so you are not manually sizing machines to peak the way you typically do on Fly.io.

Outgrowing the edge?

Run your standard containers across AWS, GCP, Azure, and on-prem as one virtual cloud, on managed infrastructure or in your own accounts, with geo-intelligent routing to the nearest deployment, no cluster you have to operate, scale-to-zero, and compliance. Test it on one real workload and see.99.999% uptime SLA · SOC 2 Type II · PCI DSS Level 1

Run Unbreakable
Apps and Agents

Sign up free. No cloud accounts required.