Ample vs Fly.io: which microVM platform is better for agent-built apps? | Ample

The short version

Fly.io is the better choice when you want Docker images, 17 regions and fine-grained machine control. Ample is the better choice when a coding agent should deploy from source with no Dockerfile, no card and a hard spending cap, with managed databases created automatically. Both run each app in its own microVM.

WHO THIS IS FOR

Before you choose

Ample and Fly.io share an architecture: each app in a microVM. They differ in who they are built for: Fly.io exposes machines, regions and Dockerfiles to developers; Ample hides them so an agent can go from a repository to a live URL.

Ample and Fly.io side by side

	Ample	Fly.io
Free plan	$0 with no card. 2 apps running at once, 2 vCPU, 2 GB memory, 3 GB volumes, 1 GB bucket storage, 2 buckets.	No free tier for new organizations. The trial is 2 hours of machine time or 7 days, then a card is required.
Paid plans	Custom plans priced on volume (number of apps, limits, spending caps). No public list price; see pricing.	Pay as you go, per second: a shared-CPU machine with 256 MB is about $2.19 a month and with 1 GB about $6.70, varying by region.
Spending limit	Free has a hard budget ($5 a month, $2 a day). At the cap, apps stop serving until the account is back under budget; nothing is deleted and nothing is billed.	None. Fly.io says it has no spending ceiling and no billing alerts yet.
How apps run	Each app runs as a normal long-running process in its own microVM with its own kernel.	Firecracker microVMs (Fly Machines) built from a container image.
Long-running servers and workers	Yes. Web services and background workers (`--kind worker`) run as ordinary processes.	Yes. Process groups in `fly.toml` run web and worker processes on separate machines.
Languages	Node, Python, Go, Ruby, PHP, Java, .NET, Elixir, Rust and static sites, detected from the repository.	Anything with a Dockerfile; `fly launch` generates one for common frameworks.
Docker images	No. Ample builds from source; Dockerfile build steps are not run.	Yes; images are the deploy unit.
Databases	Managed Postgres, MySQL, Redis and MongoDB, each in its own microVM, created automatically when the code needs one.	Managed Postgres from $38 a month with high availability; Redis through Upstash.
Object storage	S3-compatible buckets, optionally published through Ample's CDN.	S3-compatible object storage provisioned through `fly storage create` and billed on the Fly bill.
Persistent disk	Persistent volumes attached to the app.	Volumes on the host's local NVMe, one per machine, without replication.
Custom domains and TLS	Custom domains with automatic TLS.	Custom domains with Let's Encrypt certificates; first 10 free.
Regions	No region choice.	17 regions.
Scheduled jobs	Scheduled jobs: a command or HTTP request on a cron schedule (any time zone) or interval, with retries and run history (`ample job create`).	No built-in cron; scheduled machines or a cron process inside the app.
Agent access	CLI, remote MCP server (OAuth), A2A endpoint and agent skills. Deploys are synchronous and return JSON with an exit code: 0 live, 1 failed, 2 needs input.	An experimental local MCP server (`fly mcp server`); separate Sprites product of persistent sandboxes for agents.
Agent signup without a person	Yes. `ample auth signup` creates an account with no browser, card or CAPTCHA; a person claims it by email within 48 hours.	No. The trial and Sprites both start with account signup.

Competitor facts come from that company's own pricing pages and documentation, checked on the date shown in the sources. Plans change; follow the source links for current numbers.

Which one fits

Choose Ample when

You want to deploy from source with no Dockerfile or machine configuration.
You need a free plan and a hard spending cap rather than open-ended pay-as-you-go.
The app needs MySQL or MongoDB, or a small Postgres without a $38 minimum.
An agent should sign up and deploy on its own and read failures as JSON.

Choose Fly.io when

You want to place machines in specific regions near your users.
You ship Docker images or need low-level control of machine size, process groups and networking.
You need UDP, raw TCP services or a private WireGuard network between apps.

Move a Fly.io app to Ample

Read fly.toml and the Dockerfile
The start command is in the Dockerfile CMD or in [processes]; the release step is [deploy] release_command. Ample builds from source, so note any system packages the Dockerfile installs.
Collect secrets
Gather secret values from where you keep them; put them in a local env file outside git.

Plan and deploy
Pass the release command so migrations run before the new release goes live.

ample deploy . --name <app-name> --public --env-file .env.production --release-command "<release command>"

Move data
Dump Fly Managed Postgres through fly mpg proxy and pg_dump --no-owner --no-acl, restore into Ample, and copy objects with any S3 tool.
Point your domain
Add the domain to the app, update DNS to the target Ample prints, and keep the old app running until the new one answers on the domain.
```
ample domain add <app-name> www.example.com  
```

Frequently asked questions

Are Ample and Fly.io built the same way?

Both run each app in its own microVM. Ample adds source builds with no Dockerfile, automatic database provisioning, a free plan with a hard cap, and agent signup on top.

Can I choose a region on Ample?

No. If region placement matters, Fly.io is the better fit today.

Does Ample need a Dockerfile?

No. Ample detects Node, Python, Go, Ruby, PHP, Java, .NET, Elixir, Rust and static sites from the repository and builds them. It does not run Dockerfile instructions.