Fly.io vs Kamal for Solo Developers

Quick Comparison

Fly.io Overview

Fly.io deploys Docker containers as micro VMs across a global network of edge servers. Configure your app with fly.toml, deploy with a single command, and your app runs close to users worldwide. The platform handles networking, TLS, scaling, and load balancing. You get managed Postgres, persistent volumes, private service networking, and a free tier with 3 shared VMs.

Fly.io's strength is removing infrastructure decisions. You don't choose a server, configure a reverse proxy, or manage SSL certificates. The platform handles it. For solo developers who want to deploy and move on, it's an efficient workflow.

Kamal Overview

Kamal is an open-source deployment tool created by the team behind Rails. It takes a different approach entirely. Instead of providing infrastructure, Kamal deploys Docker containers to any server you can SSH into. You bring the server. Kamal handles building your Docker image, pushing it to a registry, SSHing into your machine, and swapping containers with zero downtime.

The workflow is centered around a deploy.yml config file. You define your app, the server addresses, environment variables, and accessories (databases, Redis). Then kamal setup bootstraps the server and kamal deploy pushes updates. The Kamal proxy handles routing and zero-downtime container swaps.

Kamal doesn't care where your server lives. Hetzner, DigitalOcean, AWS, a Raspberry Pi in your closet. If it has Docker and you can SSH in, Kamal will deploy to it. That flexibility is the whole point.

Key Differences

Platform vs. tool. Fly.io is a complete hosting platform. Kamal is a deployment tool. Fly.io includes servers, networking, databases, and monitoring. Kamal gives you a deploy pipeline and nothing else. You provide everything Kamal deploys to.

Server responsibility. With Fly.io, server management isn't your concern. Hardware failures, OS updates, security patches. Fly.io handles it. With Kamal, you manage the servers. If your VPS has a kernel vulnerability, you're patching it. If the disk fills up, you're fixing it. This is the fundamental tradeoff.

Global deployment. Fly.io deploys to 30+ regions with a config line. Kamal deploys to whatever servers you list in your config. You could theoretically achieve multi-region deployment with Kamal by adding servers in different locations, but you'd need to manage load balancing, DNS routing, and synchronization yourself. Fly.io makes this trivial.

Cost. Kamal on a cheap VPS beats Fly.io on price for single-region deployments. The tool itself is free and open source, so you pay only for your server. A small Hetzner or DigitalOcean box running a Kamal-deployed app with a Docker Postgres container can run that whole stack for the price of one VPS, while the equivalent on Fly.io stacks per-resource charges. Fly.io also removed its permanent free tier in 2024, so new accounts get trial credits and then pay for everything. The more services you run, the bigger the gap. See the Real Cost section below for the worked numbers.

Deployment speed. Fly.io builds happen on their infrastructure. Push and wait 1-2 minutes. Kamal builds Docker images locally (or in CI), pushes to a registry, then deploys. The total time depends on your build speed and registry upload time. For large images, Kamal can be slower. For small images with a fast connection, they're comparable.

Zero downtime. Both achieve zero-downtime deploys. Fly.io does it through rolling VM updates. Kamal does it through the Kamal proxy, which routes traffic to the new container before stopping the old one. Both work well in practice.

Database management. Fly.io offers managed Postgres deployed as a Fly app. Kamal deploys databases as Docker accessories on your server. Neither is a fully managed database service like RDS. With Kamal, you get direct access to the container and full control over configuration. With Fly.io, you get a more abstracted but slightly easier setup.

By the Numbers (2026)

Numbers move, so here is what each side actually looked like when this was checked on 2026-05-28.

Kamal

• Latest version: v2.11.0, released 2026-03-18 (see the GitHub release page).
• Language: Ruby. Kamal ships as a gem, not an npm package.
• GitHub stars: 14,247, with 715 forks and 152 open issues on basecamp/kamal.
• Adoption: about 18.9 million total downloads on RubyGems, with roughly 2.1 million on the v2.11.0 release alone.
• Cost: free and open source under the MIT license. You pay only for the servers you point it at.
• Capability worth knowing: the bundled kamal-proxy can provision automatic HTTPS via Let's Encrypt when you deploy to a single host with the ssl: true and host options, and it handles gapless zero-downtime container swaps without the app needing to cooperate.

Fly.io

