✍️ 필사 모드: PaaS Comparison 2026 — Vercel · Netlify · Render · Fly.io · Railway · Northflank · Heroku · Cloud Run · App Runner · Coolify: Where to Deploy in 2026

• Prologue — Who Moved In When Heroku Moved Out
• 1. What Counts as a PaaS — Drawing the Boundary
  • 1.1 The Five Axes of a PaaS
• 2. Vercel — The Home of Next.js, and v0 Too
  • 2.1 Deploying Next.js + Postgres + Redis on Vercel
  • 2.2 Where Vercel Fits
• 3. Netlify — The Older Sibling Who Survived
• 4. Render — "Miss Heroku? We Are Heroku"
  • 4.1 Deploying Next.js + Postgres + Redis + Worker on Render
• 5. Fly.io — Docker-First, Global-First
  • 5.1 Fly's Real Strength — Multi-Region Trivial
• 6. Railway — Per-Minute Resources, Beautiful UX
  • 6.1 The Railway Appeal — Code-Free Infrastructure
• 7. Northflank — Multi-Cloud, Serious Teams' PaaS
• 8. Heroku — Rumors of Its Death Were Exaggerated
• 9. Cloud Run — GCP's Hidden Champion
  • 9.1 Deploying Next.js on Cloud Run
• 10. AWS App Runner / ECS Fargate — The AWS Exit
• 11. Coolify · Dokku — "PaaS Pricing Is Insane, I'll Host It"
• 12. The Cost Matrix — A Real Bill for a $5k/mo SaaS
• 13. The Truth About Cold Starts
• 14. The Dusk and Revival of Persistent Disks
• 15. The Reality of Background Workers
• 16. Multi-Region — The Reality for Global SaaS
• 17. The Decision Framework — Which PaaS Should You Pick
• 18. Anti-Patterns Collection
• Epilogue — Look at the Workload, Not the Tool
  • PaaS Choice Checklist
  • Next Article Teaser
• References

Prologue — Who Moved In When Heroku Moved Out

In 2022, Salesforce killed Heroku's free tier. That day, a generation of indie hackers screamed in unison on Twitter. "Heroku is dead. Where do we deploy now?" Out of that scream came four years of PaaS golden age, and by spring 2026 the landscape has finally taken shape.

Let's clear a myth first. Heroku is not dead. Salesforce killed the free tier and reorganized pricing — but as of 2026 Heroku is alive, supports the Heroku-24 stack, and runs Postgres 17. What it lost was the "default" slot. New projects no longer default to Heroku.

The empty slot has too many candidates. Vercel has become the de facto home of Next.js, absorbing v0 and the ai-sdk along the way, inventing the category "framework-first PaaS". Render has shouted "miss Heroku? we are Heroku" as a slogan and bundled persistent disks, cron, background workers, and Postgres in one place. Fly.io turned multi-region deploys into a trivial concern with its Docker-first global PaaS. Railway captured a new generation with per-minute resource billing and beautiful UX. Northflank caught serious teams' eye with multi-cloud / BYOC and richer primitives — Job, Cron, Volume, Build Pipeline. Netlify is Vercel's older sibling that lost the throne but survived by leaning into JS framework hosting.

There are dark horses cloud people love. Cloud Run — GCP's serverless container — destroys other PaaS on price for certain workloads with 100ms billing and scale-to-zero. AWS App Runner and ECS Fargate are the AWS-exit for teams that already live inside AWS. Coolify and Dokku are for the "PaaS pricing is insane, I'll host it myself" crowd.

This article compares these PaaS head-to-head on the same axes. After the comparison we ask the actual question — which tool for which scenario — across four cases: deploying a Next.js app, API + Postgres + Redis + worker stack, a global multi-region SaaS, and a $5k/mo full-stack app. Prices move fast. Every number is May 2026, and we focus on the structural differences. The decision framework must outlive the numbers.

Even within the same PaaS category, different billing models and runtime models can stretch a month's bill 10x. And the cost of leaving is 10x the cost of joining.

1. What Counts as a PaaS — Drawing the Boundary

To use the word "PaaS" in 2026 we need to draw the line first. The narrow definition — Platform as a Service — is what Heroku defined. One git push heroku main and the code is built, deployed, and a domain is attached. Infrastructure is invisible. Databases, caches, and queues are add-ons added with one line.

