Fly Machines

What Fly Machines actually is

Fly Machines are the VM primitive underneath Fly.io. Announced in May 2022, they are Firecracker microVMs with a small REST API that lets you create, boot, stop, clone, update and destroy VMs programmatically. Fly's own launch post put the pitch simply: VMs with a fast REST API that can boot instances in about 300ms, with a proxy that can start them for you and shut them down when they are idle. If you have deployed an app on Fly.io through fly launch, you are already running Machines — Fly Launch is orchestration built on this API.

The distinction that matters: Fly Launch gives you the declarative app experience (a fly.toml, a deploy command, a dashboard), while the Machines API gives you the raw lifecycle control. You pick the region per Machine, the CPU and memory preset, the container image, the services and IPs. You decide when it runs. That makes Machines closer to a container-shaped compute API — think of the category between a VPS and a serverless platform — than to traditional hosting. It sits across /category/container-platforms and /category/edge-computing on ServerSpotter.

In our view, Machines are one of the more interesting compute primitives anyone is selling right now, precisely because of the start-stop economics. A Machine that is stopped costs almost nothing; a Machine that starts in hundreds of milliseconds can be stood up in response to demand rather than kept warm. That pattern is old news in serverless, but here it applies to ordinary containers with ordinary processes, no request-handler rewrite required.

Pricing: what you really pay

Machines are billed by the second while running, and the rate card is the Fly.io platform rate card — published in full in Fly's pricing documentation. In the cheapest regions (Ashburn iad and Secaucus ewr), a started shared-cpu-1x with 256MB RAM costs $2.19 per 30 days of continuous runtime. The same preset with 512MB is $3.69 and with 1GB is $6.70. shared-cpu-2x with 2GB is $13.39. Dedicated CPU presets are markedly pricier: performance-1x with 2GB is $33.00 per month and performance-2x with 4GB is $66.00. Additional RAM beyond a preset is $6.00 per GB per month. Region changes the number — a 1GB Machine is $7.73 in Frankfurt and $8.50 in Singapore.

The idle economics are the headline. Stop a Machine and compute billing stops with it; what remains is $0.15 per GB per month for the root filesystem. Volumes — the persistent block storage you attach — run $0.15 per GB per month on provisioned capacity whether attached or not, and volume snapshots cost $0.08 per GB per month with the first 10GB of snapshot data free each month. A dedicated IPv4 address is $2 per month on top; shared IPv4 and IPv6 addresses are free. Outbound data to the internet is $0.02/GB from North America and Europe, $0.04/GB from Asia Pacific, Oceania and South America, and $0.12/GB from Africa and India. Inbound traffic is free.

Fly's own worked examples put a 24/7 background worker — one shared-cpu-1x 256MB Machine plus a gigabyte of egress — at $2.21 per month. A small web app with a 512MB Machine, a 10GB volume and a Basic Managed Postgres database is $43.67, though that last item ($38 of the bill) is a platform service, not a Machine cost. If you drive the Machines API directly and bring your own datastore, the bill is essentially the Machine table plus storage and egress.

There is no free tier anymore. New accounts get a trial: 2 VM hours or 7 days, whichever ends first, with a maximum of 10 Machines, 20GB of volume storage, 2 vCPUs and 4GB RAM per Machine. Trial Machines are stopped automatically after five minutes of running. Adding a payment method ends the trial and starts real billing.

Performance & infrastructure

Each Machine is a Firecracker VM: hardware-virtualised isolation with the memory footprint of a container host. The lifecycle is explicit in the docs — a Machine is created while Fly reserves capacity, pulls your container image and builds a root filesystem (low double-digit seconds on first creation), then started once it boots, which typically takes well under a second. A stopped Machine keeps its assembled components on the worker host, so restarting is faster than recreating. Delete it and the resources go back to the pool.

That state model is the whole design. Machines stop automatically when your program exits, and Fly's proxy can start them on incoming requests — the scale-to-zero pattern. Storage is ephemeral by default: a blank slate on every boot. Persistent data lives on a Fly Volume, which is pinned to one region and one host, so plan placement around your data rather than the other way round. The Machines API also exposes clone (horizontal scale-out into chosen regions) and update (vertical resize), plus per-Machine environment, metadata and restart policy.

