The Free Tier Is Gone — Heroku Alternatives That Still Have One

Why founders look for Heroku alternatives

For years, the deployment story for indie builders was simple: push to Heroku, get a URL. The free tier handled hobby projects, MVPs, and demo apps. When you needed more, you scaled up to paid dynos. The developer experience was excellent and the pricing was fair for what you got.

Two things changed this.

First, Heroku removed the free tier in November 2022. Overnight, hundreds of thousands of hobby projects needed a new home. The Eco dyno at $5/mo (shared across apps, with sleep after inactivity) and the Basic dyno at $7/mo (always on) replaced what used to be free.

Second, the competition got better. Railway, Render, and Fly.io all launched with developer experiences that matched or exceeded Heroku, at lower prices, with more transparent billing. Heroku's dashboard, CLI, and deployment pipeline — once best-in-class — started to feel dated.

For a bootstrapped founder deploying a SaaS product, the hosting decision matters because it is a recurring cost that compounds. A $20/mo difference in hosting is $240/year. Over 3 years, that is $720 — enough for a domain, an email service, and a few months of marketing tools. Burn rate optimization starts with infrastructure.

How we evaluated these alternatives

We deployed the same application (a Node.js API with Postgres, Redis, and a background worker) to each platform and measured:

• Deployment speed: Time from git push to live URL
• Cold start latency: How fast the first request is served after a period of inactivity (important for free tiers that spin down)
• Reliability: Uptime over 30 days with synthetic monitoring
• Cost at low traffic: Monthly bill for an app handling 10,000 requests/day
• Cost at moderate traffic: Monthly bill for an app handling 100,000 requests/day
• Database experience: How easy is it to provision, connect, and manage a Postgres instance?

We prioritized the indie builder profile: shipping a product fast, keeping costs low, and avoiding infrastructure that requires a full-time DevOps hire to manage.

Deep dive: what each alternative does best

Railway — the Heroku successor

Railway is what Heroku would be if it were built today. The deployment experience is seamless: connect a GitHub repo, Railway auto-detects the framework and language, builds the app, and deploys it. The whole process takes under 90 seconds for a typical Node.js or Python application.

The built-in database experience is where Railway surpasses Heroku. Click a button to provision Postgres, MySQL, Redis, or MongoDB. The connection string is automatically injected as an environment variable. No add-on marketplace, no third-party configuration, no copying connection strings between dashboards. It just works.

Preview environments are another win. Every pull request gets its own deployment with its own database. This is standard in enterprise CI/CD but rare in indie-friendly platforms. For a solo founder using GitHub PRs even for personal projects, preview environments catch bugs before they hit production.

The Hobby plan at $5/mo includes $5 in usage credits. A small app (one web service, one Postgres instance, low traffic) typically costs $3-8/mo in usage. This means the $5 credit often covers the entire bill for a low-traffic side project. However, there is no true free tier — the $5/mo minimum applies even if your usage is $0.

Usage-based pricing is Railway's double-edged sword. You pay for compute (per vCPU-hour), memory, network egress, and database storage. For predictable low-traffic apps, this is cheap. For apps with traffic spikes (like getting featured on Hacker News or Product Hunt), the bill can jump unexpectedly. Set up billing alerts.

Railway's region options are limited compared to Fly.io. Most deployments run in US regions. If your users are primarily in Europe or Asia-Pacific, the added latency may be noticeable for API latency-sensitive applications.

When to pick Railway: You want the easiest migration from Heroku, the best developer experience, and transparent pricing. Ideal for SaaS MVPs and production apps with predictable traffic.

Render — the free tier champion

Render positioned itself as the Heroku alternative with a real free tier, and it delivers. Free static site hosting with 100 GB bandwidth per month. Free web services with 750 compute hours per month. These are genuinely usable for side projects, documentation sites, and staging environments.

The catch with free web services is spin-down. After 15 minutes of inactivity, your service goes to sleep. The first request after sleep triggers a cold start that takes 30-60 seconds. For a personal API that you hit occasionally, this is fine. For a user-facing product, cold starts are a conversion rate killer.

The paid Individual tier at $7/mo per service removes spin-down and gives you a dedicated instance. This is comparable to Heroku's Basic dyno at $7/mo, with the added benefit of Render's better deployment pipeline.

Render's managed Postgres is solid but has a sharp edge: the free tier database expires after 90 days. You can create a new one (migrating data manually) or upgrade to the paid plan at $7/mo. This is transparent in the documentation but still catches people off guard.

Build times are Render's weakest point. Complex applications with large dependency trees can take 5+ minutes to build. Railway typically builds the same application in 1-2 minutes. For a solo founder deploying multiple times per day, the difference in iteration speed is noticeable.