By that definition, Vercel · Netlify · Render · Fly.io · Railway · Northflank · Heroku · Coolify · Dokku are all PaaS. Push code, get a deploy.

There are borderline tools. Cloud Run is a serverless container platform — push a container and it autoscales. It sits one abstraction below the narrow PaaS — you bring Postgres and your build pipeline yourself — but in practice people use it like a PaaS. AWS App Runner sits in the same bucket. ECS Fargate and Kubernetes sit even lower — CaaS, Container as a Service, or IaaS.

This article covers the narrow PaaS plus Cloud Run and App Runner. ECS Fargate and EKS make cameo appearances in the comparison table but aren't main characters.

1.1 The Five Axes of a PaaS

If we don't compare on the same axes it isn't a comparison. Five axes first.

• Build model — Buildpack? Dockerfile? Framework auto-detect? Nixpacks?
• Runtime model — Always-on server? Scale-to-zero? Per-request instance?
• Persistence — Persistent disk? Postgres? Redis? Object Storage?
• Billing — Instance hours? CPU seconds? Request count? Bandwidth? Free tier?
• Operations — Logs? Metrics? Secrets? Preview environments? Rollback? Multi-region?

A one-line summary of each PaaS on these axes:

A pattern emerges already. Vercel · Netlify · Cloud Run are "scale-to-zero, no persistent disk", while Render · Fly.io · Railway · Northflank · Heroku are "always-on, persistent disk". That one line determines every price calculation and workload fit downstream.

2. Vercel — The Home of Next.js, and v0 Too

Vercel is the loudest PaaS in 2026. It's the de facto home of Next.js, the home of ai-sdk, the home of v0 — the AI that builds UI — and inventor of the AI Gateway category.

The good. If you use Next.js, you barely need to consider other options. One git push builds and deploys, every PR gets an auto preview environment, edge deploys are automatic, and image optimization and analytics come bundled. For a solo developer, "just deploy" is the Vercel definition.

The problem. Pricing. In late 2024 Vercel overhauled its billing model. The old "function invocation count + GB-Hr + bandwidth" became Active CPU. Active CPU bills only the time the CPU actually worked — waiting on an external API or DB I/O doesn't count. In theory, cheaper.

In practice. The pricing-page numbers — Active CPU $0.128 per hour, Provisioned Memory $0.0106 per GB-Hr, Edge Requests $2 per million — look reasonable. But the bill inflates fast as traffic grows. Especially Next.js apps drawing big pages through Server Components, where per-page Active CPU stretches.

What does a $5k/month SaaS spend on Vercel? Community reports — Reddit r/nextjs, the SaaS builders on Twitter — average somewhere between $150–$600 per month at the 10k–50k MAU traffic band. Above that, Pro at $20/seat plus usage overage stacks fast.

The real trap with Vercel is the absence of persistence. Postgres on Vercel is Vercel Postgres — actually a Neon OEM — and Redis is Vercel KV — actually an Upstash OEM. Both are extra cost and inflate separately with traffic. If you close everything inside Vercel and operate, you end up paying more than going to Neon and Upstash directly.

2.1 Deploying Next.js + Postgres + Redis on Vercel

Simplest workflow:

# 1. Create a Next.js app locally
npx create-next-app@latest my-saas

# 2. Link to Vercel
cd my-saas
vercel link

# 3. Add Vercel Postgres (= Neon) and Vercel KV (= Upstash)
vercel storage create postgres
vercel storage create kv

# 4. Pull env vars locally
vercel env pull .env.local

# 5. Push and you're done
git push

vercel.json is barely needed. Preview environments, domains, HTTPS, image optimization are automatic. Background worker? Vercel Cron, the beta Vercel Queues, or an external queue — Inngest, Trigger.dev. There is no way to run an always-on worker inside Vercel.

2.2 Where Vercel Fits

Vercel is optimal for Next.js · React Router · SvelteKit · Astro — apps whose framework build is standardized. SSG-centric sites — company blogs, marketing, docs — fit the free tier easily. AI interfaces — chat, code assistants, content generation — get a shorter workflow with ai-sdk and AI Gateway.

In contrast, always-on Express/Fastify servers, monoliths where Postgres + Redis + workers live in one box, WebSocket-heavy real-time apps, and gRPC are not a Vercel fit. You can force them in, but pricing and operations both suffer.

3. Netlify — The Older Sibling Who Survived