Placement is real infrastructure, not an abstraction. Machines run on Fly's own hardware across 17 regions — Amsterdam, Stockholm, Paris, Dallas, Secaucus, Frankfurt, Ashburn, Johannesburg, Los Angeles, London, Tokyo, Chicago, Singapore, San Jose, Sydney, Toronto and Sao Paulo. Capacity varies by region and host; Fly publishes guidance on placement failures because a full region can reject a create call. Managed Postgres clusters are only available in a subset of regions, and Machine prices vary regionally.

On reliability terms: the platform's 99.9% monthly uptime SLA exists but covers Enterprise plans only, with service credits and a 30-day claim window, and its downtime definition excludes hacking or virus attacks. Machines inherit that posture — there is no per-Machine or per-region availability commitment for ordinary customers. The status page and community forum are the recourse when a region has a bad day.

Where it falls short

This is a Fly.io dependency, full stop. Machines are a proprietary API on proprietary infrastructure. The container format is standard and the code you run is portable, but the lifecycle calls, the proxy behaviour, the volume semantics and the region codes are Fly's. If you build directly on the Machines API rather than Fly Launch, you are also signing up to write your own orchestration: health-aware start/stop, placement retries, scaling policy. That is the trade for the low-level control.

The CLI- and API-first character is a second cost. There is no rich visual console for Machine fleets; most work happens through flyctl and HTTP calls. For teams that want a dashboard-first experience, this will feel closer to managing instances with scripts than to a PaaS.

Third, idle is cheap but not free, and always-on is more than the headline suggests. Stopped rootfs and provisioned volumes bill continuously; a dedicated IPv4 adds $2 per month; egress is metered per GB with regional multipliers. Machines with dedicated CPU presets are expensive relative to shared presets — $33 per month for 2GB is a long way from the $3.69 entry.

Fourth, the trial is tight and the free tier is gone, which removes the zero-cost experimentation path that originally made Machines famous for side projects. And documentation, while generally strong on the API surface, occasionally lags platform changes — region availability and pricing in older posts no longer match reality.

Who should pick this

We would pick Fly Machines when workloads are bursty or request-shaped: web services that scale to zero between requests, background workers with predictable duty cycles, CI runners, per-customer sandbox environments, and APIs where starting in under a second is acceptable. Teams already on Fly.io get them for free as an architectural option; teams building custom control planes get a compute API with unusually good start/stop economics.

We would not pick Machines as a standalone choice for always-on database workloads (use volumes carefully, and compare the Postgres options first), for teams that want provider portability at the orchestration layer, or for anyone needing a contractual SLA without an Enterprise agreement. For raw price-per-core on steady workloads, traditional VPS providers on our /benchmarks page will beat this.

Key takeaways

• Firecracker VMs with a REST API, announced May 2022: boot in about 300ms, stop automatically when idle, billed by the second while running.
• Cheapest shape is $2.19 per 30 days running (shared-cpu-1x, 256MB, cheapest regions); a stopped Machine costs $0.15/GB/month for rootfs.
• Volumes ($0.15/GB/month) are region- and host-pinned; rootfs is ephemeral by default; first 10GB of snapshot data is free each month.
• Runs on Fly's own hardware in 17 regions with per-region pricing and real capacity limits — placement can fail in full regions.
• No free tier: a 2-VM-hour/7-day trial, then pay-as-you-go; the 99.9% SLA covers Enterprise plans only.
• Best fit: scale-to-zero services, request-driven compute and custom orchestration where fast start/stop economics justify a Fly-specific API.

Sources

• https://fly.io/blog/fly-machines
• https://docs.fly.io/machines/overview
• https://docs.fly.io/about/pricing
• https://docs.fly.io/reference/regions
• https://fly.io/docs/about/free-trial
• https://fly.io/legal/sla-uptime/
• https://fly.io/docs/tigris
• https://fly.io/blog/logbook-2022-05-26
• https://builtin.com/company/flyio