The web deployment landscape crystallized into a clear three-way split in 2026. Vercel for Next.js full-stack. Cloudflare Pages for static sites and edge workloads. Netlify for the Jamstack middle ground. All three ship with git push-to-deploy out of the box.
The real story is in billing and performance. In February 2026, Vercel shipped Fluid Compute to GA and announced up to 95% cost savings across 45 billion weekly requests. Cloudflare Workers hold cold starts under 5ms. Netlify migrated to credit-based billing in September 2025. The same app gets billed differently, responds at different speeds, and feels different to operate.
Short version: Next.js ecosystem → Vercel. High-traffic static or edge-heavy → Cloudflare Pages. Forms and adapter ecosystem → Netlify.
Quick Summary
- Vercel: Hobby free (100GB · 1M invocations), Pro $20/user/mo, Fluid Compute saves up to 95%
- Netlify: Free 100GB · 300 build min, Pro $19/user/mo, credit-based since Sept 2025
- Cloudflare Pages: unlimited bandwidth, 500 builds/mo free, Workers Paid $5/mo bundles ecosystem
- Cold starts: Cloudflare < 5ms > Vercel Fluid ~0ms (warm) > Netlify 150~3,000ms
- Next.js support: Vercel native > Netlify adapter (30~60% slower builds) > Cloudflare OpenNext (constraints)
- Edge PoPs: Cloudflare 330+ / Vercel 40+ / Netlify 8-region multi-cloud
- Cloudflare ecosystem: KV · D1 · R2 · Durable Objects · Hyperdrive bundled at $5
What Each Platform Actually Is
Vercel was founded by Guillermo Rauch in 2015 — the same person behind Next.js. As of 2026, the company sits around $3.2B valuation. The core edge: native Next.js integration. ISR, Image Optimization, Middleware, Server Actions, Cache Components — all of it works with zero config. Hobby plan is personal / non-commercial only.
Netlify was founded in 2014 and coined the term "Jamstack." Framework adapters span Astro, Next.js, SvelteKit, Nuxt, Gatsby, Hugo — the widest ecosystem of the three. Forms, serverless functions, and Edge Functions come built in. In September 2025, they migrated to credit-based billing.
Cloudflare Pages runs on Cloudflare's global edge network. The headline features are 330+ PoPs and unlimited bandwidth. Workers Paid ($5/month) alone bundles Workers, Pages Functions, KV, D1, R2, Durable Objects, and Hyperdrive. Next.js runs through OpenNext and inherits edge runtime constraints — some Node.js modules unavailable, ISR limited.
Free Tier Deep Dive
| Metric | Vercel Hobby | Netlify Free | Cloudflare Pages |
|---|---|---|---|
| Bandwidth | 100GB | 100GB | Unlimited |
| Build time | Unlimited deploys | 300 min/mo | 500 builds/mo |
| Function invocations | 1M/mo | 125K/mo | 100K/day (~3M/mo) |
| CPU time | 4h Active CPU | Credit-based | 10ms/request |
| Storage | 1GB Blob | 10GB | R2 10GB / KV 1GB |
| Usage restriction | Personal / non-commercial | Commercial OK | Commercial OK |
Cloudflare dominates on raw bandwidth — traffic spikes don't trigger overage invoices. Vercel Hobby's decisive constraint is the no-commercial clause. A single advertisement can put you in violation. Netlify's 300 build-minute cap is the actual bottleneck — a medium Next.js project often builds in 5~8 minutes, hitting the ceiling at 40~60 deploys/month.
Paid Plans and Overage Simulation
- Vercel Pro: $20/user/month + 16 CPU-hours, 1,440 GB-hours memory — overage Active CPU $0.128/hour
- Netlify Pro: $19/user/month + 1TB bandwidth, 25K build minutes — $7 per 500 extra build min, $20 per 100GB extra bandwidth, $25 per 1M extra invocations
- Cloudflare Workers Paid: $5/month + 10M requests, 30M CPU-ms — $0.30 per extra 1M requests
Scenario A — Small blog (100K monthly visits, 50GB bandwidth, 500K function calls)
Vercel Hobby $0 / Pro $20. Netlify Free possible. Cloudflare Pages $0. → Cloudflare Pages wins.
Scenario B — Next.js SaaS (500K monthly visits, 5M function calls, DB-heavy)
Vercel Pro ~$20~30 (Fluid keeps CPU overage near zero). Netlify Pro $19 + function overage $100 = $119. Cloudflare Workers Paid $5 + extra requests $1.50 = $6.50. → Order: Cloudflare, Vercel, Netlify. If Next.js compatibility is non-negotiable, Vercel.
Scenario C — Image hosting (2TB monthly downloads)
Vercel Pro $20 + 1.9TB overage $380 = $400. Netlify Pro $19 + 1TB overage $200 = $219. Cloudflare R2 $0 egress + $30 storage = $30. → For egress-heavy workloads, Cloudflare is effectively the only option.
Vercel Fluid Compute — Real Savings
Fluid Compute hit GA in February 2026. Per Vercel's figures: 45B weekly requests, customers seeing up to 95% savings, 75%+ of all functions now on Fluid. The old model billed the entire function duration. Fluid only bills Active CPU windows — when your code is actually executing.
// Example: Next.js API handler (I/O-bound)
export async function GET(req) {
// 100ms — JSON parsing, validation (Active CPU)
const body = await req.json()
// 400ms — Supabase query wait (I/O, Fluid bills nothing)
const data = await supabase.from('users').select()
// 30ms — response serialization (Active CPU)
return Response.json(data)
}
// Total wall time: 530ms
// Legacy billing: 530ms (all of it)
// Fluid billing: 130ms (Active CPU only) → 75% saved
From Vercel's case studies: "Many of our API endpoints were lightweight and involved external requests, resulting in idle compute time. By leveraging in-function concurrency, we were able to share compute resources between invocations, cutting costs by over 50% with zero code changes."
For typical Next.js apps, expect function invocation counts to drop 30~50% with proportional cost reduction. The benefit is limited for CPU-heavy workloads (ML inference, image resizing) where Active CPU dominates.
Cold Start Benchmarks — 5ms vs 250ms vs 3 Seconds
| Platform | Cold start | Warm response | Mechanism |
|---|---|---|---|
| Cloudflare Workers | < 5ms | ~1ms | V8 Isolates + Shard-and-Conquer (99.99% warm) |
| Vercel Fluid | ~0ms (warm) | 20~50ms | Instance pre-warming + in-function concurrency |
| Vercel legacy serverless | ~250ms | 50~80ms | AWS Lambda |
| Netlify Functions | 150~3,000ms | 80~150ms | AWS Lambda (high variance) |
Cloudflare Workers' sub-5ms comes from V8 Isolates. Instead of spinning up a container, the platform runs your function directly inside the JavaScript engine. Initialization overhead is near zero. Shard-and-Conquer consistent hashing routes same-request traffic to the same node, keeping warm-hit rate at 99.99%.
Vercel Fluid keeps instances warm with in-function concurrency — a single instance handles multiple concurrent requests. Near-zero cold starts for active functions.
Netlify, running on AWS Lambda, is the slowest. Cold starts up to 3 seconds in benchmarks. For low-traffic sites or early-morning first requests, users feel the wait.
Next.js Feature Compatibility Matrix
| Next.js feature | Vercel | Netlify | Cloudflare (OpenNext) |
|---|---|---|---|
| Server Components (RSC) | Full | Full | Full |
| Server Actions | Full | Full | Partial |
| ISR (revalidate) | Full | On-Demand only | Limited |
| Image Optimization | Native | Adapter | Cloudflare Images |
| Middleware | Full | Full | Full (edge) |
| Cache Components | Full | Planned | ❌ |
| Partial Prerendering (PPR) | Full | Partial | ❌ |
| Edge Runtime | Full | Edge Functions | Native |
| Full Node.js modules | All | All | Some blocked |
| Build speed (same project) | baseline | 30~60% slower | 20% slower |
Next.js' latest features (Cache Components, PPR) only ship fully on Vercel. Netlify covers most of it via adapter, but ISR semantics differ and builds run noticeably longer. Cloudflare Pages inherits edge-runtime constraints — can't use fs, net, or child_process, and ISR requires wiring Incremental Cache into KV separately.
On the flip side, Cloudflare's Image Optimization routes through Cloudflare Images (faster CDN), and Edge Runtime is native. For edge-friendly codebases, Cloudflare Pages can actually win.
Cloudflare Ecosystem — KV · D1 · R2 · Durable Objects
Cloudflare's real edge: $5/month Workers Paid bundles 6+ data services. Each as a standalone SaaS would run into hundreds of dollars.
| Service | Use case | Price (Paid) |
|---|---|---|
| Workers KV | Global key-value, config/session/personalization | Reads 10M $0.50, writes 1M $5 |
| D1 | Managed SQLite, lightweight relational DB | Reads 25M $1, writes 50K $1 |
| R2 | S3-compatible object storage, zero egress | $0.015/GB storage, Class A 1M $4.50 |
| Durable Objects | WebSockets, collaboration, locks, rate limiters | 1M requests $0.15, $0.20/GB/mo |
| Queues | Message queue, async work | 1M operations $0.40 |
| Hyperdrive | External PostgreSQL pooling | Included in Workers Paid |
Practical combo: sessions/config on KV, user data on D1, images/files on R2, chat rooms on Durable Objects, background jobs via Queues. Everything at the same $5.
AWS equivalent stack: RDS ($15) + DynamoDB ($10) + S3 ($5) + egress ($100+) + SQS ($2) = $130+/month minimum. R2's zero-egress policy alone makes file-heavy services land in a completely different cost range.
Durable Objects is the only practical choice for stateful edge computing. WebSocket chat rooms, Google Docs-style real-time collaboration, distributed locks, rate limiters. Vercel and Netlify have no equivalent, forcing external services (Pusher, Ably) to fill the gap.
Edge Network and Global TTFB
- Cloudflare: 330+ PoPs across 120+ countries
- Vercel: own edge network (40+ regions) + AWS/GCP
- Netlify: multi-cloud AWS/GCP/Azure (8 main regions)
TTFB benchmarks from Korea (static content): Cloudflare Seoul PoP 30~50ms, Vercel Tokyo/Seoul region 80~120ms, Netlify US-West default 250~400ms. For global apps with APAC users, Cloudflare is overwhelmingly the fastest experience.
Vercel's Tokyo/Singapore regions can reach ~100ms in Korea when explicitly configured. Hobby has limited region pinning; Pro enables per-project region selection. Setting regions in vercel.json is important — defaults often point to US regions.
Netlify Credit-Based Pricing
Since September 2025, Netlify uses a unified credit pool. Approximate conversions: 1 build minute = 1 credit, 1,000 function invocations = 1 credit, 1 GB bandwidth = 1 credit. Pro includes 500 credits/month — in theory 100 deploys if builds are 5 minutes each, but practical ceiling drops to 50~70 after other usage.
The complaint is predictability. "My build ran long and drained my credits" posts keep showing up in dev forums. Accounts created before September 4, 2025 can stay on the legacy plan.
Netlify's strengths still hold — Forms built in (100 submissions/mo free), Identity, Large Media, Split Testing. Features Vercel and Cloudflare don't match natively.
Full Comparison Table
| Dimension | Vercel | Netlify | Cloudflare Pages |
|---|---|---|---|
| Free bandwidth | 100GB | 100GB | Unlimited |
| Paid starting | $20/user/mo | $19/user/mo | $5/mo |
| Cold start | ~0ms (warm) | 150~3,000ms | < 5ms |
| Next.js support | Native (full) | Adapter (mostly) | OpenNext (constrained) |
| Serverless billing | Active CPU (Fluid) | Credit-based | Per-request |
| Global PoPs | 40+ edge | 8 regions | 330+ PoPs |
| Commercial free use | Not allowed | Allowed | Allowed |
| Ecosystem | Next.js + Postgres/KV/Blob | Forms, Identity, Split Testing | KV, D1, R2, DO, Queues |
| Build speed (Next.js) | Fastest | 30~60% slower | 20% slower |
| DX / dashboard | Best | Clean | Deep but learning curve |
| Egress cost | Deducts from bandwidth | Deducts | R2 $0 |
Combining Platforms — Real-World Patterns
No reason to pick one and stick with it.
# Pattern A — Subdomain split (most common)
static.example.com → Cloudflare Pages (images, docs, heavy assets)
app.example.com → Vercel Pro (Next.js full-stack)
forms.example.com → Netlify (form intake)
# Pattern B — Cloudflare as front CDN, Vercel as origin
Cloudflare (CDN/WAF/DDoS) → Vercel (serverless origin)
# Cloudflare absorbs egress, Vercel handles execution only
# Pattern C — Full Cloudflare stack (AWS alternative)
Cloudflare Pages + Workers + D1 + R2 + Durable Objects
# Full-stack infra starting at $5/month
Recommendations by Scenario
| Scenario | Pick | Why |
|---|---|---|
| Next.js full-stack SaaS | Vercel Pro | Fluid Compute 95% savings, Cache Components/PPR native |
| Image / video hosting | Cloudflare + R2 | Zero egress, 330+ PoPs |
| Astro / SvelteKit | Netlify | Adapter ecosystem, built-in forms |
| Real-time / WebSocket | Cloudflare + DO | Only edge stateful solution |
| Global TTFB matters | Cloudflare | Largest edge network |
| Intermittent traffic | Vercel Fluid / Cloudflare | Low cold start |
| Personal (no revenue) | Vercel Hobby | All Next.js features free |
| Form-heavy marketing | Netlify | Forms built in |
Closing Thoughts
All three platforms are mature as of 2026. "Which is better" is the wrong frame — "which fits your stack" is the real question.
Three trends worth watching as of April 2026:
- Vercel Fluid Compute now powers 75%+ of all Vercel Functions and has measurably dropped Next.js full-stack bills.
- Cloudflare D1 moved past GA with real production references, making AWS RDS replacement a concrete option.
- Netlify's credit-based pricing is driving heavy users to reconsider.
The right choice shifts each year. Review your workload periodically.
Official sources:
- Vercel Pricing
- Vercel Fluid Compute docs
- Vercel Active CPU pricing blog
- Netlify Pricing
- Netlify credit-based pricing docs
- Cloudflare Workers pricing
- Cloudflare Durable Objects pricing
- Cloudflare Workers CPU benchmarks
Originally published on GoCodeLab — April 2026 pricing. Plans and policies change frequently; verify with official docs before committing.
Top comments (0)