Heroku Alternatives Decision Framework: What Actually Matters When Picking a PaaS

TL;DR: After Heroku killed their free tier, everyone rushed to Railway, Render, and Fly. Three years later, here is the framework that actually matters for picking between them based on billing model, not feature lists.

When Heroku discontinued their free tier in November 2022, hundreds of thousands of projects had to migrate. Most comparison posts you will find today are just feature lists. This guide focuses on what matters in practice after using all of these platforms in production: how they bill you and how that interacts with your traffic pattern and your tolerance for surprise invoices.

Quick Decision Helper

• Need predictable costs? → Fixed tiers (Seenode, Render)
• Traffic varies wildly? → Usage-based (Railway, Fly.io)
• Just a static site? → Serverless (Vercel, Netlify)
• Need enterprise features? → Render
• Budget under $15/month? → Seenode or self-hosted

The One Thing Everyone Gets Wrong

People compare features. They should compare billing models.

Your choice is almost never about:

• "Which has the best dashboard?"
• "Which supports my framework?"
• "Which has the nicest CLI?"

Most modern PaaS providers have reasonable dashboards, support the common languages and frameworks, and give you some batteries-included tooling. The real question is:

Which billing model matches your traffic pattern and your budget anxiety tolerance?

If you choose the wrong model, the platform can be technically great and still feel terrible to use, because every deploy becomes a question of, "What will the bill look like next month?"

Migrating from Heroku?

If you're coming from Heroku's free tier, the biggest shock is usually the cost. Heroku's free tier spoiled us—most alternatives start at $4–20/month. The good news: you're getting better performance, more predictable uptime, and actual support.

The closest "drop-in" replacements are Railway (similar workflow) and Seenode (similar economics). Render feels more "enterprise" but costs more.

The Three Billing Models That Emerged

Over the last few years, three dominant billing models have crystallized.

Model 1: Fixed Per-Node Tiers (Seenode, Render)

You pay a flat monthly rate for provisioned capacity. Whether your app is slammed 24/7 or idle for half the month, the bill barely moves.

• Predictable: You know roughly what next month’s invoice will be.
• Simple: You pay for the size and count of services and databases, not for each individual CPU cycle.
• Wasteful at low usage: You still pay even when your app is mostly idle.

Best for: Steady traffic, budget-conscious teams, and people who hate billing surprises.

Example costs (Jan 2026):

• Seenode: $4/month (Basic web + Tier 1 Postgres)
• Seenode: $11/month (Standard web + Tier 2 Postgres)
• Render: $13/month (Starter web + Basic Postgres)

If your app is always on and has relatively consistent traffic, fixed tiers tend to win. You trade theoretical efficiency for billing sanity.

Model 2: Usage-Based Metering (Railway, Fly.io)

You pay for what you actually use: per-minute compute, per-second CPU, per-request, per-GB of storage and bandwidth.

• Efficient at low/variable usage: Quiet apps can be very cheap.
• Scales smoothly with traffic: Spikes cost more, but you do not need to resize instances manually.
• Unpredictable: If you do not monitor usage, bills can drift or spike.

Best for: Variable traffic, developers who monitor usage, or apps that must be 24/7 online but receive low or bursty traffic.

Example costs (Jan 2026):

• Railway: $20–30/month typical (Pro plan with $20 included credit), can spike to $50+ with sustained traffic.
• Fly.io: $0–15/month for hobby apps without managed Postgres, $43–50/month once you add managed Postgres.

Usage-based systems reward teams that:

• Instrument and monitor their apps.
• Understand their baseline traffic profile.
• Are willing to occasionally dig through billing dashboards.

If that doesn't describe you, this model can feel like a tax audit every month.

Model 3: Serverless (Vercel, Netlify)

You pay per function invocation. There is no persistent application process; instead, your code runs on demand in short-lived serverless functions.

• Amazing for JAMstack: Static-first sites, Next.js, Astro, Remix, etc.
• Great for spiky traffic: You only pay when people actually hit your endpoints.
• Awkward for stateful backends: Long-lived connections, background jobs, or session-heavy apps do not fit naturally.

Best for: JAMstack apps, modern React frameworks, marketing sites, and dashboards with lightweight APIs.

