PaaS Pricing Comparison: What 7 Platforms Cost (2026)

Every PaaS prices the one resource that is cheap, compute, and quietly meters the three that are not: the database, egress, and seats. This PaaS pricing comparison measures the gap that hides: the advertised number covers a web service, but the invoice covers your entire cost surface, and on most platforms those two numbers are more than 3x apart.

A small always-on full-stack app with a database runs $14/mo flat on Selfhost.dev (app and Postgres on one server), and $40 to $60/mo on most alternatives once the managed database and egress tax are added back. On usage-metered platforms there is no fixed number at all; the bill tracks your traffic.

That gap is what this breakdown is about.

We took one workload, a small always-on full-stack app with a Postgres database, priced it across Railway, Render, Vercel, Heroku, Fly.io, DigitalOcean, and Selfhost.dev, and scored each on the axis that actually determines regret: pricing predictability, not sticker price.

Two mechanics drive almost every surprise invoice.

The first is the separate database. Compute looks cheap because the Postgres bill is a different line item, and it is usually the larger one. On Fly.io, a 1 GB managed Postgres is $38, close to 4x the app compute sitting beside it.

The second is metering. Usage-based pricing converts a fixed cost into a variable one, so your bill inherits the variance of your traffic. That is fine until a launch, a crawler, or a retry loop turns runaway usage risk into a real number on the invoice.

Neither mechanic shows up on the pricing page.

Both show up on the bill.

The rest of this breakdown is per-provider and honest: what each platform actually costs, where each one genuinely wins, and which failure domain you are signing up for at each stage.

Quick Summary: PaaS pricing at a glance

The whole comparison, for engineers who already know what a Postgres bill looks like:

• Lowest cost surface: Selfhost.dev, $14/mo flat, app and Postgres on one server. Roughly 3 to 4x cheaper than the next option once a real database is priced in.
• Closest on price: DigitalOcean App Platform, approximately $40/mo, but the database is a separate product and App Platform has no persistent storage for stateful workloads.
• Highest sticker-to-invoice gap: Heroku (~$59) and Render (~$58), where the database, egress tax, and platform fees all land on top of compute.
• Lowest pricing predictability: Railway and Vercel. Both meter usage, so the bill inherits your traffic variance and carries real runaway usage risk.
• Steepest scaling cliff: Heroku. A $50 dyno gives 1 GB of RAM; the next real step up is $250.
• Free tiers, with the catch: Render and Railway free tiers sleep or expire, Heroku has none, and Vercel’s excludes a database. None run a production stateful workload.
• The one insight that matters: two mechanics drive every surprise invoice, the separately billed database and usage metering. Flat pricing with the database included removes both.

Think another platform will be cheaper? Prove it.

Put in your own numbers and see your real monthly cost in under 30 seconds, no signup required.

Compare your stack: Pricing calculator

Already convinced? Verify your account for a free welcome credit and deploy your first app free in about two minutes → (console.selfhost.dev)

PaaS Pricing Comparison (2026): Real Costs, Hidden Fees & Bill Risk

Most PaaS pricing pages show you a starting price. None of them show you the bill you actually get once a database, egress, and a bit of growth are in the picture. So we did the work: we priced seven platforms for the same real full-stack app, then scored each one on the things people actually regret not checking before they signed up.

How we compared: We priced each provider to run the same small always-on full-stack app, roughly 2 vCPU and 4 GB of total compute for the app plus a small (~1 GB) managed PostgreSQL, running 24/7 with approximately 100 GB egress.

Selfhost.dev runs both on one shared server. The others split them into a web service plus a separate database, so exact instance sizes differ by provider.

All prices were verified in July 2026 from each provider’s public pricing page.

*Vercel is a serverless, frontend-first outlier. It does not bundle a database, so a separate Postgres is added.

The verdict this produces

Every PaaS here carries at least one bill-risk red flag except one. Selfhost.dev is the only platform that is low-cost, zero-variance, and trap-free at the startup stage.

How to read the scores (anchored to real mechanics):