The infrastructure backing is solid. Render runs on AWS and GCP with automatic SSL, CDN for static assets, and DDoS protection. Uptime has been reliable in our monitoring.

When to pick Render: You need a free tier for static sites, staging environments, or low-traffic projects. Also strong for paid deployments if build speed is not a priority.

Fly.io — the global edge platform

Fly.io takes a fundamentally different approach. Instead of running your app in one data center, Fly.io deploys your containers to points of presence worldwide. Your API request is served from the data center closest to the user making the request.

For a SaaS product with users in New York, London, and Tokyo, this means sub-100ms response times for everyone, without the complexity of managing a multi-region deployment yourself. Traditional PaaS platforms run your app in one region (usually US East or EU West), and users far from that region experience added latency.

The Machines API is powerful for cost optimization. Scale-to-zero means your app stops when no requests are coming and starts within a few seconds when traffic arrives. Unlike Render's free tier spin-down (30-60 second cold starts), Fly.io machines typically restart in 1-3 seconds.

The free allowance includes 3 shared-cpu VMs with 256MB RAM each. This is enough for a small API or web service. Postgres is available with read replicas, and Fly.io offers LiteFS for distributed SQLite — a compelling option for read-heavy applications that want global replication without a full Postgres cluster.

The learning curve is steeper than Railway or Render. Deployment uses a CLI tool (flyctl) and a fly.toml configuration file. The concepts (machines, volumes, regions, secrets) require more upfront learning. Debugging is harder — logs are less accessible than on Railway or Render's web dashboards, and you sometimes need to SSH into the machine to investigate issues.

Pricing is granular. CPU, memory, bandwidth, and storage are all billed separately. A small app typically costs $3-10/mo, but predicting the exact bill requires understanding the pricing dimensions. The billing dashboard helps, but it is less intuitive than Railway's usage-credit model.

When to pick Fly.io: Your users are globally distributed and response time matters. Also compelling for edge computing use cases, real-time applications, and apps where scale-to-zero saves meaningful money.

Coolify — your own PaaS

Coolify is an open-source platform that turns any VPS into a Heroku-like deployment platform. Install it on a $5/mo Hetzner or DigitalOcean server, and you get git push to deploy, automatic SSL via Let's Encrypt, one-click database provisioning, and a web dashboard for managing everything.

The cost math is compelling. A single $10/mo Hetzner CPX21 (3 vCPU, 4GB RAM) can host 5-10 small web applications, several databases, and background workers. The same workload on Railway would cost $5-15 per service, easily exceeding $50/mo. On Render, similar pricing. Coolify collapses this into a flat infrastructure cost.

The deployment experience mirrors Heroku closely. Connect a GitHub repo, Coolify detects the buildpack, builds the application, and deploys it as a Docker container. Nixpacks (the same builder Railway uses) handle automatic language and framework detection. Custom Dockerfiles work too.

Database management is one-click. Postgres, MySQL, MongoDB, Redis, and more deploy as managed containers on your server. Coolify handles automatic backups (configurable schedule and retention) and connection string injection.

The trade-offs are the trade-offs of self-hosting. Server maintenance (OS updates, security patches, disk monitoring) is your responsibility. There is no automatic failover — if your server goes down, all your apps go down. There is no global CDN or multi-region deployment unless you set it up yourself. Monitoring your server with tools like Uptime Kuma (which Coolify can deploy for you) is essential.

For a technical founder who is comfortable with basic Linux administration, Coolify is the highest-value option on this list. The savings compound over time, and you own your entire infrastructure.

When to pick Coolify: You are technical, comfortable with Linux servers, and want to minimize hosting costs by consolidating multiple services onto a single VPS.

DigitalOcean App Platform — the safe enterprise choice

DigitalOcean App Platform is the managed PaaS offering from one of the most established cloud providers for indie developers. If you already use DigitalOcean Droplets, Managed Databases, or Spaces, App Platform integrates seamlessly.

The deployment experience is competent but not remarkable. Connect a GitHub repo, select your branch, configure environment variables, deploy. Build detection works for common frameworks. The dashboard lets you monitor logs, metrics, and deployment history.

Free static site hosting covers 3 sites with 1 GB storage and 1 GB bandwidth. This is modest compared to Render (100 GB bandwidth) but functional for documentation sites or landing pages.

Per-container pricing is the main limitation. A Basic container at $5/mo runs a single instance. Add a worker process and that is another $5/mo. Add a managed Postgres database ($7/mo minimum) and you are at $17/mo for a standard web app stack. Railway handles the same workload for $5-10/mo with usage-based pricing.

