App Hosting Costs in 2026: Real Monthly Budgets by Traffic Tier

Hosting is the bill founders underestimate most. In 2026 you can run a real production app for $14 a month or accidentally spend $23,000 on a single DDoS weekend, and both outcomes are documented. This guide gives you the actual numbers across Vercel, Render, Fly.io, Railway, AWS, Heroku, and self-hosted PaaS so you can pick the right tier before you deploy, not after you see the invoice.

9 min read9 sectionsJune 20, 2026

Kostadin Stamboliev

Founder and Imaginator

LinkedIn

Founder and Imaginator at Pineido. Practitioner across IT consulting, app and web development, technical SEO, and AI / automation. Ships production code in 30-day sprints with fixed scope and clear ownership.

Why Hosting Cost Estimates Fail You

Most hosting cost guides quote the entry tier and stop there. That is the number that gets founders into trouble. The real cost has four components: compute, bandwidth, build minutes, and per-seat or per-team fees. Every major platform prices these differently, and the ratio shifts dramatically with traffic.

At 100K monthly visitors a Next.js app might push 50GB of bandwidth. At 1M visitors that same app pushes 500GB, and on some platforms that bandwidth bill alone exceeds the compute bill. Vercel's free tier caps bandwidth at 100GB per month total across all projects. Once you cross it, you are on Pro at $20/user/month plus overage.

Build minutes matter on CI-heavy teams. Vercel Pro includes 24,000 build minutes per month; a team running preview deploys on every PR branch can burn through that in two weeks.

The framing you need: separate the always-on floor (the minimum you pay with zero users), the variable ramp (what happens at 100K, 500K, and 1M monthly visitors), and the spike risk (what a bad weekend costs you). All three appear in the sections below.

Vercel: The Premium Developer Experience Tax

Vercel is the default choice for Next.js teams and it earns that reputation on developer experience. The cost structure is less forgiving.

Hobby tier is free but has no SLA and no team seats. Pro is $20/user/month, so a 3-person team pays $60/month before a single request is served. Add usage: bandwidth is $0.15/GB after the first 1TB included in Pro; Edge Function invocations run $2 per million after 1M free; ISR cache writes add up on content-heavy sites.

At 100K monthly visitors with a typical 400KB average page weight, you are transferring roughly 40GB. That fits inside Pro with room to spare. At 500K visitors you are at 200GB, well within the 1TB cap. At 1M visitors you are at 400GB, still under, but once you add API routes, image optimization (each image transformation counts), and Edge Middleware, real teams land at $150 to $300/month at that scale.

The documented risk: a documented DDoS attack against a Vercel-hosted app generated a $23,000 bill in a single weekend before spend alerts fired. Vercel now has spend protection controls, but they require you to configure them proactively. If you are on Vercel without a spend cap set, go set one now.

Decision rule: Vercel makes sense when your team is Next.js-first, you want zero DevOps overhead, and your traffic is predictable. It gets expensive faster than alternatives once you add team members or hit image-heavy content.

Render, Fly.io, and Railway: The Mid-Tier Sweet Spot

These three platforms occupy the same competitive space: managed containers with a real git-push workflow, no AWS surface area to configure, and pricing that does not punish small teams.

Render uses fixed instance pricing. A starter web service is $7/month, a standard instance is $25/month, and a pro instance is $85/month. Static sites are free. Postgres starts at $7/month for 1GB. For a typical full-stack app (web service plus Postgres), you are at $14 to $32/month depending on your memory needs. Render does not charge per team seat at the Team plan level for basic access. That $800-to-$40 migration story is real: one documented case moved a Vercel Pro team from $800/month (8 users plus heavy usage) to $40/month on two Render standard instances plus managed Postgres.

Fly.io is pay-per-resource with a $5/month minimum on any active app. A single shared-CPU-1x machine with 256MB RAM is $1.94/month, but you will want at least 512MB in practice. A 2-machine HA setup (for zero-downtime deploys) with 1GB RAM runs around $15 to $25/month. Bandwidth is $0.02/GB after the free tier. Fly is the best fit when you need full container control or want to run non-Node workloads close to users across regions.