• Bill Variance = how much the monthly bill moves on its own. Flat pricing (Selfhost.dev) and fixed instance tiers (DigitalOcean, Heroku, Render) barely move. Usage-metered platforms (Railway, Vercel, Fly.io compute) move with every request.
• Surprise-Bill Risk = the odds of a shock invoice. Highest on Vercel (bandwidth billed at $0.15/GB after the 1 TB allowance, the “$286 on a $20 plan” genre) and Railway (the whole bill is metered).
• Scale Penalty = how hard growth hits the bill. Worst on Heroku (a $50 dyno gives only 1 GB RAM; the next real step, Performance-M, is $250) and Fly.io (Managed Postgres jumps $38, then $72, then $282 by tier).
• Best fit = the honest stage ceiling. Selfhost.dev is capped at “startup” on purpose: it is EU-only with one server size today, with larger servers rolling out, so we do not claim the enterprise or global-scale tier.

The starting price is never the bill.

Here is where the money actually goes for the same small app, so you can see why the totals land where they do.

† Render adds a $25/mo workspace fee for production features. *Vercel is serverless and frontend-first. It bundles no database, so a separate Postgres (Neon or Supabase) is added.

The pattern: every competitor is three stacked charges. Selfhost.dev is one line because the database and the egress are on the same server as the app. Its entire $14 server, app and database included, costs less than most of these platforms charge for a same-spec 2 vCPU / 4 GB web service alone (Render’s is $85).

The starting price is the cheapest this ever gets.

This is the number founders wish they had seen first: what the same app costs as traffic grows.

Figures are modeled from each provider’s published July 2026 rates; the trigger column is the verified mechanic that drives the jump.

Scenarios:

• Side project = the baseline config above.
• Growing startup ≈ 2 vCPU / 4 GB app + 4 GB Postgres + 500 GB egress.
• Scale-up ≈ 4 vCPU / 8 GB app + 8 GB Postgres + 1 TB egress.

Figures are modeled from each provider’s published July 2026 rates. *Vercel is a serverless, frontend-first outlier. **Selfhost.dev stays flat per server. Larger Project servers are rolling out, and heavy production data moves to Selfhost.dev Managed Databases (about half the cost of AWS RDS).

Selfhost.dev stays flat per server; larger Project servers are rolling out, and heavy production data moves to Selfhost.dev Managed Databases(about half the cost of AWS RDS). The number you can forecast does not change: you are never billed for usage you did not provision.

The takeaway: the platforms that look cheapest at the side-project stage (Railway, Vercel) are the ones whose bills climb hardest and least predictably as you grow. The predictable options stay predictable.

Price your own setup: Every number here is for one sample app. See what your exact app and database would cost in about 30 seconds, no signup required: the pricing calculator (Project Server).

Ready to skip the surprise bills? Verify your account for a free welcome credit and deploy your app in about two minutes: console.selfhost.dev.

How we compared these PaaS prices

One workload, priced seven ways.

The config is a small always-on full-stack app: roughly 2 vCPU / 4 GB of total compute for the app, a small (~1 GB) managed PostgreSQL, and ~100 GB of monthly egress, running 24/7.

This is the architecture of a typical early-stage SaaS: an app layer, a PostgreSQL database, always-on, run by a small team making cost-sensitive infrastructure decisions.

That last part matters.

“Always-on” is where usage-based and instance-based pricing diverge hardest, and it is the honest default for a production app that has to answer a request at 3 a.m.

Selfhost.dev runs the app and the database on one shared server.

Every other platform splits them into a web service plus a separate managed database, each with its own compute, storage, and often its own egress. So the exact instance sizes are not identical across providers; they cannot be.

We matched total resources, not line items, and priced the smallest realistic production configuration on each.

Selfhost.dev runs the whole stack on one 2 vCPU / 4 GB server, while the tables price every other provider on its smallest realistic production instance, which is often smaller than 2 vCPU / 4 GB (Render’s $25 Standard, DigitalOcean’s $25 for 1 vCPU / 2 GiB). That deliberately gives the competitors their cheapest sensible tier rather than inflating their bills to match ours. Where we instead compare against a strict 2 vCPU / 4 GB equivalent, such as Render’s $85 web service, we say so explicitly.

Every number here was verified in July 2026 from each provider’s public pricing page. No sales calls, no “contact us” tiers, and no estimates where a real figure was published.

That transparency is the point.

Most PaaS comparisons are published by a vendor ranking itself first, with pricing described as “models” rather than dollars. We show the config, the math, and the receipts, so you can check every figure and change the assumptions if yours differ.

