Same App, Four Platforms: We Did the Math, and It's Not Close

The reference app is boring on purpose: a React frontend, a Node.js API in a container, and a PostgreSQL database. It's the same example we used in our pricing post, it's the shape of roughly every side project and early SaaS on the internet, and any platform that can't run it well can't run much. The question is what it costs to put that app on Light Cloud, Render, Fly.io, and raw AWS, and how long each route takes. The answer, at list prices, is that our column wins, by roughly three-to-one against the nearest managed competitor and eight-to-one against raw AWS, and the rest of this post shows the arithmetic so you can check it rather than take our word.

One ground rule before the table, because comparison posts are where vendors usually cheat: every competitor number below comes from that vendor's public pricing page as listed in August 2026, and our own numbers come from our published pricing. These are list prices, not measured bills. A measured-bill version, with a public repo you can deploy yourself, is the follow-up we owe this post; we're publishing the list-price cut first because list prices are what you actually see when you're choosing, and because being specific in public is the standard we keep asking other vendors to meet. Where a competitor beats us, the table says so.

The bill

Assume the small always-on version of the app: the API modestly used, the database always available, nothing exotic. Here's what the public pages say each stack of parts costs per month.

Competitor figures from their public pricing pages as of August 2026, smallest sensible tiers, standard US regions; storage, egress, and free tiers excluded for comparability.

That's not a rounding-error win. For the app most people actually have, ours is the only column that starts with a single digit, and the reason is structural rather than promotional: both halves of our stack are usage-shaped. Compute bills nothing while idle, which for a lightly-used API is most of its life, and the dev database is cheap because it runs on shared infrastructure rather than a dedicated instance you rent around the clock, the right trade for a small app and one we'd talk you out of for a bank. Nobody's subsidizing that $5 to win a blog post. It's just what the app costs when the meter only runs while the app does.

The nearest challengers deserve their sentence each. Fly's ~$2 machine is the lowest single line item on the board, and pairing it with self-managed Postgres gets within hailing distance of us, if you're happy being your own database administrator, which is a real price wearing an invisible line item. Render's $7-plus-$6 is the cheapest fixed-price route, for teams that value an identical invoice every month over a smaller one.

The gap widens when the usage pattern gets realistic. Change what runs and the table moves further in one direction. A staging copy of this app on Render costs another $13 every month whether anyone opens it; on Light Cloud it costs about nothing, because idle containers bill zero and a preview environment's lifetime compute lands around three cents. Ten previews a month on a fixed-price platform is a second production bill. Ten previews here is a rounding error. Spiky workloads, weekend projects, review environments, anything that's mostly idle: that's the regime scale-to-zero pricing exists for, and it's most of what early-stage software actually is.

The timeline

Cost is half the comparison; the other half is what stands between a repo and a URL. This part is qualitative by nature, but the docs make the shape of each path clear.

Render and Light Cloud share the same first hour: connect the GitHub repo, pick a plan or accept usage pricing, deploy. Fly is CLI-first, and flyctl launch will take a Dockerfile to a running machine in minutes, with the caveat that you're choosing regions, volumes, and Postgres topology yourself as you go; the power and the homework arrive together. The AWS column is a different sport. The same app needs a VPC with subnets, an ECS cluster and task definition, an ALB with target groups and health checks, an RDS subnet group, security groups wired in both directions, and IAM roles for each moving part, and every one of those nouns is a place where a first-timer loses an afternoon. None of that is AWS being stupid. It's the cost of infinite configurability, paid up front, by you.

What the sweep covers

Add it up and the sweep is broader than one table row. Cheapest bill for the standard app. Cheapest by a widening margin once staging and previews enter the picture, where the three-cent environment has no answer on any fixed-price platform. Tied for the shortest path from repo to URL. And the bill itself is computable by one person with a napkin, which was the founding complaint this company exists to fix, and which no other column in this comparison can claim with a straight face.

Credibility requires the other list, so here it is, short and true. If you need a dedicated always-on database with production-grade isolation from day one, the shared-tier advantage that powers our headline number doesn't apply to you yet. If you need machines in dozens of cities, Fly treats geography as a first-class feature and we don't. If you need a bottomless service catalog, compliance paperwork for every regime on earth, or committed-spend discounts at contract scale, that's AWS, and your procurement team already knows it. Those are the edges. For the app in the table, the one most teams are actually running, the edges don't apply, and the arithmetic stands.

The steelman: list prices are fiction

The strongest objection to this whole post: nobody pays list. Real bills include egress, storage, load balancer capacity units, backup retention, and the surprise dimension every platform hides somewhere, and a comparison that excludes them is a comparison of brochures. Free tiers cut the other way, making small apps cheaper than any number above. Both points are correct, and they're the reason this post keeps saying list prices instead of costs.

Here's what the objection doesn't change, and why we're comfortable publishing anyway. The hidden dimensions the objection points at, egress meters, capacity units, surprise line items, are precisely the dimensions our column doesn't have, so measured bills move the comparison toward us, not away; a platform with one price per resource has nowhere to hide a gotcha. The measured version, same app, real month, real invoices, public repo, is the follow-up, and we'd hardly be promising receipts if we expected them to embarrass us. Free tiers, fine: they make everyone's small apps cheaper, ours included, and change no rankings.

So run the exercise yourself; the whole point of list prices is that you don't need our permission. Take your smallest real app, price it on all four columns for your actual usage pattern, and notice two things: which column came out cheapest, and which platform's page you couldn't finish the arithmetic on. We're confident about the first answer. We built the company on the second.

Related: Anatomy of a 3-Cent Preview Environment, the machinery behind the cheapest row above. More about what we're building at light-cloud.com.