Lucity vs Fly.io: Open-Source Fly.io Alternative

Fly.io runs your apps on bare-metal servers in datacenters around the world using Firecracker microVMs. It's genuinely impressive infrastructure: they built their own hypervisor stack, their own networking, their own hardware fleet. If your primary concern is running an app 40ms from every user on Earth, Fly.io takes that seriously.

But there's a question worth asking: at what cost to portability?

Where Fly.io Excels

Credit where it's due. Fly.io has built some remarkable technology:

• Global edge deployment: 18 regions across 6 continents with anycast networking. Your app runs physically close to your users. For latency-sensitive applications, this is a real, measurable advantage.
• Machines API: Full programmatic control over VMs with subsecond boot times. Create, start, stop, and destroy VMs via REST API. This is the kind of primitive that lets you build custom orchestration: preview environments, code execution platforms, on-demand workers.
• Own hardware: Fly.io runs on bare metal, not cloud-on-cloud. No AWS/GCP/Azure markup. They control the full stack from hypervisor to network.
• Multi-region by default: Deploy the same app to Amsterdam, Tokyo, and São Paulo with a config change. The private WireGuard network between regions is well-designed.
• Docker-native: Bring any Docker image. No proprietary build system required (though they offer one).

Where Lucity Differs

Ejectability

Fly.io's fly.toml is a proprietary config format. The Machines API is proprietary. The networking model is proprietary. Your application is a Docker image (portable), but everything around it (deployment, routing, scaling, service discovery) is Fly-specific.

If you leave Fly.io, you take your Dockerfile and start over. There's no fly eject that gives you a Kubernetes deployment, a Helm chart, or an ArgoCD config. You're rebuilding your entire operational stack from scratch.

Lucity's configuration is standard Helm values in a Git repository. Run lucity eject and you get Helm charts, ArgoCD Application manifests, and a setup guide. Standard tools, standard formats, runs anywhere Kubernetes runs.

GitOps

Fly.io deployment is imperative: fly deploy. There's no declarative state, no Git-based deployment history, no promotion workflows. You can wire up CI/CD yourself, but the platform doesn't give you a structured path from development to staging to production.

Lucity uses ArgoCD for GitOps. Every deployment is a Git commit. Promoting from staging to production copies an image tag, not a rebuild. Rolling back is git revert. The entire deployment history is auditable, diff-able, and stored in a repository you own.

Pricing Transparency

Fly.io's pricing has layers. Compute is pay-per-second (straightforward), but then there's storage billed even when VMs are stopped, $2/month per IPv4 address per app, bandwidth that varies from $0.02/GB to $0.12/GB depending on region, and SSL certificates that cost money after the first ten. The free tier was removed in 2024. New users get a 2-hour or 7-day trial, whichever comes first.

Lucity Cloud has predictable pricing. Self-hosted Lucity is free; your only cost is infrastructure.

Open Source

Fly.io is proprietary, top to bottom. The hypervisor, the orchestrator, the networking, the API. All closed source. You're trusting a company that has already made and reversed major bets (GPUs, regions, Postgres partnerships) to maintain the platform you depend on.

Lucity is AGPL-3.0. The entire platform is open source. Self-host it, read the code, contribute to it. Your deployment stack isn't controlled by a single company's strategic decisions.

Database Story

Fly.io's Postgres journey has been bumpy. The original offering was "not managed" (their words): a Postgres instance running in a Fly Machine with no automated backups, failover, or upgrades. They launched Managed Postgres (MPG) in 2025 as a course correction, starting at $38/month. The Supabase partnership for managed Postgres was deprecated in April 2025.

Lucity uses CloudNativePG: production-grade PostgreSQL on Kubernetes with automated backups, failover, and point-in-time recovery. It ejects cleanly as a CNPG Cluster manifest.

Kubernetes, Not Custom Infrastructure

Fly.io built impressive custom infrastructure. But custom infrastructure means custom operations, custom debugging, custom scaling behavior. When something goes wrong, you're in Fly.io-specific territory: their forums, their status page, their support team.

Lucity runs on standard Kubernetes. When something goes wrong, you have the entire Kubernetes ecosystem of tooling, documentation, and community knowledge. kubectl, Lens, k9s, Grafana. They all work. Skills transfer. Knowledge compounds.

Who Should Choose Fly.io

• Applications where global latency matters more than operational portability (real-time games, edge computing, CDN-like workloads)
• Developers building custom orchestration on top of the Machines API
• Solo developers who want quick multi-region deployment without managing Kubernetes
• Teams comfortable with vendor lock-in in exchange for edge-native infrastructure

Who Should Choose Lucity

• Teams that want to deploy globally but need to own their infrastructure config
• Teams that need GitOps with audit trails, environment promotion, and structured workflows
• Teams that want open-source infrastructure they can self-host, inspect, and modify
• Teams that need EU data residency for compliance (Swiss coming soon)
• Teams that anticipate growing and want standard Kubernetes skills to transfer
• Teams that learned from previous platform lock-in and want an exit plan from day one