How our team thought through whether to run our own deployment platform or keep paying for someone else's. Pricing and feature details verified June 2026 — these change often, so we always recheck the vendor's pricing page before committing.
Why we wrote this
If we ship web apps, we eventually hit the same fork in the road. We can hand our infrastructure to a managed Platform-as-a-Service (PaaS) — Vercel, Heroku, Netlify, Railway — and pay a monthly bill that scales with usage. Or we can run an open-source, self-hostable PaaS like Coolify on a server we own and pay only for the hardware.
The managed platforms give us convenience: we push our code, and global infrastructure, scaling, SSL, and databases are handled. The self-hosted route gives us control and a flat, predictable cost — at the price of doing our own operations.
This post breaks down what each managed platform actually does, what it costs, and where it shines or stings. Then it does the same for Coolify, and finishes with a clear "what we can and cannot do" view of each side.
First, the two models in one paragraph
A managed PaaS abstracts the server away entirely. We never SSH into a machine; we push to Git and the platform builds, deploys, scales, and serves our app from its own infrastructure. We pay per seat, per usage, or both. A self-hosted PaaS like Coolify is a control panel we install on our own VPS or bare metal. It gives us the same git-push-to-deploy experience, automatic SSL, and a dashboard — but the servers, the uptime, the backups, and the security patching are ours to own. The software is free; the server is our only bill.
Vercel
What it is: The frontend platform of choice for Next.js and modern JavaScript frameworks. Vercel is built around serverless functions, a global edge network, and an exceptional developer experience.
What we can do with it:
- Push to Git and get automatic builds, preview URLs for every pull request, and instant production deploys.
- Serve from a global edge CDN with very low latency worldwide.
- Run serverless functions and edge middleware close to our users.
- Use Next.js-specific features like Incremental Static Regeneration (ISR), image optimization, and edge config.
- Automatic HTTPS/SSL and zero-config deployments.
Pricing (June 2026):
- Hobby — free, but non-commercial only. If our app earns money, Vercel requires an upgrade.
- Pro — $20 per user per month, with $20 of usage credit per seat and 1 TB of bandwidth included. A 5-person team pays $100/month in seats before any traffic.
- Enterprise — custom pricing, often starting in the five-figures-per-year range, with SSO, SLAs, and audit logs.
What to watch: Vercel's real cost is usage-based and can catch us off guard. Above the included tiers, we pay for Fast Data Transfer (~$0.15/GB), Edge Requests (~$2 per million), function execution, and image optimization. A growing SaaS app can run a few hundred dollars a month. On the free Hobby plan, hitting the limits takes the site offline until the next billing cycle rather than charging overages.
Best for: Frontend-heavy teams, Next.js apps, and anyone who values speed-to-ship and global performance over infrastructure control.
Heroku
What it is: The platform that popularized git-push deployment back in 2007. Now owned by Salesforce, it remains a polished, full-stack PaaS — but it's no longer cheap, and the free tier is gone.
What we can do with it:
- Deploy full-stack apps in nearly any language using "dynos" (its container units).
- Attach a large ecosystem of add-ons (Postgres, Redis, monitoring, etc.) with a few clicks.
- Scale horizontally by adding more dynos (on Standard tier and above).
- Tight Salesforce integration via Heroku Connect for teams in that ecosystem.
Pricing (June 2026) — no free tier:
- Eco — $5/month for 1,000 dyno hours shared across the account; dynos sleep after 30 minutes of inactivity. Good for hobby/non-production.
- Basic — $7/month per dyno, always-on, no sleep.
- Standard — $25–$50/month per dyno, with horizontal scaling, metrics, and preboot.
- Performance — $250–$500/month per dyno for high-traffic, dedicated workloads.
- Add-ons billed separately: Postgres, Redis, and others stack on top of dyno costs.
What to watch: Costs compound fast because dynos, databases, Redis, and add-ons are each billed independently. The filesystem is ephemeral (data is wiped on restart), which forces adoption of managed Postgres/Redis. Enterprise pricing is opaque and negotiated.
Best for: Teams that value a mature, battle-tested platform and simplicity over cost, especially those already in the Salesforce ecosystem.
Netlify
What it is: The Jamstack pioneer — built for static sites, frontend apps, and serverless functions, with Git-based CI/CD and a built-in CDN.
What we can do with it:
- Deploy static sites and frontend frameworks with Git-based continuous deployment.
- Get unlimited deploy previews, custom domains with SSL, and form handling out of the box.
- Run serverless functions and edge functions.
- Use a managed Postgres database and basic firewall rules even on the free tier.
Pricing (June 2026) — credit-based model:
- Free — $0, with 300 credits/month, 100 GB bandwidth, 300 build minutes, custom domains, and unlimited preview deploys. Genuinely usable for small sites.
- Personal — $9/month with 1,000 credits.
- Pro — $20/month flat with 3,000 credits and, as of April 2026, unlimited team seats (Netlify dropped per-seat pricing).
- Enterprise — custom pricing for compliance and advanced security.
What to watch: The credit model bundles bandwidth, build minutes, and function invocations into one allowance — flexible, but it takes a minute to reason about. Exceed credits and we auto-recharge (paid plans) or the site pauses (free plan). Complex backends aren't its strength.
Best for: Static sites, Jamstack apps, content-heavy frontends, and small teams that want a generous free tier and flat team pricing.
Railway
What it is: A modern, usage-based PaaS positioned as the cleaner, cheaper answer to Heroku's dyno model. Strong developer experience, native databases, and billing that tracks actual usage.
What we can do with it:
- Auto-detect our stack and deploy with near-zero config (Next.js, Django, Rails, Rust, and more).
- Spin up PostgreSQL, MySQL, MongoDB, or Redis with one click — billed as part of usage.
- Get preview environments per pull request, an environment-variables UI, logs, and metrics.
- Set hard monthly spend caps (Pro) so the bill can't run away.
Pricing (June 2026) — usage-based with included credits:
- Trial — no permanent free tier; a 30-day trial with $5 one-time credit, no card required.
- Hobby — $5/month, which includes $5 of usage credits (single-developer workspaces).
- Pro — $20/month, including $20 of credits, unlimited workspace seats, and spend limits.
- Enterprise — custom, with a ~$2,000/month minimum, plus compliance (HIPAA/SOC 2), dedicated infra, and BYOC.
What to watch: Usage-based billing rewards efficiency but trades predictability — a database-heavy app can exceed its credit allowance, so we'd keep an eye on the usage dashboard. Most real production apps land around $20–$50/month.
Best for: Developers and startups who want Heroku-like simplicity with modern, consumption-based pricing and don't mind monitoring usage.
Coolify — the self-hosted option
What it is: An open-source, self-hostable PaaS (Apache 2.0 license) that we install on any server with an SSH connection — a VPS, bare metal, a Raspberry Pi, even an old laptop. It hit a stable v4.0 in 2026, has 55,000+ GitHub stars, and is the most popular self-hosted PaaS available. The community has shifted from calling it a "Heroku alternative" to a "self-hosted Vercel."
What we can do with it:
- Git push to deploy from GitHub, GitLab, Bitbucket, or Gitea — including self-hosted Git.
- Automatic, auto-renewing SSL via Let's Encrypt for our custom domains.
- One-click deploy of 280+ services — databases (PostgreSQL, MySQL, MongoDB, Redis, ClickHouse), workflow tools (n8n), and more — plus anything that runs in Docker.
- Multi-server orchestration from a single dashboard.
- Preview deployments per branch — including the backend and per-branch databases, which Vercel itself can't do.
- Automatic database backups to any S3-compatible storage.
- A powerful API, a CLI, and a browser-based real-time terminal for managing servers without leaving the dashboard.
- Team collaboration with roles and permissions, monitoring, and notifications via Discord, Telegram, or email.
- No vendor lock-in — all settings live on our own server.
Pricing (June 2026):
- Self-hosted — free forever, all features included, no per-seat fees and no feature gates. We pay only for the server. A capable VPS (e.g., Hetzner, ~4 vCPU / 8 GB RAM) runs roughly $6–$25/month. Real-world reports describe dropping from ~$150/month on managed platforms to under $30/month.
- Coolify Cloud — $5/month for up to 2 connected servers (+$3/month per additional server), with a 20% annual discount. Important nuance: Cloud manages the Coolify control plane (the dashboard, updates, backups) — we still bring and pay for our own servers.
Where it falls short — the honest cons:
- No global edge network or CDN. Our app runs in one region unless we put Cloudflare (or similar) in front of it.
- No Incremental Static Regeneration and no edge-middleware runtime. If we rely on Vercel-specific edge features, we'd need to rewrite them.
- No true serverless "scale to zero." Coolify runs long-lived containers and has a minimum footprint (roughly 2 CPU / 2 GB RAM), so it's not a FaaS replacement. (For functions, we'd pair it with something like Supabase, Cloud Run, or Lambda.)
- No built-in observability. No analytics, error tracking, session replay, or uptime monitoring out of the box — a production-grade observability stack adds roughly $150+/month if we want it.
- We own the operations. Patching, uptime, scaling decisions, and security are on us. A single-server setup is a single point of failure; real production needs multi-server planning.
- Security and compliance are our responsibility. Coolify has had at least one CVE on record and is generally not a fit out-of-the-box for regulated SOC 2 / HIPAA workloads.
- There's a learning curve if our team is light on DevOps/Docker experience.
Best for: Technically capable teams like ours that want full infrastructure control, data sovereignty, predictable flat costs, and freedom from vendor lock-in — and have (or are willing to build) the DevOps bandwidth to run it.
Head-to-head at a glance
| Dimension | Vercel | Heroku | Netlify | Railway | Coolify |
|---|---|---|---|---|---|
| Model | Managed | Managed | Managed | Managed | Self-hosted |
| Primary strength | Frontend / Next.js | Full-stack, mature | Jamstack / static | Full-stack, usage-based | Full control, any Docker app |
| Free tier | Yes (non-commercial) | No | Yes (generous) | Trial only ($5) | Software free; pay for server |
| Entry paid price | $20/user/mo | $5/mo (Eco) | $9/mo (Personal) | $5/mo (Hobby) | ~$6–25/mo (VPS) |
| Pricing predictability | Usage can spike | Stacks fast | Credit-based | Usage-based | Flat / predictable |
| Global edge CDN | Yes | No (single region) | Yes | No (single region) | No (add Cloudflare) |
| Serverless functions | Yes | Limited | Yes | Via services | Not native (workarounds) |
| Scale to zero | Yes | Eco sleeps | Yes | Yes | No |
| Managed databases | Add-on | Add-on | Postgres included | One-click, native | We run them (or connect Neon, etc.) |
| Built-in observability | Yes | Add-ons | Some | Yes | No (add our own) |
| Backend / long-running jobs | Limited | Yes | Limited | Yes | Yes |
| Per-branch backend + DB previews | No | No | No | Partial | Yes |
| Data sovereignty / on-prem | No | No | No | BYOC (Enterprise) | Yes (fully) |
| Vendor lock-in | High | High | Medium | Medium | None |
| Ops burden on us | None | None | None | None | High |
What we CAN and CANNOT do: paid platforms vs. Coolify
With the paid platforms, we CAN:
- Ship globally with edge CDNs and serverless functions with effectively zero operations work.
- Auto-scale from zero to large traffic spikes without touching a server.
- Lean on managed databases with built-in backups and high availability.
- Get compliance certifications (SOC 2, HIPAA on higher tiers), DDoS protection, and SLAs.
- Use platform-specific magic — Vercel's ISR and edge middleware, Netlify's form handling, Heroku's add-on marketplace.
With the paid platforms, we CANNOT (easily):
- Predict the bill with certainty once usage scales — costs are tied to traffic, seats, and execution.
- Keep our data fully on our own infrastructure or on-premises (except Railway/others' enterprise BYOC).
- Escape vendor lock-in — platform-specific features mean migration has real switching costs.
- Run arbitrary long-lived or unusual workloads cheaply (serverless timeouts and per-resource billing get in the way).
With Coolify, we CAN:
- Run unlimited apps and databases on one server for a flat, predictable monthly cost.
- Deploy any Docker-compatible service, plus 280+ one-click templates.
- Keep 100% of our data on infrastructure we own — full sovereignty, no lock-in.
- Get git-push deploys, auto-SSL, multi-server management, and per-branch previews that include the backend and a database.
- Run long-lived processes (schedulers, bots, AI pipelines) that serverless timeouts would kill.
With Coolify, we CANNOT (without extra work):
- Serve from a global edge network or use true serverless scale-to-zero out of the box.
- Get built-in analytics, error tracking, or uptime monitoring (we assemble our own stack).
- Offload operations — uptime, patching, scaling, and security are our team's job.
- Treat it as turnkey for regulated SOC 2 / HIPAA workloads without significant hardening.
- Use Vercel-/Netlify-specific edge features without rewriting them.
So which should we choose?
There's no universal winner — it depends on what we're optimizing for.
- Vercel — when we live in the Next.js/frontend world and want the best developer experience and global performance, and we accept usage-based billing.
- Netlify — when we build Jamstack/static sites and want a genuinely generous free tier and flat team pricing.
- Heroku — when we want a mature, simple, full-stack platform and cost is secondary to reliability and the add-on ecosystem.
- Railway — when we want Heroku-style simplicity with modern, pay-for-what-we-use pricing and native databases.
- Coolify — when we have (or want to build) the DevOps capability, value control and data ownership, and want to convert a variable cloud bill into a flat, low server cost — which is exactly our case as we deploy our own services on our own infrastructure.
The honest summary: the managed platforms give us time and zero operations; Coolify gives us control and a low, predictable cost. The right answer is whichever of those two our team is shorter on.
Pricing and feature details reflect June 2026 and are subject to change. We verify current numbers on each vendor's pricing page before making a decision.
Top comments (0)