• Pricing model: pay-as-you-go. The permanent free tier was removed in 2024; new accounts now get trial credits and then pay for every resource.
• Smallest always-on machine: shared-cpu-1x with 256MB RAM at about $2.02/month, rising to about $5.92/month at 1GB and about $11.11/month at 2GB (Amsterdam-region figures from the pricing docs; other regions apply a markup).
• shared-cpu-2x with 1GB RAM: about $6.64/month.
• Persistent volume storage: $0.15 per GB per month of provisioned capacity.
• Outbound bandwidth: $0.02 per GB egress to the public internet for North America and Europe.
• Managed Postgres: starts at $38/month for the Basic plan (shared-2x, 1GB RAM) and $72/month for Starter (shared-2x, 2GB RAM), with database storage billed at $0.28 per provisioned GB per month.

The headline takeaway is that Kamal has no per-resource pricing at all. Every Fly.io line item above is a recurring charge that Kamal simply does not have, because Kamal is software you run, not infrastructure you rent.

Real Cost at Solo-Dev Scale

Pricing tables only matter once you plug in a real workload, so here is one. Assume a typical solo-dev side project in a single region, no multi-region requirement: one always-on web app needing about 1GB of RAM, one Postgres database with 1GB of RAM and 10GB of storage, and roughly 50GB of outbound bandwidth a month.

On Fly.io, using the published 2026 rates:

• Web app: shared-cpu-1x at 1GB RAM, about $5.92/month.
• Managed Postgres: Basic plan (shared-2x, 1GB RAM) at $38.00/month.
• Postgres storage: 10GB at $0.28 per GB, $2.80/month.
• Bandwidth: 50GB egress at $0.02 per GB, $1.00/month.
• Estimated total: about $47.72/month, or roughly $573 a year, before any redundancy.

On Kamal, the same workload:

• Kamal itself: $0. It is free, open source software.
• One VPS sized to hold the app plus a Postgres Docker accessory and 10GB of data. A small two-to-four GB box from Hetzner or DigitalOcean covers this comfortably. Check current VPS pricing with your chosen provider, but boxes in this class typically land in the single-digit to low-double-digit dollars per month.
• Bandwidth is usually bundled into the VPS plan rather than metered per GB.
• Estimated total: the cost of one small VPS, commonly a fraction of the Fly.io figure above.

The gap is the managed Postgres line. Fly.io charges $38/month for a managed 1GB database before you store a single byte, while Kamal runs the same database as a Docker container on a server you are already paying for. If your project does not need managed-database guarantees, that single line is most of the price difference. The flip side is the assumption baked into the Kamal column: you are now the one patching the OS, watching disk space, and owning backups. That operational time is the real price of the lower bill, and for some solo devs it is more expensive than $38 a month. Multi-region changes the math entirely, because Fly.io adds a config line where Kamal asks you to build and run the routing yourself.

When to Choose Fly.io

• You want managed infrastructure without server management
• Global multi-region deployment is a requirement
• You prefer deploying without maintaining your own servers
• Built-in networking and secrets management matters
• The free tier is useful for your use case

When to Choose Kamal

• You already have servers or VPS credits
• Long-term cost savings outweigh setup convenience
• You want complete infrastructure independence
• You're comfortable with Docker, SSH, and basic server admin
• You want to deploy to any provider without platform lock-in

The Verdict

Fly.io is the managed option. Kamal is the DIY option. Both deploy Docker containers. Both achieve zero downtime. The difference is who manages the servers.

For solo developers who value their time above everything else, Fly.io is the pragmatic choice. You deploy and forget. No server maintenance, no security patches, no disk space monitoring. The platform tax you pay in monthly fees buys back hours of operational work.

For solo developers who are comfortable with servers and want maximum control over their stack, Kamal is an excellent tool. It's lean, opinionated in the right ways, and works with any infrastructure provider. The combination of Kamal plus a cheap VPS gives you a professional deployment pipeline at minimal cost.

My recommendation: if you have a VPS sitting around or you're cost-sensitive, learn Kamal. It's a skill that pays for itself. If you want to focus purely on building and don't want to think about servers, Fly.io is the faster path. Both are solid choices for solo developers.

Sources

All figures checked on 2026-05-28.

• Fly.io resource pricing (machine presets, RAM, volumes, bandwidth): https://fly.io/docs/about/pricing/
• Fly.io Managed Postgres pricing: https://fly.io/docs/mpg/
• Fly.io pricing overview page: https://fly.io/pricing/
• Kamal GitHub repository (stars, forks, issues, language): https://github.com/basecamp/kamal
• Kamal v2.11.0 release: https://github.com/basecamp/kamal/releases/tag/v2.11.0
• Kamal on RubyGems (version and download counts): https://rubygems.org/gems/kamal
• Kamal proxy documentation (automatic Let's Encrypt HTTPS, zero-downtime): https://kamal-deploy.org/docs/configuration/proxy/
• Kamal proxy repository: https://github.com/basecamp/kamal-proxy