Not suitable for: Traditional backend frameworks like Django, Rails, or Express apps that rely on in-memory state, sticky sessions, or complex background processing.

If your mental model of “backend” is a long-running process with queues, WebSockets, and custom workers, serverless can feel like fighting the platform instead of using it.

What It Actually Costs (Real Numbers, Jan 2026)

To make this concrete, consider a typical full-stack app:

• Web service with roughly 1 GB RAM
• Managed Postgres with 1 GB storage (plus sensible defaults)

Here is what that looks like across platforms today:

Platform	Monthly Cost	Billing Model	What You Get
Seenode	$11	Fixed tier	Standard web + Tier 2 Postgres, always-on
Fly.io	$12–15	Usage-based	Self-managed Postgres (or $43–50/month with managed Postgres)
Railway	$20–30	Usage-based	Pro plan with $20 credit, can spike with traffic
Render	$57+	Fixed tier	Web service + Postgres with PITR and zero-downtime deploys

The cliff nobody mentions: Fly.io looks cheap ($0–15) for hobby apps without managed Postgres, but once you turn on managed Postgres, the bill often jumps up rather fast ($45-50). The platform is still good—but the mental model of it being "cheap" quietly disappears.

The Decision Framework

Stop comparing dashboards and feature checklists. Walk through these questions instead.

Question 1: Can you tolerate variable billing?

• Yes, I monitor usage and I am okay with variance
  
  Choose Railway or Fly.io. You get flexible scaling and can squeeze out cost efficiencies if you understand your workload.

• No, I need predictable monthly costs
  
  Choose Seenode or Render. Fixed tiers mean you know the number before the invoice arrives.

If you feel stress every time a cloud bill arrives, treat predictability as a core feature—not a nice-to-have.

Question 2: What is your budget ceiling?

Use this as a rough mapping for a single production app with a database:

• $5–15/month

  • Seenode (Basic or Standard tiers: $4–11/month)
  • Self-hosted on a low-cost VPS (Hetzner, Contabo, etc.), if you are willing to manage infra.

• $20–50/month

  • Railway (Pro plan, potentially higher with sustained traffic)
  • Seenode higher tiers if you need more resources but want fixed pricing.

• $50–100/month

  • Render (app + managed Postgres with PITR)
  • Fly.io with managed Postgres and multi-region setups.

• $100+/month

  • Render with enterprise-style features (SSO, high availability, advanced backups).

These numbers change over time, but the shape of the tradeoffs does not.

Question 3: Do you need enterprise features?

• Yes – compliance, SOC2, SSO, PITR, zero-downtime deploys are non-negotiable
  
  Lean toward Render. It is opinionated, boring in the best way, and designed for teams that want stability and support more than they want to save $20/month.

• No – I mostly need HTTPS, logs, deploys, and a Postgres database
  
  Seenode or Railway are usually a better fit. They give you the essentials without pushing you up into enterprise pricing.

If legal and compliance teams are involved, the cheapest platform is rarely the right one.

Question 4: Is global distribution critical?

• Yes – my users are spread across regions and latency matters
  
  Fly.io shines here, with multi-region deployments as a first-class concept.

• No – most users are in one region and latency is fine
  
  Seenode, Railway, or Render will do the job. Focus on simplicity and billing, not on global replicas you may never need.

What I Actually Use (and Why)

Disclosure: I work on Seenode, so understand the bias. That said, here is the honest breakdown of what I reach for in different scenarios.

For hobby projects

• Choice: Seenode Basic ($4/month)
• Why: It is the cheapest always-on option with a database included that still feels like Heroku. I can git push, get HTTPS and logs, and forget about it. At $4/month, it is psychologically close to “free” but without the randomness of free-tier shutdowns.

For client projects

• Choice: Render
• Why: Clients pay for peace of mind. Render gives you:
  • Managed Postgres with point-in-time recovery (PITR)
  • Zero-downtime deploys
  • A mature, predictable environment

The extra cost (often $57+/month for a typical setup) is easy to justify compared to the cost of a single outage for a paying client.

For high-traffic production on a coffee-priced budget

• Choice: Self-hosted on Hetzner (or similar low-cost VPS) with Coolify or Dokploy.