The value of App Platform is context. If your infrastructure is already on DigitalOcean — Droplets for compute, Managed Databases for data, Spaces for files — App Platform fits naturally into that ecosystem. Private networking between App Platform services and your existing DigitalOcean resources works out of the box.

When to pick DigitalOcean App Platform: You are already invested in the DigitalOcean ecosystem and want a PaaS that integrates with your existing infrastructure.

Dokku — the original self-hosted Heroku

Dokku is the oldest project on this list and the simplest. It is literally a bash script that installs a Heroku-compatible deployment platform on any Ubuntu server. If you know Heroku, you know Dokku.

The Heroku buildpack compatibility is Dokku's killer feature. If your app deploys to Heroku with a Procfile, it deploys to Dokku with zero changes. Same buildpacks, same process types, same environment variable management. The migration is a DNS change and a git remote update.

Dokku is extremely lightweight. It runs comfortably on a 1GB RAM VPS. The plugin ecosystem covers the essentials: Postgres, MySQL, Redis, Let's Encrypt SSL, HTTP auth, and more. Each plugin installs with a single command.

The limitation is management interface. Dokku is CLI-only. There is no web dashboard. Deploying, scaling, viewing logs, and managing databases all happen through SSH commands. For a developer who lives in the terminal, this is fine. For anyone who wants a visual overview of their deployments, Coolify is the better self-hosted option.

Single-server architecture means no redundancy. Dokku does not natively support clustering, load balancing, or automatic failover across multiple servers. For a side project or early-stage SaaS, this is acceptable. For a product with paying customers who expect uptime guarantees, you need additional infrastructure around Dokku or a managed platform.

When to pick Dokku: You have existing Heroku apps, want to migrate with minimal changes, and are comfortable with CLI-only management on a VPS.

The real infrastructure cost for indie founders

Here is what a typical SaaS MVP actually costs to run on each platform (web service + Postgres + Redis + background worker):

• Heroku: $7 (Basic dyno) + $9 (Mini Postgres) + $15 (Mini Redis) + $7 (worker dyno) = $38/mo
• Railway: Usage-based, typically $8-15/mo for this workload
• Render: $7 (web) + $7 (Postgres) + $7 (Redis) + $7 (worker) = $28/mo
• Fly.io: Usage-based, typically $10-18/mo depending on regions
• Coolify on Hetzner: $5-10/mo (VPS cost only, all services included)
• DigitalOcean App Platform: $5 (web) + $7 (DB) + $5 (Redis) + $5 (worker) = $22/mo
• Dokku on VPS: $5-10/mo (VPS cost only)

The self-hosted options (Coolify, Dokku) are dramatically cheaper for multi-service deployments because you pay for the server, not per service. The managed platforms (Railway, Render, Fly.io) charge per service but handle all the infrastructure management.

Your choice depends on whether you value your time (managed platform) or your money (self-hosted). For a pre-revenue side project, self-hosting saves real dollars. For a product generating revenue, the managed platform frees up hours you can spend on features and growth.

When to stick with Heroku

Heroku still makes sense if:

• You have production apps on Heroku with complex add-on dependencies (Heroku Scheduler, Papertrail, New Relic) that would require migration
• Your team relies on Heroku Pipelines for staging and review apps in a mature CI/CD workflow
• You need Heroku's enterprise certifications (SOC 2, HIPAA compliance on Shield dynos)
• The Salesforce ecosystem integration matters for your business (Heroku Connect for Salesforce data sync)
• The switching cost exceeds the savings when you factor in engineering time for migration

Heroku's developer experience is still good. It is not the best anymore, but it works reliably. If your Heroku bill is $50/mo and a migration would take 8 hours of engineering time, the payback period is a year or more. Make sure the switch is worth it before committing.

Making the switch: practical tips

1. Start with a non-critical app. Deploy a side project or staging environment to the new platform first. Get comfortable with the deployment pipeline, logging, and monitoring before moving production.
2. Document your Heroku add-ons. List every add-on, its configuration, and its purpose. Find the equivalent on the new platform or a standalone service that replaces it.
3. Test database migration. Use pg_dump and pg_restore to migrate Postgres data. Test the full cycle on a copy before touching production. Verify that all constraints, indexes, and extensions are preserved.
4. Set up monitoring immediately. Deploy uptime monitoring (Uptime Robot, Better Uptime, or Uptime Kuma for self-hosted) before routing traffic to the new platform. Silent failures are the biggest risk during migration.
5. Use DNS-based cutover. Point your domain to the new platform via DNS. Keep Heroku running in parallel for 48 hours in case you need to roll back. DNS TTL of 300 seconds gives you a fast rollback path.