Netlify started before Vercel. Founded 2014, coined the word "JAMstack". Until Vercel started in 2017 and overtook by riding Next.js, Netlify held that throne.

In 2026 Netlify holds the younger-sibling seat. Next.js's primary residence moved to Vercel, and Netlify's pricing model has followed similar lines. Two reasons Netlify still matters.

First, better neutrality across frameworks. Astro, Remix, SvelteKit, Hugo, Eleventy, Gatsby — all run well on Netlify. Vercel supports other frameworks too, but with the air of "Next.js is first-class, everything else is second". Netlify has less of that air.

Second, stable build infrastructure. Netlify's build system is mature and deep. For big monorepo SSG builds, Netlify still has the edge in stability — many reports back this up.

Pricing largely parallels Vercel. Free tier — 100GB bandwidth, 300 build minutes — and Pro at $19/month/seat. Function invocations and Edge Functions bill similarly. Netlify Blobs — Object Storage — and Netlify Forms — form submission handling — are small differentiators Vercel lacks.

The problem is the same. No persistent disk, weak worker story, Postgres and Redis live elsewhere. Netlify Postgres is in beta in 2026 but as a Neon OEM it sits in the same seat as Vercel Postgres.

When to pick Netlify. Non-Next.js SSG/SSR sites, monorepo SSG builds, sites already running well on Netlify where migration cost is not worth it. For a new Next.js project there's not much reason to pick Netlify.

4. Render — "Miss Heroku? We Are Heroku"

Render arrived in 2019, explicitly positioning itself as "Heroku's successor". After Heroku's 2022 free-tier death, the biggest beneficiary was Render.

Why the slogan lands. What Heroku did well — Postgres, Redis, background workers, cron, persistent disk, simple pricing — Render offers in one place. One render.yaml declares web service + worker + cron + Postgres + Redis and it just runs.

The 2026 pricing model is simple. Web Service · Background Worker · Private Service bill on instance hours. Starter $7/month, Standard $25/month, Pro $85/month are the base lines. Postgres starts at Starter $7/month (256MB RAM, 1GB storage) and Standard $20/month. Redis has a similar line. Persistent Disk is $0.25 per GB-month. Cron Jobs are free — billed only for execution time.

Estimating the Render bill for a $5k/month SaaS: one Web Service ($25) + one Worker ($25) + Postgres Standard ($20) + Redis Starter ($10) + 10GB disk ($2.5) = $82.5/month. The same workload on Vercel + Neon + Upstash typically lands at $150–$300. Render is just cheaper.

The traps with Render. First, it's not a cold start but "sleep" — only on the free tier. Free instances go to sleep after 15 minutes of inactivity and take 20–30 seconds to wake on the next request. Paid tiers are always-on. Second, global multi-region deployment is weak. Render lets you pick a region — Oregon, Ohio, Virginia, Frankfurt, Singapore — but deploying the same service across multiple regions simultaneously is a relatively recent feature and not as smooth as Fly.io.

4.1 Deploying Next.js + Postgres + Redis + Worker on Render

# render.yaml
services:
  - type: web
    name: app
    runtime: node
    buildCommand: pnpm install && pnpm build
    startCommand: pnpm start
    envVars:
      - key: DATABASE_URL
        fromDatabase:
          name: app-db
          property: connectionString
      - key: REDIS_URL
        fromService:
          type: redis
          name: app-redis
          property: connectionString
  - type: worker
    name: worker
    runtime: node
    buildCommand: pnpm install && pnpm build:worker
    startCommand: pnpm start:worker
  - type: redis
    name: app-redis
    ipAllowList: []
    plan: starter

databases:
  - name: app-db
    plan: starter
    region: oregon

Push this file and you're done. It feels like Vercel minimalism plus Heroku's full-stack story combined.

5. Fly.io — Docker-First, Global-First

Fly.io starts differently from other PaaS. From day one, Docker and multi-region were first-class citizens. By 2026 Fly's user experience has been rebuilt twice — first as Nomad-based Apps v1, then as Firecracker-MicroVM-based Machines / Apps v2.

The essence of Fly Machines. A Fly Machine is one Firecracker MicroVM — KVM's lightweight VM, the same tech AWS Lambda uses. Boot time around 250ms, stop/resume — fly machine stop / start — is built in, and one app can hold multiple Machines across multiple regions. Pricing is CPU/memory-hours per Machine, but a stopped Machine costs near-zero (only storage).