If you need:

• Many services
• Heavy background workers
• Higher traffic

…and still want to stay under $50/month, managed PaaS platforms become harder to justify. Self-hosting:

• Compresses all infra cost into a single VPS bill.
• Gives you full control over resource allocation.
• Moves all responsibility for uptime onto you.

Downtime in this model is almost always your fault—bad deploys, poor monitoring, slow incident response. You save money but pay in operations time and cognitive load.

The Missing Costs Nobody Mentions

Looking only at base instance prices hides a lot of real-world cost. Four common gotchas:

Common mistake: Picking a platform based on the cheapest headline price, then getting surprised by egress fees, backup costs, or usage spikes. Always factor in the hidden costs.

1. Egress fees

• Railway: $0.05/GB outbound
• Fly.io: $0.02/GB outbound

If you run a webhook-heavy app, file-serving API, or anything data-intensive, egress can quietly add $50–200/month on top of your compute bill.

2. Railway’s credit system

• Hobby: $1/month subscription with $5 usage credit
• Pro: $20/month subscription with $20 usage credit

Once your actual usage exceeds that credit, metered charges apply. For small apps this is fine; for growing usage it can turn into an invisible ratchet until you look closely at the billing breakdown.

3. Stopped machines and storage

• Fly.io continues billing storage even when machines are stopped: around $0.15/GB/month.

Stopping everything in a panic does not always reset the bill to zero. Persistent volumes, snapshots, and images keep ticking along until you explicitly delete them.

4. Database backups and safety nets

• Render: Includes PITR on paid database plans. This is a genuine safety feature.
• Railway / Fly.io: You usually need to:
  • Configure backups yourself, or
  • Rely on third-party tools, or
  • Accept a more limited restore story.

This is invisible until something goes wrong—and then it is the only line item that matters.

The Closest Alternatives to OG Heroku

If what you really want is “git push and boom, we are live”, here is how the modern landscape looks:

1. Railway – Captures a lot of the Heroku magic. Simple, fast to onboard. The tradeoff is billing unpredictability if you are not watching usage.
2. Seenode – Leans into Heroku-style simplicity with Heroku-free-tier-style economics. At $4/month, it is psychologically very close to the old “free dyno” experience.
3. Render – The most production-ready choice, especially for serious projects and client work. More expensive, but you get strong defaults and guardrails.

Everything else in the ecosystem is either:

• More serverless and front-end centric (Vercel, Netlify), or
• More infra-heavy and DIY (Cloud providers, raw Kubernetes, self-hosting).

They can be great—but they are no longer "Heroku for everyone."

Quick Comparison Summary

Platform	Best For	Monthly Cost	Billing Model	Key Differentiator
Seenode	Hobby projects, predictable costs	$4–11	Fixed	Cheapest always-on with DB
Railway	Variable traffic, Heroku-like workflow	$20–30+	Usage-based	Simplicity + flexibility
Render	Client work, enterprise needs	$57+	Fixed	Production-ready defaults
Fly.io	Global distribution, bursty traffic	$0–50+	Usage-based	Multi-region by default

Key Takeaways

1. Billing model matters more than features — Match it to your traffic pattern
2. Hidden costs add up — Egress, storage, backups can double your bill
3. Predictability vs. flexibility — Choose based on your tolerance for billing surprises
4. Enterprise features cost money — Only pay for them if you actually need them
5. Self-hosting saves money — But you pay in operational overhead

So… What Should You Actually Do?

When choosing a PaaS in 2026, ask yourself one question first:

Is predictable billing or pay-as-you-go flexibility more important for this project?

Then layer on:

• How much operational burden am I willing to accept?
• Do I actually need global distribution, or does a single region work?
• Is this a hobby app, client app, or revenue-critical system?

Once you answer those honestly, the "Heroku alternatives" list narrows itself down very quickly.

Use this checklist as you evaluate providers:

• Your stack (language, framework, database)
• Rough traffic pattern (requests/day or month)
• Maximum monthly budget
• Whether you need enterprise features (compliance, SSO, etc.)

With clear answers to those questions, you can quickly narrow down to one or two platforms whose billing models actually fit how your app is used.