Railway starts at $5/month with usage-based billing on top. DigitalOcean App Platform starts at $5/month per container. Both are suitable for single-developer projects and small teams where Vercel's per-seat pricing becomes the dominant cost.

Heroku in 2026: Maintenance Mode and What That Means

Heroku killed its free tier in 2022 and has been in what Salesforce describes informally as a maintenance phase since. No major new features have shipped in 18 months. The platform still works reliably, but pricing no longer reflects the market.

Heroku Eco dynos are $5/month each with 512MB RAM. They sleep after 30 minutes of inactivity, making them useless for production APIs unless you use a keepalive pinger. Basic dynos at $7/month stay always-on, making the realistic always-on floor $12 to $16/month for a minimal app (one Basic dyno plus a Postgres Mini at $5/month).

The scale problem becomes obvious fast. A Standard-2X dyno (1GB RAM, 2x CPU share) is $50/month. A Performance-M dyno (2.5GB RAM, dedicated CPU) is $250/month. Compare that to a VPS: a Hetzner CX31 (8GB RAM, 2 vCPU) is $8 to $12/month in 2026. A DigitalOcean Droplet at 4GB/2vCPU is $24/month.

The 5-app comparison: running 5 small Node.js apps on Heroku Eco costs $30/month (5 x $5 Eco plus shared Postgres). Running the same 5 apps on Coolify self-hosted on a single $14/month Hetzner VPS costs $14/month total, with git-push deploys and automatic SSL. The only trade-off is that you spend 2 to 3 hours setting up Coolify once.

Decision rule: Heroku makes sense only if your team's time cost of DevOps exceeds the premium, or if you are locked in by vendor tooling. For greenfield projects in 2026, the cost math no longer supports Heroku.

AWS Serverless: Powerful and Unpredictable

AWS Lambda plus API Gateway is the only hosting option where your bill is genuinely proportional to usage from zero, with no idle cost. That sounds ideal. The reality is more complicated.

At very low traffic (under 1M requests/month), Lambda is nearly free, often under $5/month. At 10M requests/month with 256MB functions averaging 200ms, you are at roughly $20 to $40/month for compute, plus API Gateway at $3.50 per million requests. That adds up to $38 to $75/month for a busy API at that scale, which is competitive.

The unpredictability problem is amplified at scale. Cold starts on Node.js Lambda functions run 200ms to 800ms without provisioned concurrency. Provisioned concurrency costs $0.015 per GB-hour, so provisioning 5 instances at 512MB for 24 hours costs $0.90/day or $27/month just to eliminate cold starts. Add CloudFront ($0.085/GB in US), RDS Proxy (mandatory for Aurora Serverless, $0.015/hr or $11/month), and log ingestion to CloudWatch ($0.50/GB), and the per-service overhead grows fast.

The real AWS risk is not the compute bill but the combination of services. A production Next.js app on AWS typically touches Lambda, API Gateway, CloudFront, S3, RDS or Aurora, Secrets Manager, and CloudWatch. Each has its own pricing model. Teams without AWS billing alerts have walked into $500 to $2,000 monthly bills they did not anticipate.

Decision rule: AWS serverless is the right call when you need fine-grained scaling, already have AWS expertise on the team, and are willing to build the billing guardrails. For teams under 5 engineers, managed PaaS nearly always has a better cost-to-complexity ratio.

Self-Hosted PaaS: Dokku, Coolify, and CapRover

Self-hosted PaaS solves the core tradeoff: you get the git-push deployment workflow of Heroku without the Heroku price tag. You pay for the VPS and spend an afternoon on setup.

Dokku is the original self-hosted Heroku replacement. It runs on a single Linux server, supports Heroku buildpacks, and handles multiple apps, SSL via Let's Encrypt, and environment variables through a CLI that mirrors Heroku's commands. A developer moving from Heroku to Dokku on a $14/month Hetzner VPS keeps the same git push dokku main workflow and immediately cuts monthly spend.