PaaS pricing compared (2026), provider by provider

Seven platforms, one workload, an honest read on each. We priced the smallest realistic production setup and note where each genuinely wins, because the goal is the right tool, not the cheapest row.

1. Selfhost.dev pricing (the flat-server alternative)

Selfhost.dev collapses the split.

The app and the Postgres run on one server you can see: a Small instance is 2 vCPU / 4 GB / 40 GB for $14/mo flat, billed by the hour from prepaid credits.

Stop the server and you pay nothing. No per-service line items, no per-seat fees, and no egress tax on that config. The cost surface is one number you can forecast.

The whole $14 server, app and database included, costs less than most of these platforms charge for compute alone at the same size. Match Selfhost.dev’s Small box spec, 2 vCPU / 4 GB, and Render’s web service by itself is $85 before you add its database.

It is a real server, not a black box: streaming logs, live per-service metrics, GitHub auto-deploy with PR previews and rollbacks, custom domains with automatic SSL, and 150+ MCP tools across 22 modules to drive deploys and databases from your editor.

No lock-in; it is standard containers you can move.

For a small team running a full-stack app with a database on a budget, with a bill they can predict, nothing else on this list is close on unit economics.

The honest limits: Projects runs in the EU today, on a single well-tuned server size, with larger ones already on the way. The databases you spin up inside a project are fast, lightweight companions built to sit right next to your app.

And when you need the serious stuff, a dedicated managed PostgreSQL with high availability, point-in-time recovery, and connection pooling, that is exactly what our Managed Databases product is built to deliver. If you’re at that point and weighing a standalone managed database against AWS RDS and the rest of the field, our shortlist of the best AWS RDS alternatives ranks them on cost, predictability, and lock-in.

Best for: Full-stack apps that want their app and database on one predictable bill, not two usage meters ticking in the background.

See it in action: Projects shows you the model in a couple of minutes, or pick your stack and go, Docker, Next.js, Django, Node.js, or any GitHub repo.

Know your bill before you commit: the Selfhost.dev pricing calculator builds your exact monthly cost in about 30 seconds. No signup, no sales call, no guessing.

Then ship it: Verify your account, grab a free welcome credit, and deploy in about two minutes at console.selfhost.dev.

2. Railway pricing

Railway bills actual consumption, per second: roughly $20/vCPU and $10/GB of RAM per month, plus $0.05/GB egress.

There are no instance tiers. You provision nothing; you pay for what runs.

For our always-on app and a small Postgres, that lands between $30 and $65/mo. The range is the honest answer, because there is no fixed number. The bill tracks your traffic, a tradeoff developers love while prototyping and finance teams dread during budgeting.

A quiet month is cheap. A launch, a crawler, or a background job that spins is not.

This is the platform’s best feature and its worst liability in the same mechanic. For bursty or scale-to-zero workloads that idle most of the day, usage pricing is a real discount over reserved instances. For a steady always-on service, it converts a predictable cost into a variable one and hands you the runaway usage risk.

We settle the usage-versus-instance question between the two most-requested options directly.

The developer experience is excellent: real-time canvas, one-click databases, unlimited seats on the $20 Pro plan, first-class CLI and MCP access.

If you are weighing Railway against a flat server, here is how that math changes.

Best for: bursty, event-driven, or scale-to-zero apps where you would rather pay for actual use than reserve capacity.

The tradeoff: you give up pricing predictability to get it.

3. Render pricing

Render is instance-based and prorated by the second, which makes it far more forecastable than Railway. The catch is that the bill is assembled from separate line items: a workspace plan, compute per service, the database, egress, and storage.

A Standard web service is $25, a 1 GB Postgres is $19, egress past the 25 GB allowance is $0.15/GB, persistent storage is $0.30/GB, and the Pro workspace that unlocks autoscaling and full-stack previews is another $25.

Our config lands near $58 before the workspace fee.

The free tier sleeps, and the free Postgres expires after 30 days, so it is a demo, not a runway.

Where Render earns its price: it is mature, the instance pricing is predictable, autoscaling is real, and it carries SOC 2 and ISO 27001, with HIPAA available at a compute premium. That compliance surface is a legitimate reason to pay more.