Fly Postgres and Volumes. Fly doesn't operate managed Postgres directly anymore — actually, in 2024 it ended the managed offering — and now leans on Supabase Postgres on Fly or running a Postgres MicroVM yourself. Volumes — persistent disks — are alive and mount directly to a Machine.

One fly.toml is enough.

# fly.toml
app = "my-saas"
primary_region = "nrt"

[build]
  dockerfile = "Dockerfile"

[env]
  PORT = "8080"

[[services]]
  internal_port = 8080
  protocol = "tcp"
  auto_stop_machines = true
  auto_start_machines = true
  min_machines_running = 1

  [[services.ports]]
    handlers = ["http"]
    port = 80

  [[services.ports]]
    handlers = ["tls", "http"]
    port = 443

[mounts]
  source = "data"
  destination = "/app/data"

One fly deploy and you're done. Multi-region? fly scale count 1 --region nrt,sin,fra — one line.

Fly pricing. The smallest Machine — shared-cpu-1x · 256MB — runs under $2/month. Typical workloads — shared-cpu-2x · 1GB — run $5–$10/month. Bandwidth is $0.02 per GB in NA/EU. A $5k/month SaaS often comes in similar to or slightly cheaper than Render — though you do more operational work yourself (Postgres backups, Redis HA).

Fly's traps. First, operational burden is higher. Things Render does automatically — Postgres backups, monitoring, alarms — you write yourself on Fly. Second, local debugging is harder. Firecracker MicroVM means SSH-style entry is fly ssh console, and accidentally nuking a Volume is hard to undo.

5.1 Fly's Real Strength — Multi-Region Trivial

Deploying one app to Tokyo, Singapore, and Frankfurt simultaneously is a project on other PaaS — Render added it only recently, Vercel only at the edge, Cloud Run requires per-region deploys. On Fly it's one line. If you need to keep global SaaS latency under 50ms, Fly does that with the least friction.

6. Railway — Per-Minute Resources, Beautiful UX

Railway started in 2020. It belonged to the "miss Heroku? we do too" camp from day one, and by 2026 it has the most beautiful UX of any PaaS. Just looking at the dashboard you feel the difference.

Railway's differentiators. First, per-minute resource billing. Similar to Vercel's Active CPU, but Railway applies it uniformly to Web services too. CPU at roughly $0.000463 per minute, Memory at $0.000231 per GB-minute. When a service idles — no traffic — billing drops to near-zero. Note: Railway does not fully scale to zero — instances stay alive.

Second, Hobby Plan vs Pro Plan. Hobby at $5/month base — includes $5 of resource credits. Pro at $20/month base + team collaboration + larger instances. Solo developers often start fine on Hobby.

Third, Postgres, Redis, MySQL, MongoDB in one click. Database instances also bill on resources, so small DBs land at $3–$5/month.

The Railway bill for a $5k/month SaaS. Depends on traffic pattern, but a light SaaS — Web + Worker + Postgres + Redis — often lands at $30–$80/month. A heavy SaaS — large Postgres, always-on worker — at $150–$300. Similar to Render, sometimes a hair cheaper.

Railway's traps. First, per-minute billing gets expensive on heavy workloads. For always-on big instances, Render's flat instance-hours pricing is more predictable. Second, backups and multi-region are weaker — even more so than Render. Third, no real free tier — the $5 base is a barrier to entry.

6.1 The Railway Appeal — Code-Free Infrastructure

Railway's real appeal is the dashboard. Add Postgres, add Redis, share env vars, private networking, domains — all a few clicks. No render.yaml or fly.toml to write. For a solo developer this is a real difference.

# Railway CLI alone is enough
npm i -g @railway/cli
railway login
railway init my-saas
railway add postgresql
railway add redis
railway up

7. Northflank — Multi-Cloud, Serious Teams' PaaS

Northflank started in London in 2020. It aimed for one level of abstraction above other PaaS. In short, "a PaaS as powerful as Kubernetes".

Northflank's differentiators. First, multi-cloud / BYOC. You can run Northflank inside your own AWS · GCP · Azure account. The choice for teams with data sovereignty needs or existing cloud credit balances. Second, first-class Jobs and Cron. A richer scheduler than Render's Cron. Third, Build Pipelines. Run Docker builds inside Northflank and auto-deploy outputs to other Northflank services.

