The Hidden PaaS Tax Nobody Puts in the Pricing Table

Render charges $100 a month for a dedicated outbound IP address. Vercel charges $100 a month for the same thing, on a completely unrelated pricing page, using a completely unrelated billing model. Neither number appears in the headline comparison tables that get shared every time someone asks "Render vs Railway vs Fly vs Vercel" — those tables compare web-service base prices, and both platforms' base prices are perfectly reasonable. The $100 shows up later, on the actual invoice, the first time an app needs to hand a bank's fraud API or a partner's webhook a fixed IP to allowlist.

That fee is the tell. It's not a compute cost, a storage cost, or a bandwidth cost — it's a fee for a feature that exists only because the underlying infrastructure is shared. This post reconstructs a real invoice for a real workload on four platforms, line by line, and then prices the identical workload on a single owned server, where most of these line items simply don't exist as billable events.

The Workload: One Web Service, One Worker, One Postgres​

To keep the comparison honest, every platform below prices the same topology — the shape of a typical early-revenue SaaS, not a strawman:

• One web service (API + frontend)
• One background worker (queue processing, scheduled jobs)
• One Postgres database, production-sized (not the free/hobby tier)
• ~150GB/month of egress — a real but unremarkable amount of traffic
• One outbound IP that needs to be static, because a payment processor or partner API requires an allowlisted address
• "Fast enough" support, because the app now has paying customers and a support ticket sitting for three days is no longer acceptable

Nothing here is exotic. It's the default shape of a product that graduated past the free tier six months ago. Here's what it costs, platform by platform, and then the same thing on a single Hetzner box.

The Answer, Up Front​

The rest of this post is where each of those numbers comes from.

Render: The $100 Line Nobody Budgets For​

Render's per-service pricing looks competitive at first glance — a Standard instance runs $25/month, and a production-sized Postgres Basic-1GB instance runs about $20/month. For the workload above:

• Web service (Standard): $25
• Background worker (Standard): $25
• Postgres (Basic-1GB): $20
• Bandwidth overage beyond the plan's included allowance, at $0.15/GB: roughly $5–10 depending on how much of the 150GB the included tier absorbs
• Dedicated outbound IP: $100/month, for three static IPv4 addresses tied to one workspace/environment in one region
• A Professional workspace seat ($19/user/month) — required to unlock chat support instead of email-only

Subtotal: ~$196/month. The dedicated IP alone is roughly four times the cost of the web service it's attached to, and more than the web service and worker combined. Nothing else on this list comes close to costing that much for a feature that is, functionally, "give me one number that doesn't change."

Railway: The Tax You Pay With Trust, Not Dollars​

Railway's Pro plan is $20/month and includes $20 of usage credit, so the subscription fee and the first slice of metered compute effectively cancel out. For the same web+worker+Postgres topology, realistic usage draw lands around $50/month total once egress (billed at $0.05/GB) is folded in — genuinely the cheapest of the three general-purpose PaaS options here.

But look at what a static IP actually buys on Railway. Static outbound IPs are free on the Pro plan, enabled with a toggle — no $100 fee. The catch is in Railway's own documentation: "there is no guarantee that the IPv4 addresses assigned to your service are dedicated... they may be shared with other Railway customers." That's a materially different product than Render's or Fly's dedicated IP. A partner's compliance team asking "is this IP exclusively yours" gets a "not exactly" answer, which can be a dealbreaker for exactly the kind of banking or healthcare API integration that made a static IP necessary in the first place.

The support side has the same shape. Business Class (priority) support isn't a line item you can add to a Pro plan invoice at any price — it only unlocks once a workspace crosses $5,000/month in spend, or on Enterprise. A team that wants faster response times before it's spending five figures a month simply can't buy that outcome from Railway. The tax here isn't a fee; it's an exclusion.

Fly.io: Cheap Compute, New Metered Line Items​

Fly.io's Machines pricing is genuinely inexpensive at small scale — a shared-cpu-1x 512MB machine runs under $4/month, so two machines (web + worker) land around $35/month all-in once Managed Postgres is included. The IP-allocation cost is modest and transparent by comparison to Render and Vercel:

• Dedicated IPv4 (inbound): $2/month
• Static egress IPv4 (outbound, one per region): $3.60/month

Together, $5.60/month — a rounding error next to Render's $100. But two new line items appeared on Fly invoices in early 2026 that didn't exist a year earlier. Volume snapshots started billing in January 2026 at $0.08/GB/month, and because Fly retains multiple snapshots by default, the effective cost runs 2–5x the raw storage rate until older snapshots age out — a 10GB Postgres volume with a handful of retained snapshots adds roughly $4/month that wasn't a billable event in 2025. Inter-region private networking started billing in February 2026 at Machine rates ($0.01/GB in, $0.02/GB out) — $0 for this single-region topology, but a real new cost the moment a team adds a second region for latency or redundancy.

Fly.io's honest total here is the lowest of the three general-purpose PaaS platforms — call it ~$45–49/month — which matters for the argument this post is making: the tax isn't universal in size, it's universal in kind. Every platform meters something related to IP allocation or shared-infrastructure overhead that a single owned server never has to.