For teams who like the model but not the stacked bill, the field of Render alternatives is worth a look.

Best for: startups that want predictable instance pricing and a compliance story, and do not mind assembling the bill from parts.

Watch out for: the egress tax and the per-service line items stacking up.

4. Vercel pricing

Vercel is not a backend host, and pricing it as one is the mistake. It is the best frontend and Next.js platform in the category: serverless, edge-distributed, with preview deployments that set the bar for developer experience.

Pro is $20 per seat, so a team of five is $100 before a single request is served.

Bandwidth is 1 TB included, then $0.15/GB, the source of the recurring surprise-invoice stories that follow a viral asset or traffic spike meeting the egress tax.

There is no bundled database.

Vercel Postgres is now Marketplace, Neon-backed, so you add a separate ~$19/mo Postgres and manage two bills.

For a full-stack app with real stateful workloads, you are stitching two products together. For backend-heavy teams choosing between the two, we trace where the bill actually goes.

Best for: frontend-heavy apps, marketing sites, and Next.js teams already in the ecosystem.

The tradeoff: per-seat cost, bandwidth spikes, and a database you bring yourself.

5. Heroku pricing

Heroku invented this category, and its pricing still reflects an earlier era. Dynos are RAM-stingy: $50/mo (Standard-2X) buys 1 GB of RAM, and the next real step, Performance-M at 2.5 GB, is $250.

That is a scaling cliff, not a curve, and the jump nearly every growing Heroku app eventually hits. The database is a separate add-on.

Essential-1 Postgres is $9 for 10 GB but has no high availability and tolerates hours of downtime a month. A production database with HA starts around $50, at which point the DB rivals the compute.

There is no free tier, gone since 2022.

Our small config is about $59, and the upgrade path from there is steep.

The RAM cliff is why most teams eventually map the migration paths off Heroku.

What you get for it: the most mature buildpack workflow, an enormous add-on marketplace, and the Salesforce ecosystem behind it. For teams already there, the operational familiarity has real value.

Best for: legacy Heroku shops and enterprises inside the Salesforce orbit.

Watch out for: the RAM cliff and the add-on database that outgrows your dyno.

6. Fly.io pricing

Fly.io is built for global, latency-sensitive workloads: Firecracker microVMs across 30+ regions, close to your users, with autostop so idle machines cost less. If multi-region is a requirement rather than a wish, this is the strongest platform on the list.

Compute is cheap. A shared 1 core / 2 GB machine is about $10/mo. The cost driver is the database: Managed Postgres starts at $38/mo for a single gigabyte, roughly 4x the app beside it, and the tier jumps are large ($38 to $72 to $282).

Our config is about $51, and the DB is most of it. Two operational caveats.

There is no built-in CI/CD; you wire up GitHub Actions for previews and rollbacks yourself.

And the platform has had reliability incidents, including a notable fleet event, so factor the failure domain into a single-provider bet.

Best for: global, real-time, or latency-sensitive apps that need edge presence.

Watch out for: a Managed Postgres that costs more than your compute, and CI you assemble yourself.

7. DigitalOcean App Platform pricing

DigitalOcean is the closest competitor here on price and the most predictable of the traditional PaaS options: flat monthly per-container pricing, generous bundled bandwidth, and no metering games.

A 1 vCPU / 2 GiB container is $25 and includes 200 GiB of transfer, egress most platforms would tax. A managed 1 GB Postgres is $15. Our config lands near $40, cheaper than Render or Heroku.

Two structural limits exist. App Platform has no persistent storage, containers are ephemeral, so any stateful workload lives in the separate managed database. It is also effectively single-region, so multi-region complexity is not solved here.

Best for: startups and scale-ups that want simple, predictable pricing on a mature cloud with cheap bandwidth.

The honest note: at ~$40 it is the nearest competitor to Selfhost.dev, still roughly 3x the cost, and the database is a separate product. Since it is the closest call on price, the closest head-to-head we have is worth reading before you decide.

The hidden costs that wreck your PaaS bill

The sticker price covers compute. The bill covers everything the sticker price left off the page.

Five line items account for almost every PaaS invoice that lands higher than expected. Four of them are taxes you can name: the database tax, the egress tax, the seat tax, and the usage tax.

1. The separate database

This is the big one.