Pricing parallels Render. Small instances $5–$10/month, standard $25–$50/month. Postgres · Redis · MySQL · MongoDB are also offered as managed.

Northflank's traps. First, the steepest learning curve among PaaS. The UI is powerful and that means complex. Second, smaller community — fewer users than Render, Fly, Railway means fewer search results. Third, overkill as a solo developer's first pick — usually a serious team's second PaaS.

When to pick Northflank. Deploying inside your own cloud account, controlling location for data sovereignty — GDPR, Korea's PIPA, healthcare/finance regulation, needing more control than a PaaS without going all the way to Kubernetes.

8. Heroku — Rumors of Its Death Were Exaggerated

Heroku started in 2007, was acquired by Salesforce in 2010, and killed its free tier in 2022 — making many enemies. But it didn't die. As of 2026, Heroku is alive, with the Heroku-24 stack (Ubuntu 24.04 LTS base), Postgres 17, PCI / HIPAA compliance, and Salesforce integrations — an enterprise PaaS.

Why Heroku is still alive. First, too many apps already run well on Heroku. The cost for a big company to leave a Heroku monolith they've run for 5–10 years is 10x the cost of staying. Second, Salesforce ecosystem integration. Bidirectional sync with SFDC via Heroku Connect is uniquely a Heroku capability. Third, Eco · Basic Dyno partly restore the free-tier seat — Eco Dyno $5/month with 1,000 hours and sleep allowed, Basic Dyno $7/month always-on.

Pricing. Eco $5, Basic $7, Standard-1X $25, Standard-2X $50, Performance-M $250. Postgres Mini $5, Basic $9, Standard-0 $50, Standard-2 $200. Redis Mini $3, Premium from $15. The same workload on Render · Railway · Fly is usually 20–40% cheaper.

Reason to pick Heroku for a new project. One reason — Salesforce integration. Beyond that, a new project has weak reason to choose Heroku.

9. Cloud Run — GCP's Hidden Champion

Cloud Run often goes missing from PaaS comparison articles. The reason is simple — GCP's console UX is more complex than other PaaS, and only people who burned through GCP's free credits look at the real bill. But many who do become Cloud Run fans.

The essence of Cloud Run. Push a container and it autoscales per request. No requests, scale to zero. Requests come in, wakes up within 100ms. The concurrent requests one instance can handle — concurrency — is your choice, default 80.

Why pricing is insane. 100ms billing increments + scale-to-zero + first 240,000 vCPU-seconds and 450,000 GiB-seconds free per month. A small SaaS — $5k/month revenue, 10k–50k MAU traffic — often lands at $5–$50/month on Cloud Run. The same workload on Vercel is $150–$600, on Render $80–$150.

Cloud Run's traps. First, you need other GCP services around it. Cloud SQL — Postgres — bills separately, Cloud Memorystore — Redis — is expensive, Cloud Storage — Object — is separate. Close everything inside GCP and you end up similar to other PaaS pricing. Second, per-request instance is poor for WebSocket / gRPC streaming — Cloud Run 2nd gen helps but with limits. Third, cold start is not zero — first request takes 100ms–several seconds (depends on image size and dependencies).

9.1 Deploying Next.js on Cloud Run

# 1. Write a Dockerfile
# (use the standard Next.js Dockerfile example)

# 2. Cloud Build + Cloud Run in one shot
gcloud run deploy my-saas \
  --source . \
  --region asia-northeast1 \
  --allow-unauthenticated \
  --memory 512Mi \
  --cpu 1 \
  --concurrency 80 \
  --min-instances 0 \
  --max-instances 100

# 3. Connect Cloud SQL Postgres
gcloud run services update my-saas \
  --add-cloudsql-instances PROJECT:REGION:INSTANCE \
  --set-env-vars DATABASE_URL=postgres://...

Setting --min-instances 1 removes cold start at the cost of one always-on instance. Still usually cheaper than an always-on instance on other PaaS.

10. AWS App Runner / ECS Fargate — The AWS Exit

For teams that already have everything inside AWS, adding another PaaS feels like extra cost. App Runner and ECS Fargate are that team's PaaS exit.

App Runner. Push a container or a GitHub repo, get auto build · deploy. Similar to Cloud Run but always-on — does not scale to zero. Pricing: vCPU per minute $0.064, Memory GB per minute $0.007. A $5k/month SaaS bill usually lands at $80–$200.