Coolify is the modern successor. It runs as a Docker-based control plane, supports Nixpacks and Dockerfiles, includes a web UI, handles databases and services (Postgres, Redis, MySQL), and sends deployment notifications. It is actively developed and the recommended default in 2026 for teams that want visual deployment management without a SaaS fee.

CapRover occupies a middle position, stronger multi-server clustering support than Dokku but lighter than a full Kubernetes setup. Good fit for teams running 10 or more services that need to spread across 2 to 3 VPS instances.

Bandwidth optimization matters on self-hosted setups. Run a CDN (Cloudflare free tier) in front of your VPS to offload static assets and absorb traffic spikes. Without a CDN, a 1M-visitor month could push 500GB through your VPS, triggering overage charges from your provider. With Cloudflare, 80 to 90 percent of that bandwidth is served from Cloudflare's edge for free.

Decision rule: if you have one developer who can run a Linux server, self-hosted PaaS is the most cost-efficient option at every traffic tier below 5M monthly visitors.

Cost Curves at 100K, 500K, and 1M Monthly Visitors

Abstract pricing is hard to reason about. Here are concrete monthly totals assuming a typical full-stack app: server-side rendering, a Node.js API, Postgres, and standard image assets (400KB average page weight).

100K monthly visitors (40GB bandwidth, 3M API requests):

  • Vercel Pro (1 user): $20 compute + minimal usage = $25 to $35/month
  • Render Standard + Postgres Starter: $25 + $7 = $32/month
  • Fly.io 2x shared-CPU-2x + Fly Postgres: $20 + $15 = $35/month
  • Railway Starter plan: $20 to $30/month usage-based
  • AWS Lambda + RDS t3.micro: $15 + $25 = $40/month
  • Coolify on Hetzner CX21: $14/month total

500K monthly visitors (200GB bandwidth, 15M API requests):

  • Vercel Pro (3 users): $60 + usage $30 = $90 to $120/month
  • Render Standard 2x + Postgres Basic: $50 + $20 = $70/month
  • Fly.io 2x performance-2x + Postgres: $60 + $30 = $90/month
  • AWS Lambda + RDS t3.small: $60 + $50 = $110/month
  • Coolify on Hetzner CX41: $30/month total

1M monthly visitors (400GB bandwidth, 30M API requests):

  • Vercel Pro (5 users): $100 + usage $80 = $180 to $280/month
  • Render Pro instances + Postgres Standard: $170 + $90 = $260/month
  • Fly.io 4x performance + Postgres HA: $200 + $60 = $260/month
  • AWS Lambda + RDS t3.medium + CloudFront: $150 + $80 = $230/month
  • Coolify on Hetzner AX41 (dedicated): $60/month total

The self-hosted gap widens with scale. At 1M visitors, Coolify on a $60/month dedicated server costs 4x less than any managed option.

Bandwidth Optimization and Team-Size Multipliers

Bandwidth is the cost that scales with users, so reducing it pays compound dividends. Three optimizations make a measurable difference.

First, serve all static assets (JS bundles, CSS, images, fonts) through a CDN. Cloudflare's free tier handles this for most apps. Cloudflare R2 costs $0.015/GB stored plus zero egress fees, making it materially cheaper than S3 ($0.023/GB stored, $0.09/GB egress) for apps with heavy image traffic.

Second, enable Brotli compression on your API responses. Brotli reduces JSON payload size by 20 to 30 percent compared to gzip. On an app serving 10M API responses per month at 2KB average, that is 40 to 60GB of bandwidth savings per month.

Third, use aggressive cache headers for immutable assets. A content-hashed bundle file with Cache-Control: immutable, max-age=31536000 will not consume bandwidth on repeat visitors. An app with 40 percent returning visitors can cut effective bandwidth by 20 to 30 percent through proper caching alone.

Team size multipliers apply on Vercel specifically. Vercel Pro charges per seat. A 5-person team pays $100/month in seat costs before any usage. A 10-person team pays $200/month. On Render, Railway, and Fly.io, team access does not multiply the base cost at the same rate. This makes Vercel's per-seat model increasingly expensive as teams grow, and is the primary driver behind documented migrations to Render.

