I priced ten hosting providers for the same small app. The spread was 9x.

I have a couple of side projects and a bad habit of moving them. Every time a free tier ends or an invoice looks wrong, I spend an evening on pricing pages, pick something, and then forget every number by the next time I need them.

So this time I wrote them down, for myself. Same app, ten providers, August 2026 list prices, and not the marketing headline price - the price of the whole thing, including the database, the cache, the cron worker, the object storage, and the egress. That last one is where most of the surprises live.

The second question was the one I actually cared about: what if one of these things randomly works. Going from a few hundred users to ten times that costs wildly different money depending on where you started, and by the end that mattered to me more than the difference between $7 and $62 at the bottom.

The reference app

I did not want to compare a static site on one host with a Kubernetes cluster on another, so I fixed the shape first:

• one always-on Node/Bun HTTP service, small - roughly 0.25 vCPU and 512 MB in steady state
• one background worker doing cron jobs and a queue
• PostgreSQL, ~10 GB of data
• Redis or something Redis-shaped for sessions and rate limits
• 20 GB of object storage for user uploads
• ~100 GB of egress per month

That is a boring SaaS MVP or an internal tool with a few hundred users. Not a hobby toy, not a scale-up.

Same app, same month, $7 to $62. Nothing about the app changed, only who I gave the card to.

The self-managed end: Hetzner plus Coolify

A Hetzner CX33 is 4 vCPU, 8 GB RAM, 80 GB NVMe and 20 TB of traffic for €8.49/month. Add automated backups at 20% and you are at roughly $12. On that box, Coolify gives you a Heroku-ish UI: git push to deploy, automatic Let's Encrypt, a catalogue of 280-plus one-click services, Postgres and Redis as containers, preview deploys per PR. Self-hosted it costs nothing; their cloud control plane is $5/month for two servers if you would rather not host the panel too.

Dokploy is the leaner alternative - Docker Swarm underneath, first-class Compose support, much younger project. Coolify is Apache 2.0, Dokploy is source-available with restrictions on reselling. For a small team I would still take Coolify, purely for the app catalogue and the fact it has been around since 2022.

The catch is honest and boring: it is one box. You own the kernel updates, the disk filling up at 3am, and the restore drill. The 20 TB of included traffic is what makes the price look unfair though - on Render the same 100 GB overage would cost more than the whole Hetzner server.

Also worth knowing: Hetzner raised prices on 15 June 2026, and US locations cost about 20% more with 1 TB of traffic instead of 20 TB.

The PaaS middle

Railway came out best of the managed group at ~$26. Per-second billing at $0.0278/vCPU-hour and $0.0139/GB-hour, so an idle service actually costs close to nothing, and $5/month of the Hobby plan is credit you spend anyway. Config is a railway.json or the UI, templates cover the usual services, object storage is $0.015/GB-month with free egress. The thing I keep tripping on: their Postgres and Redis are just containers with a volume. You get backups, but you do not get a managed database in the sense that Render or Neon mean it.

Render is the polished one at ~$40 - web service $7, worker $7, Postgres Basic $19, Key Value $7. Everything is declared in render.yaml, previews per PR work properly, and it feels like Heroku did when Heroku was good. Two footguns: there is no object storage at all, so you are bolting on S3 or R2 anyway, and bandwidth over the included 100 GB per service is $30 per 100 GB. That is $0.30/GB, the most expensive egress in this entire comparison.

Fly.io is ~$53 and that is almost entirely Managed Postgres at $38/month plus $0.28/GB storage. The compute itself is cheap - a shared-1x machine with 1 GB is about $7 - and egress is $0.02/GB in NA/EU, which is excellent. If you run Postgres yourself on a second machine you land near $20, but then you are self-managing anyway and Hetzner does that cheaper. Fly wins when you genuinely need multi-region, which most small teams genuinely do not.

DigitalOcean App Platform is ~$50 and the most predictable pricing here: $10 for 1 vCPU/1 GB with 100 GiB transfer, $5 for the worker, $15 for managed Postgres, $15 for managed Valkey, $5 for Spaces. Nothing clever, nothing surprising, $0.02/GiB overage. It is the option you pick when someone else has to read the invoice.

Heroku is ~$27 and I was mildly surprised - Basic dynos at $7, Postgres Essential-1 at $9, Key-Value Mini at $3. The floor is fine now. The ceiling is not: the next Postgres tier up is $50, dynos jump to $25, the filesystem is still ephemeral, and a request still dies at 30 seconds. Cheap to start, punitive to grow.

Sevalla was the most expensive at ~$62, which is a shame because the product is nice. The app pods are reasonable ($10 for 0.5 CPU / 1 GB), but the database ladder goes $5 for 0.25 CPU / 1 GB of storage and then straight to $34 for the next size. There is no middle. Egress is $0.10/GB.

The two outliers

Cloudflare Workers at ~$7 is the cheapest number on the chart and the least comparable. $5/month, 10M requests, 30M CPU-milliseconds, cron triggers for free, D1 for SQL, KV, R2 with zero egress fees. If your app fits Workers, nothing else comes close on price. But "fits" is doing heavy lifting: D1 is SQLite not Postgres, Node compat is partial, there are no long-running processes, and rewriting a Postgres app to fit is not a hosting decision, it is an architecture decision.

