Heroku Is (Finally, Officially) Dead
9 min read
CloudDevOpsOpinion
“Set your heart upon your work, but never on its reward.”
Bhagavad Gita
“Set your heart upon your work, but never on its reward.”
Bhagavad Gita
Heroku, the platform that taught an entire generation of developers what deployment meant, is dead. Not dying. Not struggling. Dead.
I know what you're thinking: "But I can still visit heroku.com." You can. There's something there — a platform with the same name, the same purple branding, the same CLI. But that's not Heroku. That's Salesforce's enterprise PaaS wearing Heroku's corpse like a skinsuit.
The Heroku that mattered — the free-tier, git push heroku main, "holy shit my side project is live on the internet" Heroku — died on November 28, 2022. Today, we're finally acknowledging what we've all known for years: the funeral was three years ago, and nobody sent flowers.
If you learned to code between 2010 and 2020, Heroku was probably your first deployment. Not because it was the best option, but because it was the only option that didn't require understanding what a VPS was, how SSH worked, or why your NGINX config wasn't passing traffic to your app.
The magic was almost insultingly simple:
# This was it. This was the whole deployment process.
heroku create my-brilliant-app
git push heroku main
# Then you'd run this and feel like a wizard
heroku openThat was it. No Dockerfile. No Kubernetes manifests. No CI/CD pipeline. No infrastructure-as-code. You wrote code, you pushed it, and then it was on the internet, running on something called a "dyno" that you didn't need to understand.
For a generation of developers who came up building WordPress blogs and static HTML pages, this was transcendence. You could have an idea at 2am, code it by 4am, and show your friends a live URL by breakfast. The feedback loop from "I should build this" to "I built this and you can use it" collapsed from weeks to hours.
The free tier wasn't just a feature. It was Heroku's entire value proposition. It was how they became synonymous with deployment for an entire generation.
Here's the dirty secret that explains everything that happened after: Heroku's free tier was never sustainable, and everyone knew it.
The theory was a classic SaaS conversion funnel: developers start with free dynos, fall in love with the platform, then convert to paid plans when their side projects become real businesses. It's the same model that worked for GitHub, Atlassian, and dozens of others.
The problem: developers are cheap. And good at staying cheap.
Free tier users discovered every trick in the book. They'd ping their apps every 20 minutes to prevent dyno sleep. They'd run multiple free apps with an internal load balancer. They'd use the free Postgres tier with a cron job that periodically deleted old data to stay under the row limit. The community treated the free tier like a competitive sport.
// The legendary "keep my free dyno awake" pattern
// Thousands of developers ran some version of this
setInterval(() => {
fetch('https://my-free-app.herokuapp.com/health')
.catch(() => console.log('Dyno probably sleeping anyway'))
}, 20 * 60 * 1000)By 2022, Heroku's free tier was hemorrhaging money. The company cited "fraud and abuse" when they announced the shutdown, but that was corporate-speak for "our free tier users are costing us millions and not converting to paid plans."
Salesforce acquired Heroku in 2010 for $212 million. For twelve years, they let it run as a mostly independent unit, occasionally extracting integration value for their enterprise platform but largely leaving the developer experience alone.
Then came November 2022.
The announcement was brief: free dynos, free Heroku Postgres, and free Heroku Redis would be discontinued. Existing free-tier users had 30 days to migrate to paid plans or watch their apps die.
The community response was predictable: outrage, betrayal, and a mass exodus that made the Twitter-to-Mastodon migration look orderly.
Here's what the pricing looked like post-apocalypse:
| What you got for free | What it costs now |
|---|---|
| Free dyno (sleeps after 30 min) | $5/month ("Eco" tier, still sleeps) |
| Free Postgres (10,000 rows) | $5/month ("Mini" tier, same limits) |
| Free Redis (25 MB) | $3/month (same limits) |
That's $13/month minimum for what used to be free. For a hobbyist with five side projects, you're suddenly looking at $65/month to keep apps running that you might check once a quarter.
The math didn't work. The developers left.
Heroku still exists. It's even still being updated — Node.js 25 support, Claude integration for their AI initiatives, new dyno types. But look at who it's for now:
| Dyno Type | Memory | Price |
|---|---|---|
| Eco | 512 MB | $5/mo (shared hours) |
| Basic | 512 MB | $7/mo |
| Standard-1X | 512 MB | $25/mo |
| Standard-2X | 1 GB | $50/mo |
| Performance-M | 2.5 GB | $250/mo |
| Performance-L | 14 GB | $500/mo |
| Performance-XL | 62 GB | $750/mo |
This isn't a platform for indie hackers anymore. This is enterprise infrastructure priced for enterprise budgets. The message is clear: if you're not spending serious money, Heroku doesn't want you.
Salesforce made a calculated decision: the developer community that loved Heroku wasn't generating revenue proportional to the resources they consumed. So Salesforce chose to kill the community and keep the brand.
It worked, from a business perspective. Heroku still generates revenue. It still has enterprise customers who don't care about the free tier because their bills are paid by companies with actual budgets. But the thing that made Heroku Heroku — the democratic access to deployment, the "anyone can ship" ethos — that's gone.
The irony of killing Heroku's free tier is that it created a market opportunity that half a dozen competitors immediately filled. Within months of the November 2022 announcement, alternatives had absorbed most of Heroku's former user base:
Railway became the spiritual successor — same git push simplicity, usage-based pricing starting at $5/month, and a developer experience that explicitly borrowed from Heroku's playbook. They even built migration tools specifically targeting Heroku refugees.
Render went further, offering an actual free tier (the thing Heroku killed) along with a one-click "migrate from Heroku" button. It was almost comically on-the-nose.
Fly.io took the technical high ground, offering global edge deployment that Heroku never matched, with pay-as-you-go pricing that works out to $2-3/month for hobby projects.
Coolify and Dokku emerged as the self-hosted alternatives for developers who decided they'd rather manage their own infrastructure than pay anyone again. Both use Heroku-compatible buildpacks, meaning migration was often just changing the git remote.
# The migration pattern that played out thousands of times
git remote remove heroku
git remote add railway https://railway.app/your-app
git push railway main
# Same vibes, different platformThe developer community didn't just survive Heroku's death — it diversified. Instead of one dominant platform, there's now an ecosystem. Whether that's better or worse depends on your perspective, but it's definitely different.
The thing that nobody talks about is what was lost beyond the free tier itself.
Heroku wasn't just cheap hosting. It was a shared context. When you wrote a tutorial, you could say "deploy it to Heroku" and know that every reader could follow along. When you helped a junior developer, you could say "just push to Heroku" without qualifying it. When you built open source tools, you could include a "Deploy to Heroku" button knowing it would just work.
That shared context is gone now. A deployment tutorial in 2026 has to pick a platform — Railway, Render, Fly, Vercel, or self-hosted — and immediately alienate readers who use something else. The community fragmentation that followed Heroku's death made everything slightly harder.
There's also the question of who got left behind. The free tier wasn't just for hobbyists — it was for students, for bootcamp graduates building their portfolios, for developers in countries where $13/month is a significant expense, for anyone who wanted to experiment without financial commitment.
Those people didn't migrate to Railway. They just stopped deploying things.
Heroku (2007-2022) was preceded in death by the free API tier, the unlimited private repository, and the free SSL certificate. It is survived by its enterprise customers, its Salesforce integration, and a generation of developers who still type heroku logs --tail out of muscle memory before remembering their apps aren't there anymore.
The platform revolutionized deployment by making it invisible. Before Heroku, deployment was a skill. After Heroku, it was a command. That abstraction — the idea that infrastructure should disappear so developers can focus on code — became the foundation for every PaaS that followed.
Heroku taught us that the developer experience matters as much as the technology. It proved that simplicity wins, that constraints enable creativity, and that the best infrastructure is the kind you don't have to think about.
Then it got bought by Salesforce, and Salesforce did what Salesforce does: optimized for enterprise revenue at the expense of everything else.
Here's what Heroku's death actually teaches us: every free tier is a bet that you'll convert to paid, and when that bet stops paying off, the free tier dies.
This isn't unique to Heroku. It's the lifecycle of every developer tool that offers a generous free tier:
We've seen it with Heroku. We're watching it happen with others. The generous free tier you depend on today is always one quarterly earnings report away from extinction.
The only sustainable model is one where either you're paying, or you're the product. Heroku's free users were neither — they were just expensive to serve.
Pour one out for git push heroku main. It was never going to last forever, but for a decade, it made deployment feel like magic.
The magic is gone now. But at least we know what we're paying for.
Developers spent decades wishing for tools that write code. Now they have them. Why does freedom feel like loss?
Shadow IT on steroids, MCP tools nobody asked for, LLMs playing architect, vibe-coded open source, and text-to-SQL fantasies. The antipatterns everyone's falling into — and how to stop.
The era of prompting your way through codebases is hitting a wall. Comprehension debt — the hidden cost of code you ship but don't understand — is the new technical debt.