Where App Runner sits. Integrates smoothly inside the AWS console with other AWS services — RDS, ElastiCache, S3, SQS. There's real value if AWS is first-class to your team. But PaaS outside AWS — Render, Railway, Fly — does the same workload cheaper and easier.

ECS Fargate. Container as a Service. You define an ECS Task Definition and run it on Fargate. One level of abstraction below a PaaS — you write VPC, ALB, IAM, Task Role yourself. But the control is correspondingly large. Large teams often have their main workload on ECS Fargate or EKS, with App Runner and PaaS reserved for ancillary workloads.

Price comparison. The same 1 vCPU + 2GB memory always-on for a month: ECS Fargate around $36/month, App Runner $40–$50/month. Render Standard $25/month, Fly dedicated-cpu-1x $30/month. AWS is slightly more expensive but the integration value with other AWS services can close that gap.

11. Coolify · Dokku — "PaaS Pricing Is Insane, I'll Host It"

There's always a crowd that hates PaaS pricing. "Hetzner VPS gives 4 vCPU + 8GB memory for $5/month, why would the same spec cost $85 on Render?" That crowd's tools are Coolify and Dokku.

Coolify. Open-source self-hosted PaaS that appeared in 2022 and exploded around 2025. Install Coolify on your VPS — Hetzner, DigitalOcean, OVH — and get Heroku-like experience on top. GitHub integration, auto-deploy, domains, HTTPS — auto via Let's Encrypt — managed Postgres · Redis · MySQL · MongoDB, monitoring, all included.