Vercel plus Neon plus Upstash at ~$45 is the default for a lot of people and it is fine, as long as you know what you are paying for. $20 for Pro, ~$19 for a Neon compute that is always on at $0.106/CU-hour, ~$5 for Upstash. You get the best deploy experience in the industry, previews that non-technical people can actually use, and $0.15/GB after the first TB. You do not get a place to run a worker that lives longer than a function invocation, which is exactly the thing my reference app needs.

Supabase at ~$32 sits between the two: $25 Pro includes $10 of compute, an 8 GB Postgres, Auth, Storage, Edge Functions and pg_cron, and 250 GB of egress. Add ~$7 somewhere for the Node process and you are done, and you can often drop Redis entirely by using Postgres for queues and rate limits. Cheapest way to get a real managed Postgres with batteries attached.

The vertical axis is how little you touch a server, the bubble size is how annoying the migration out would be. There is no free lunch on that chart: everything cheap is either something you administer yourself or something you have rewritten your app for.

Where the money actually leaks

Compute prices are within a factor of two of each other. Egress is not.

Hetzner includes 20 TB. Cloudflare R2 charges zero for egress by design. Render charges $0.30/GB. If your app serves images, exports or video, this single line decides your bill, and it is never the line on the pricing page you looked at.

What if the thing actually grows

This is the part I care about more than the $7. A side project that works stops being a side project, and the question becomes how much the same architecture costs at ten times the load. So I priced a second scenario on the same providers:

• the app on 4 vCPU / 8 GB, split over two instances
• the worker on 1 vCPU / 2 GB
• Postgres on 4 vCPU / 16 GB with 100 GB of data
• 4 GB of Redis
• 200 GB of object storage
• 1 TB of egress

The slope matters more than the starting point. Ten times the traffic is 4x the money on Hetzner and 18x on Render, and the two were $28 apart when I started.

Where the extra money goes is different in each case:

• Hetzner goes from one CX33 to two CX43 boxes (8 vCPU / 16 GB, €15.99 each), one for the app and one for the data. Traffic is still included, so 1 TB of egress costs nothing. You pay in work instead: Postgres replication, a load balancer, and the failover plan are yours.
• Railway bills memory at ~$10 per GB-month, and at this size you are holding 25-30 GB of RAM. That single line is over half the bill. Compute is per-second and genuinely cheap; RAM is not.
• Render is the worst slope in the group, and almost all of it is egress: at $0.30/GB, the 900 GB over the included quota costs more than every instance on the account combined.
• Vercel stays sane on bandwidth (Pro includes 1 TB) and gets expensive on the database instead - an always-on 4 CU Neon compute is ~$310/month on its own.
• Supabase scales by compute add-on, so it is one clean line item: XL is $210/month for 4 cores and 16 GB. Predictable, but vertical only until you add read replicas, because there is still one writer.
• Cloudflare barely moves. 100M requests a month is $5 plus $0.30 per extra million, and R2 still charges nothing for egress. If the app fits Workers, it is the only option here that does not care whether you have 500 users or 500,000.

Vertical, horizontal, and what actually blocks you

The honest summary: vertical scaling is cheap everywhere and horizontal scaling is where the platform earns its markup. On a VPS you can double the box in a reboot for €8 more, but going from one box to three with a replicated database is a weekend and a runbook. On Railway or Render it is a number in a form, and you pay 5-10x per unit of compute for that. That premium is fine while the app is small; it is what people mean when they say a platform "got expensive" at scale.

The other thing worth planning for: the two cheapest options at 10x are the two with the least room to grow into. Hetzner is cheap because you are the ops team, and Cloudflare is cheap because you have already written your app to its shape. Neither gets cheaper by accident.

What you get without wiring it yourself

This is what actually matters for a small team - not raw price, but how many services you have to glue together on a Sunday.

That radar is my scoring, not a benchmark, so argue with it. The shape is the point: Hetzner wins on cost and portability and loses on setup, Vercel is the mirror image of that, and Railway is the least-bad compromise if you want one line on the chart to be decent everywhere.

So what would I actually pick

• Side project, weekend, might die in a month: Cloudflare Workers if it fits, otherwise Railway. Both cost near zero when idle.

• Real product, small team, you want to stop thinking about it: Supabase for the data layer plus one small compute box. Best ratio of managed features to dollars in this list.

• Client work where the bill has to be defensible: DigitalOcean App Platform. Boring, predictable, nobody gets a surprise.

• You are cost-sensitive and not scared of a terminal: Hetzner plus Coolify, and set up the restore drill on day one, not after the first incident.

• Next.js-shaped frontend with a separate API: Vercel for the frontend only, anything else for the backend. Paying Vercel prices for a background worker is how the $45 becomes $200.

• It might actually grow and you do not know yet: start managed, but keep the app in a Dockerfile and the data in plain Postgres with no proprietary extensions. That one rule is what makes the move to a box you own a boring afternoon instead of a rewrite, and at 10x it is the difference between $50 and $500.

The thing I would not do is pick a provider because it was cheap at the tier I am on today. Every platform here is affordable at the bottom; what differs is the slope. Hetzner and Cloudflare barely move, Supabase and DigitalOcean roughly track the load, and Render, Heroku and Railway multiply faster than the traffic does - Render because of egress, the other two because of memory pricing and tier jumps.

Prices are August 2026 list prices, no promos, no annual discounts, no VAT, EU regions where the provider has them. Both scenarios are my own estimates built from published rate cards, not measured invoices - the 10x numbers especially, since they assume steady utilisation and nobody's traffic is steady. Argue with the numbers, the ranking and the slopes are what I would stand behind.