On every platform here except Selfhost.dev, the database is a distinct billable service, and it is often the larger half of the bill. Fly.io’s Managed Postgres is $38 for 1 GB against roughly $10 of app compute.

Heroku’s production Postgres with high availability starts near $50, more than the dyno it serves. The reason it hurts is psychological as much as financial.

You price the compute, sign up, then discover the database is a second decision with its own tiers, its own storage charges, and its own scaling cliff.

What a production database actually costs across providers is a comparison of its own.

Running the app and the database on one server removes the line item entirely.

2. Per-seat pricing

Compute scales with load. Seats scale with hiring, which is the one axis you do not want tied to an infrastructure bill.

Vercel and legacy Heroku plans charge per developer: a five-person team on Vercel Pro is $100/mo before serving a single request. The cost is invisible on day one and compounds with every hire.

3. The egress tax

Bandwidth is the cost that arrives after your product works. It is billed per gigabyte past a free allowance, and the allowance is small: 5 to 25 GB on Render, 1 TB on Vercel, then $0.15/GB on both.

One asset going viral, an unoptimized image, or a chatty API turns egress into a line item you never modeled. It is the most common source of the surprise-bill screenshots that circulate on Reddit and Hacker News.

4. Cold starts and sleeping tiers

The free and hobby tiers that make a platform look cheap usually sleep. Render and Railway free services idle out, and the first request after idle pays cold start latency measured in seconds. That is fine for a demo and disqualifying for anything a user or a health check touches.

Heroku removed its free tier entirely, so the honest entry price there is not zero.

5. Usage spikes

Usage-based pricing means your bill inherits the variance of your traffic. The failure mode is not steady growth; it is the retry loop, the runaway cron, the crawler, or the launch. On metered platforms these events convert directly into invoice, and you find out after the fact.

Serverless database (Neon) pricing carries the same risk: the meter does not care whether the usage was intentional. Flat pricing with the database on the same server removes four of these five at once: no separate database line item, no per-seat fee, no egress tax within the included allowance, and no metered spike.

The one that remains is the honest one. You provision a server and pay for it whether it is busy or idle, which is the tradeoff you accept for a number you can forecast.

Price your own workload to see where your real cost surface lands.

PaaS pricing models explained: Flat-server vs usage-based vs instance-based

Flat Server: One price for the whole stack (Selfhost.dev)

By now the pattern is clear. Usage-based pricing is unpredictable; you cannot know the bill until the month is over. Instance-based pricing is predictable per piece but complicated in aggregate. So the obvious question is the one you are probably already asking: if one model is unpredictable and the other is complicated, what does the better alternative look like?

It looks like collapsing the whole thing into one number.

Your app and your database run together on one server, at one flat monthly price, known before the month begins. No wondering why your database cost more than your application. No egress charge you did not know existed. No adding a teammate and watching the bill quietly climb.

There is an honest tradeoff: you pay for the server whether it is busy or idle, like any reserved instance. If your workload sleeps most of the day, usage-based wins on the cheapest-when-idle line. But for most always-on production apps, one flat server often works out lower than paying separately for compute, a managed database, and usage-based add-ons, and you can forecast it a year out and be right.

Because infrastructure should not be the most unpredictable line item in your startup. You should be watching your users grow, not your cloud invoice.

“No surprise bills” is not a slogan. It is a property of the pricing model you pick. That is the model Selfhost.dev is built around. Spin up an app and its database on one server, verify your account for a free welcome credit, and watch the whole bill become a single number you already know.

Usage-based (Railway, Fly.io compute)

You pay for what you consume, metered per second: CPU, memory, egress, and invocations. The appeal is real. An idle service costs almost nothing, so bursty and scale-to-zero workloads win here. The cost is predictability.

Your bill inherits the variance of your traffic, and the worst case is unbounded. A retry loop or a launch does not throttle; it bills. You are trading a fixed cost for a variable one and accepting the runaway usage risk that comes with it.

Instance-based (Render, Heroku, DigitalOcean)

You reserve a fixed-size box and pay a flat rate for it, busy or idle. The compute line is predictable, which is the improvement over usage-based pricing.

The catch is that the box is only one line item. The database, egress, storage, seats, and platform fees are billed separately, so the real bill is a sum you assemble, not the number on the pricing card.

Predictable per line, surprising in total.