Vercel: The Platform That Can't Even Price This Topology​

Vercel doesn't offer a persistent background worker or a managed relational database, so this workload doesn't actually run on Vercel end to end — a team would pair Vercel's web tier with a separate Postgres vendor (Neon, Supabase) and a separate queue, each with its own bill. Pricing just the web portion:

• Pro plan: $20/seat/month, including 1TB of bandwidth (150GB fits comfortably inside it)
• Static outbound IPs, if the payment/partner API needs one: $100/month per project — the same number as Render, arrived at completely independently

That's ~$120/month for the slice of the stack Vercel actually serves, before pricing the database and worker elsewhere. And the support-tier story on Vercel isn't a line item at all — it's a cliff. SLA-backed support, SSO, and dedicated infrastructure sit behind Enterprise, and Enterprise contracts start around $20,000/year (~$1,667/month) — not a fee you add to a Pro invoice, but a different pricing universe you have to move into entirely.

The Same Topology on Hetzner​

A single Hetzner CX22 — 2 vCPUs, 4GB RAM, 40GB NVMe — runs about $5/month and includes 20TB of monthly outbound transfer and one IPv4 address, no add-on required. Running web service, worker, and Postgres together via Docker Compose (or a self-hosted PaaS layer like bex) fits comfortably on that box for an early-stage app; a CX32 for headroom is still under $10/month.

Every line item that inflated the platform invoices above is either included or doesn't exist as a metered concept here:

• 150GB egress — free; 20TB is included, and there's no per-GB overage rate to trigger
• Static outbound IP — the box's own IPv4 address is already fixed and exclusively yours; there's no separate "dedicated IP" product to buy, because dedication was never in question
• Support tier — nothing to gate; there's no seat count or monthly-spend threshold standing between "I have a question" and "I get an answer" from the people who run the software

Total: ~$5–10/month, roughly a twentieth of Render's invoice for the identical topology.

It's worth being honest that Hetzner itself isn't immune to price changes — its dedicated-vCPU CCX line roughly tripled in a June 2026 repricing, after an across-the-board increase in April blamed on DRAM contract prices. The CX line used in this comparison wasn't part of that specific spike, but "self-host on commodity hardware" has to mean tracking a supplier's pricing risk over time, not treating one price snapshot as permanent.

What the $5-a-Month Box Doesn't Give You​

None of this is an argument that Render, Railway, Fly, and Vercel are bad products — they sell something real, and the invoice comparison above is deliberately silent about it. A managed Postgres instance comes with automated backups, point-in-time recovery, and failover that a Docker container on a single VPS does not have unless someone builds it. Patching the OS, the runtime, and the database engine is the platform's job on a PaaS and your job on a bare server. None of these platforms' engineering teams are on call for your Hetzner box at 3 a.m.

That operational gap is real, and it's the actual trade a team is making when it moves off a hosted PaaS — not "give up reliability to save money," but "take on the operational work yourself, or hand it to tooling built specifically to close that gap without reintroducing the multi-tenancy fees this post just added up."

Why It's a Multi-Tenancy Tax, Not a Cost of Doing Business​

Every fee reconstructed above exists for the same underlying reason: the provider is running many tenants on shared infrastructure, and a dedicated IP, a NAT gateway, or a priority-support queue is a scarce, contended resource that has to be metered, allocated, or gated to keep it fair across customers who didn't ask to share it. Render's $100 IP fee isn't pricing the IP address itself — IPv4 addresses cost providers a few dollars a year at most — it's pricing the operational work of carving a stable, exclusive resource out of a pool built for elastic, ephemeral, shared tenancy. Railway's non-dedicated free IP is the same tension resolved the other way: keep it free by not promising exclusivity. Vercel's support cliff is a headcount-allocation problem wearing a pricing-tier costume.

A single-tenant server has none of these tensions to resolve, because there's no pool to allocate from and no other tenant to protect the SLA from. The IP is yours because it's the only workload on the box. Support doesn't need a tier, because there's no fleet-wide queue to prioritize against. The tax isn't incompetence or greed on the platforms' part — it's the structurally unavoidable cost of multi-tenancy, and it shows up as a line item precisely because it has to be rationed somehow.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own, with a Render-compatible API and none of the per-IP or support-tier line items above. Star the repo on GitHub or deploy your first app today.

Sources:

• Outbound IP Addresses — Render Docs
• Dedicated IPs for your services on Render — Render Blog
• Outbound Bandwidth — Render Docs
• Pricing — Render
• Static Outbound IPs — Railway Docs
• Pricing Plans — Railway Docs
• Support — Railway Docs
• Fly.io Resource Pricing — Fly Docs
• How Do I Get a Static IP for Fly.io Apps? — QuotaGuard
• We are going to start charging for MPG inter-region private network usage from February 2026 — Fly.io Community
• Static IPs — Vercel Docs
• Vercel Enterprise Plan — Vercel Docs
• Pricing on Vercel — Vercel Docs
• Hetzner introduces new shared vCPU cloud servers — Hetzner Pressroom
• Price Adjustment 15 June 2026 — Hetzner Docs