For freelancers and solo founders: Fly.io and Render both allow multiple projects on a single account without seat multipliers, making them the cost-efficient default.

Get operations insights weekly

Join service-business operators who get one actionable insight on ops, automation, and growth every week.

Checking that you're human. You can send in a moment.

No spam. Unsubscribe anytime.

You’re subscribed! Look for our next issue in your inbox.

How Pineido Scopes Hosting in a 30-Day Sprint

When Pineido scopes a fixed-price build, hosting selection is part of the architecture decision, not an afterthought. For most early-stage apps under 500K monthly visitors, the default recommendation is Render or Fly.io: predictable billing, no per-seat penalty, and enough operational headroom to hand off without a DevOps hire. For teams with existing AWS infrastructure, the sprint includes Lambda setup with spend caps and CloudWatch billing alerts configured from day one.

Self-hosted PaaS (Coolify on a client-owned VPS) is the recommendation when the client has more than 3 apps to run, is cost-sensitive past launch, and has someone internal who can own the server. Pineido does the initial Coolify setup and CI pipeline as part of scope.

Hosting cost is always documented in the project handoff as a 12-month projection at three traffic scenarios: current baseline, 5x growth, and 20x growth. If you are evaluating what a custom app build and its hosting costs in 2026, the App and Web Development sprint is the right starting point.

Frequently asked questions

What is the cheapest way to host a production app in 2026?

The cheapest production-ready option is Coolify on a Hetzner CX21 VPS at $4 to $7/month, giving you a git-push deployment workflow, automatic SSL, and managed Postgres on the same machine. Total cost for a small full-stack app is $14/month or less. If you need a managed platform with zero server access, Render at $7/month per web service plus $7/month Postgres is the next most affordable option with real SLA guarantees.

Does Vercel get expensive at high traffic?

Yes, in two ways. First, the per-seat Pro cost ($20/user/month) dominates for teams of 5 or more. Second, Vercel's usage-based fees for Edge Functions, image optimization, and ISR writes compound at scale. At 1M monthly visitors with a multi-person team, expect $180 to $300/month. The documented $23K DDoS bill happened because spend protection was not configured. Always set a spend cap in Vercel's billing dashboard before going live.

What are the best Heroku alternatives in 2026?

For a managed experience: Render ($7 to $85/month per service, no sleep on paid tiers), Fly.io (pay-per-resource from $5/month), and Railway ($5/month plus usage). For a self-hosted Heroku replacement with the same git-push workflow: Coolify is the current best option, actively maintained with a clean web UI. Dokku is the classic CLI-based alternative. Both run on any VPS and cost only the server fee, typically $7 to $30/month depending on your resource needs.

Is AWS cheaper than Vercel for a Node.js app?

At low traffic (under 100K monthly visitors), AWS Lambda can be marginally cheaper than Vercel Pro if you have one user. At 500K to 1M visitors, AWS Lambda plus RDS runs $100 to $230/month, comparable to Vercel. The real difference is complexity: AWS requires configuring IAM, VPCs, billing alerts, and multiple service integrations. Vercel has zero AWS surface area. For teams without AWS experience, the hidden cost is the engineering time spent on configuration and incident response.

Should I use Render or Fly.io for my app?

Use Render if you want predictable fixed-instance billing and a simple setup for standard web services and Postgres. Use Fly.io if you need multi-region deployment, full container control, or are running non-standard workloads (Go, Rust, Python workers). Render is easier to onboard; Fly.io gives more control at the cost of a slightly steeper CLI learning curve. Both are competitive on price at the $15 to $50/month range for a typical full-stack app.

Is self-hosting with Dokku or Coolify worth it in 2026?

Yes, if you have at least two or three apps to run and one person who can maintain a Linux server. The savings are significant: 5 Node apps on Heroku Eco cost $30/month; the same 5 apps on Coolify running on a $14/month Hetzner VPS cost $14/month total. The setup investment is 2 to 4 hours once. After that, deployments are `git push` identical to Heroku. Add Cloudflare in front for DDoS protection and CDN at no extra cost.

Ready to ship?

Tell us where you are stuck. We will review it and send a focused recommendation within one business day.