Which PaaS should you choose?

There is no single best PaaS, only the right one for a given workload.

Match the platform to the shape of your app, not to a leaderboard.

• Frontend or Next.js site → Vercel. Nothing matches its edge network, preview deployments, and frontend developer experience. Bring your own database.
• Global, low-latency, multi-region → Fly.io. If your users are everywhere and latency is the product, Firecracker microVMs close to them are worth the premium and the extra operational work.
• Bursty or scale-to-zero, and fine with a variable bill → Railway. For workloads that idle most of the day, usage pricing is a genuine discount, if you can tolerate an unpredictable invoice.
• Cheapest mature managed cloud → DigitalOcean. Simple, predictable, cheap bandwidth, on a broad cloud. The nearest competitor here on price, at roughly 3x our number.
• Full-stack app with a database, on a budget, with a bill you can forecast → Selfhost.dev. One server, app and Postgres together, $14 flat, pause to zero. For a small team shipping a real product on predictable unit economics, nothing else on this list is close.

That last case is the most common one, and it is the one the market prices worst.

A full-stack app with a database is the default shape of an early product, and it is exactly the workload where separate database fees and metered usage do the most damage.

A flat server with the database included removes both.

If that is your workload, price it yourself in about 30 seconds, no signup, and see where your real cost surface lands.Then, when the number makes sense, put it into production: deploy your stack (Docker, Next.js, Django, Node.js, or any GitHub repo), verify your account for a free welcome credit, and you are live in about two minutes at console.selfhost.dev.

Conclusion: Predictable PaaS pricing wins

The clearest signal in this data is not who is cheapest. It is that the cheapest sticker price and the cheapest bill are almost never the same platform.

Every provider prices compute to look competitive, then recovers its margin somewhere you were not looking: the database, the egress, the per-seat fee. Those are the line items you do not see until they are already on the invoice. Put plainly, infrastructure pricing is a tax on uncertainty, and the sticker price is engineered to hide how much of that tax you just signed up for.

Which is why the real enemy was never price. It was variance.

Most teams optimize for the first month. They compare the $5 and $7 entry tiers, pick the lowest, and quietly inherit a bill that scales with traffic, a database that ends up costing more than the app, and a seat fee that climbs with headcount. The number that mattered was never the entry price. It was the slope, how steeply the bill rises on its own as you grow.

So the decision comes down to two questions, in order. First, is your workload steady or bursty? Bursty, idle-heavy workloads really are cheaper metered. Steady, always-on services are cheaper and calmer on a fixed price. Second, how many separate things are you billed for? Every added line item, database, egress, seats, storage, is one more surface where the bill can surprise you. Fewer line items, fewer surprises.

From there the calls are direct, in the order most early products should consider them:

• Choose Selfhost.dev if you are shipping a full-stack app with a database and want one number you can forecast. The app and the database run on one server at $14 flat, with no separate database bill and no usage meter, and it pauses to zero when idle. This is the default shape of an early-stage product, and it is the workload that every usage-based and instance-based model prices worst, which is exactly the gap a flat server closes.
• Choose Vercel if the product is a frontend or Next.js site and the backend is someone else’s problem.
• Choose Fly.io if global latency is a product requirement and you can absorb the operational work and the database premium.
• Choose Railway if your workload idles most of the day and you would rather pay for real use than reserved capacity, and you can live with a variable invoice.
• Choose DigitalOcean if you want the cheapest predictable traditional cloud and do not mind running the database as a separate product.

Selfhost.dev leads that list for a reason. A full-stack app with a database is the default shape of an early product, and it is precisely the workload where separate database fees and metered usage do the most damage. One server with the database included removes both at once, and turns a stack of separate line items into a single number you can drop into a budget and forget.

But for most early products, the trap is not paying an extra $20 a month. It is choosing an architecture that becomes expensive to run and expensive to leave.

Optimize for the bill you can predict, not the one you can afford today, and choosing a PaaS stops being a gamble.

Because the invoice that kills a startup is rarely the first one

If you have read this far, the fastest way to know whether the flat-server model fits your stack is to run your own numbers. Price your exact setup in about 30 seconds, no signup required. If the number makes sense, deploy your first app free with a welcome credit at console.selfhost.dev.

Frequently Asked Questions