The real Coolify price. Coolify itself is free (Pro $5/month is the price of cloud-hosted Coolify, an instance you don't manage). VPS cost — Hetzner CX31 (2 vCPU, 8GB) at $13/month — is all you pay. Run 10 apps on one VPS and that's $1.3 per app. 1/20th the Render price.

Coolify's traps. First, you operate it. OS updates, security patches, backups, monitoring — all yours. Second, HA is weak. Everything on one VPS means when the VPS dies, every app dies. Coolify's cluster — multi-node — feature is beta. Third, the learning curve sneaks up. Expecting PaaS simplicity makes the first two weeks rough.

Dokku. Open-source mini-Heroku alive since 2013. Simpler than Coolify, no GUI (community GUIs exist), CLI only. dokku apps:create my-app, git push dokku main — almost identical to Heroku's CLI. A solo developer installing Dokku on their own VPS and running 5 small apps is still a sensible 2026 choice.

When to pick Coolify / Dokku. Save money, want to learn ops, side projects where HA isn't absolute. Usually unsuitable for primary business SaaS — one outage's business impact dominates the VPS savings.

12. The Cost Matrix — A Real Bill for a $5k/mo SaaS

Below is an estimated monthly bill for the same workload — Next.js 14 app + Postgres (10GB, light workload) + Redis (256MB) + one background worker — on each PaaS. Traffic assumption: 1M page views per month, 30k daily requests.

Reading. On price alone, Coolify · Dokku dominate. But that's a number that ignores your operational cost — time + risk. Managed PaaS at $80 is not expensive, it's insurance premium. Among managed PaaS, Railway and Fly.io are cheapest, Render next, Vercel · Heroku · App Runner most expensive.

Price is one axis. Without other axes — operational simplicity, workload fit, migration cost, team consensus — the decision goes wrong.

13. The Truth About Cold Starts

The phrase "cold start" still sits at the heart of PaaS debates in 2026. The truth is this.

Only scale-to-zero platforms have cold starts. Always-on PaaS — Render, Railway, Heroku, Northflank — have no cold start. They do have instance restart time, but it's shorter than a cold start.

Vercel · Netlify · Cloud Run · Fly Machines (auto_stop) have cold starts. Typical times:

• Vercel Functions — small Node.js function 100–500ms, big SSR 1–3 seconds
• Netlify Functions — similar
• Cloud Run — 100ms–2 seconds, image size matters a lot
• Fly Machines (auto_stop) — 250–500ms, Firecracker's strength
• AWS Lambda — Node 100–500ms, Java/Python longer

Workloads where cold start hurts. Real-time chat, games, trading, payment processing. Anywhere a 2-second first-request latency translates to user loss.

Three fixes. (1) Min instances >= 1 — both Cloud Run and Fly Machines support it. One always-on instance handles the first request. (2) Provisioned Concurrency — AWS Lambda's feature. (3) Move to an always-on PaaS.

14. The Dusk and Revival of Persistent Disks

Between 2018–2022 the big PaaS trend was "persistent disks are an anti-pattern". Push every state to external — Postgres, Redis, S3 — and keep compute stateless. Vercel · Netlify pushed that direction to the extreme.

The 2023–2026 trend partly reversed. Workloads that need persistent disks reappeared.

• SQLite + Litestream — the simplest data layer for a SaaS. SQLite and the app live inside one VM, and Litestream async-replicates to S3. Fly.io and Render support this pattern well.
• Self-hosted vector DBs — pgvector, Qdrant, Weaviate need disks on your instance.
• File-processing workflows — image transforms, video transcode, large temp file storage.
• Local caches — disk caches when Redis isn't used.

Do you need persistent disks? Look at Render, Fly.io, Railway, Northflank, Coolify · Dokku. Vercel, Netlify, Cloud Run, App Runner drop out.

15. The Reality of Background Workers

Background workers are the hidden half of a SaaS. Sending emails, processing payment webhooks, video transcoding, report generation, scheduled data sync — workers do all of it. PaaS support for workers varies sharply.

First-class — Render, Railway, Fly.io, Northflank, Heroku, Coolify. A worker is an always-on process. Start worker.js, poll a queue or receive messages, done.

Partial — Cloud Run Jobs, App Runner. Cloud Run Jobs is an executable worker but not always-on — it runs when invoked and exits. A queue-polling worker feels awkward on Cloud Run.

Weak — Vercel, Netlify. Vercel Queues is in beta, but there is no always-on worker model. Attaching external worker infrastructure — Inngest, Trigger.dev, Defer, Hatchet — is the common workaround. That's the real cost amplifier on Vercel.

For worker-heavy SaaS — image/video processing, AI inference, ETL — Render · Fly · Railway is almost always a better fit than Vercel.

16. Multi-Region — The Reality for Global SaaS

If you want a global SaaS with under-50ms latency, multi-region is required. The reality of multi-region support:

Smoothest — Fly.io. fly scale count 1 --region nrt,sin,fra,iad in one line. Multi-region Postgres was once Fly's strong card (now collaborative with Supabase).

Auto edge — Vercel, Netlify. Edge Functions and static assets auto-deploy to global edges. But databases don't live at the edge — Neon, PlanetScale, Supabase provide multi-region read replicas.

Region pick — Render, Railway, Northflank, Heroku. Deploy a service to one region; same service across multiple regions is a recent feature or beta. Not the first pick for global SaaS.

Auto global — Cloud Run. Pass multiple --region flags and the same service runs in multiple regions, but you wire up Load Balancer and Cloud Run multi-region config yourself.

If global multi-region is a hard requirement: Fly.io has the least friction, Cloud Run next, Vercel + a global DB after that.

17. The Decision Framework — Which PaaS Should You Pick

A simple decision tree for PaaS choice:

Starting point: what kind of app is it?

1. Next.js · React Router · SvelteKit centric SSG/SSR + light API → Vercel (or Netlify). Other options are similar price or higher, and Vercel's integration value is large.
2. Monolith — Web + worker + DB + Redis in one box → Render (or Railway). Heroku-like experience, delivered best.
3. Global users, multi-region required → Fly.io. Least friction.
4. Team already inside AWS → App Runner or ECS Fargate. AWS exit.
5. Your own cloud / data sovereignty → Northflank.
6. Extreme cost saving, solo with ops learning time → Coolify on Hetzner or Dokku.
7. Already on GCP → Cloud Run + Cloud SQL.
8. Salesforce integration → Heroku.

By team size:

• Solo / side project — Vercel (Hobby) · Fly · Railway · Coolify
• 2–5 small team — Vercel Pro · Render · Railway · Fly
• 5–20 serious SaaS — Render · Railway · Northflank · Fly
• 20+ / compliance — Northflank · Heroku · App Runner · Cloud Run

By learning curve (shortest first):

Vercel > Railway > Render > Heroku > Netlify > Fly > Cloud Run > Coolify > Northflank > App Runner > ECS Fargate.

18. Anti-Patterns Collection

Common patterns that wreck a PaaS choice:

1. Deciding on price alone. Coolify on a VPS at $13/month looks great, until your business SaaS sits there and one outage stops business. The $80 for managed PaaS isn't expensive — it's insurance premium.

2. Assuming "Vercel does it all". It's good at Next.js, not at every workload. Always-on workers, big monoliths, WebSocket-centric apps live better outside Vercel.

3. Starting on the PaaS's managed DB. Vercel Postgres, Render Postgres, Railway Postgres are easy to start but costly to migrate. Start with an independent managed DB — Neon, Supabase, PlanetScale — and you can swap PaaS later.

4. Adopting multi-region too early. Users are all on one continent and you went multi-region anyway. Single region + CDN is enough for many cases.

5. Running production on the free tier. Free tier cold start, sleep, and small resources damage user experience. Start production on paid.

6. Ignoring cold start. Go into Vercel · Cloud Run unaware and the first request taking 1–3 seconds bleeds users. Use min instances >= 1, or move to an always-on PaaS.

7. Assuming the PaaS handles all backups and monitoring. Render · Railway's automatic backup only retains a fixed window. Without your own additional backup, recovery during an incident fails.

8. "PaaS pricing is insane" then jumping to Kubernetes. The PaaS $200/month you hated becomes EKS's $73/month control plane + node cost + ops time (= 5 hours/week) and ends up more expensive. If PaaS pricing bugs you, first move within the same PaaS category to a cheaper option — Railway, Fly — before going to K8s.

Epilogue — Look at the Workload, Not the Tool

The trap of PaaS comparison writing is tool-first thinking. The question is not "Vercel vs Render" but "what fits my workload". The same SaaS can have different answers depending on user distribution, traffic pattern, worker load, data size, and compliance needs.

The 2026 landscape in one line: Next.js = Vercel, monolith = Render, global = Fly, per-minute billing = Railway, serious multi-cloud = Northflank, GCP = Cloud Run, AWS = App Runner, self-host = Coolify. Know these eight and a new project's PaaS decision typically takes 5 minutes.

PaaS Choice Checklist

• Is my app a scale-to-zero workload? (Is cold start acceptable?)
• Do I need persistent disks?
• Do I need always-on workers? Are workers heavy?
• Do I have global users? Is sub-50ms latency required?
• Will I take managed Postgres / Redis inside the PaaS or split it out (Neon / Supabase / Upstash)?
• Do I need compliance — HIPAA, PCI, GDPR, data sovereignty?
• What is the team size and operational availability?
• Have I calculated the cost of leaving — migration to another PaaS — in advance?
• How does my bill change when traffic grows 10x?
• Are preview environments, rollback, backups, and logs sufficient?

Next Article Teaser

The next article will compare the managed databases that sit on top of a PaaS — Neon · Supabase · PlanetScale · Turso · Cloudflare D1 · CockroachDB Serverless with the same depth. Half of a PaaS decision is a DB decision — separating that out frees the PaaS decision.

References

• Vercel pricing — https://vercel.com/pricing
• Vercel Active CPU model — https://vercel.com/docs/pricing/billing
• Vercel AI SDK — https://sdk.vercel.ai
• Netlify pricing — https://www.netlify.com/pricing
• Render pricing — https://render.com/pricing
• Render docs — https://render.com/docs
• Fly.io pricing — https://fly.io/docs/about/pricing
• Fly Machines — https://fly.io/docs/machines
• Fly Apps v2 — https://fly.io/docs/apps
• Railway pricing — https://railway.com/pricing
• Railway Hobby vs Pro — https://docs.railway.app/reference/pricing
• Northflank pricing — https://northflank.com/pricing
• Northflank BYOC — https://northflank.com/docs/byoc
• Heroku pricing — https://www.heroku.com/pricing
• Heroku-24 stack — https://devcenter.heroku.com/articles/heroku-24-stack
• Cloud Run pricing — https://cloud.google.com/run/pricing
• Cloud Run docs — https://cloud.google.com/run/docs
• AWS App Runner — https://aws.amazon.com/apprunner
• AWS Fargate pricing — https://aws.amazon.com/fargate/pricing
• Coolify — https://coolify.io
• Coolify docs — https://coolify.io/docs
• Dokku — https://dokku.com
• Neon — https://neon.tech
• Supabase — https://supabase.com
• Upstash — https://upstash.com
• Inngest (worker complement for Vercel) — https://www.inngest.com
• Trigger.dev — https://trigger.dev
• Heroku free-tier sunset post (2022) — https://blog.heroku.com/next-chapter