Vercel vs Netlify vs Cloudflare Pages vs AWS Amplify

Choosing a deployment platform is one of the most consequential early decisions in a web project. It affects build speed, cold-start latency, pricing at scale, and even which frameworks you can adopt. This comparison cuts through the marketing and evaluates four leading platforms on what actually matters in production.

Overview

Platform	Founded	Core Philosophy	Primary Audience
Vercel	2015 (as ZEIT)	"Framework-defined infrastructure"	Frontend / full-stack teams using Next.js
Netlify	2014	"Composable web architecture"	Jamstack & static-first teams
Cloudflare Pages	2021	"Edge-first everything"	Performance-obsessed teams, global apps
AWS Amplify	2017	"AWS services with a simpler DX"	Teams already invested in AWS ecosystem

Key Insight

No platform is universally "best." Vercel dominates the Next.js ecosystem, Netlify pioneered Jamstack workflows, Cloudflare wins on edge latency, and Amplify is the on-ramp to the full AWS service catalog.

Architecture Comparison

Feature Matrix

Feature	Vercel	Netlify	Cloudflare Pages	AWS Amplify
Free tier bandwidth	100 GB/mo	100 GB/mo	Unlimited	15 GB/mo
Free tier builds	6,000 min/mo	300 min/mo	500 builds/mo	1,000 min/mo
Pro plan price	$20/user/mo	$19/user/mo	$5/mo (Workers Paid)	Pay-as-you-go
Edge locations	~70+ (Anycast)	CDN (multi-provider)	310+ PoPs	600+ CloudFront PoPs
Serverless runtime	Node.js (AWS Lambda)	Node.js (AWS Lambda)	V8 Isolates (Workers)	Node.js (Lambda)
Edge runtime	V8 Isolates	Deno Deploy	V8 Isolates (native)	Lambda@Edge / CloudFront Functions
Cold start	~250ms (serverless) / <1ms (edge)	~250ms (serverless) / <5ms (edge)	<1ms (Workers)	~300ms (Lambda)
Max function duration	60s (Pro) / 300s (Enterprise)	10s (free) / 26s (paid)	30s (Workers) / 15min (Queues)	15min (Lambda)
Next.js support	First-class (creator)	Adapter-based	Adapter (OpenNext)	Adapter-based
Framework adapters	Next, Nuxt, SvelteKit, Astro	Next, Nuxt, Gatsby, Remix, Astro	Next (partial), Astro, Nuxt, SvelteKit	Next, Nuxt, Gatsby, Angular
Preview deployments	Per-PR, instant	Per-PR, instant	Per-branch	Per-branch
Monorepo support	Turborepo-native	Build plugins	Manual config	Amplify monorepo
Analytics	Web Vitals, Speed Insights	Built-in analytics	Web Analytics (free)	CloudWatch integration
DDoS protection	Included	Included	Enterprise-grade (native)	AWS Shield
Custom domains	Unlimited (free)	Unlimited (free)	Unlimited (free)	Unlimited (free)
Image optimization	Built-in (next/image)	Large Media / plugins	Cloudflare Images (paid)	Manual (Lambda@Edge)
Database	Vercel Postgres, KV, Blob	None (BYO)	D1 (SQLite), KV, R2	DynamoDB, Aurora
Auth	None (BYO)	Netlify Identity	Cloudflare Access	Cognito (native)

Code & Config Comparison

Build Configuration

Vercel (vercel.json):

{
  "buildCommand": "npm run build",
  "outputDirectory": ".next",
  "framework": "nextjs",
  "regions": ["iad1", "sfo1", "cdg1"],
  "functions": {
    "api/**/*.ts": {
      "memory": 1024,
      "maxDuration": 60
    }
  },
  "crons": [
    { "path": "/api/cron/sync", "schedule": "0 */6 * * *" }
  ]
}

Netlify (netlify.toml):

[build]
  command = "npm run build"
  publish = ".next"

[build.environment]
  NODE_VERSION = "20"

[[redirects]]
  from = "/api/*"
  to = "/.netlify/functions/:splat"
  status = 200

[[headers]]
  for = "/*"
  [headers.values]
    X-Frame-Options = "DENY"
    X-Content-Type-Options = "nosniff"

Cloudflare Pages (wrangler.toml):

name = "my-app"
compatibility_date = "2026-03-01"
pages_build_output_dir = "./dist"

[[d1_databases]]
binding = "DB"
database_name = "my-db"
database_id = "xxxx-xxxx-xxxx"

[vars]
ENVIRONMENT = "production"

AWS Amplify (amplify.yml):

version: 1
frontend:
  phases:
    preBuild:
      commands:
        - npm ci
    build:
      commands:
        - npm run build
  artifacts:
    baseDirectory: .next
    files:
      - '**/*'
  cache:
    paths:
      - node_modules/**/*
      - .next/cache/**/*

Serverless Function Example

Vercel (Edge Function):

// app/api/hello/route.ts
export const runtime = 'edge';

export async function GET(request: Request) {
  const country = request.headers.get('x-vercel-ip-country') || 'unknown';
  return new Response(
    JSON.stringify({ message: `Hello from ${country}` }),
    { headers: { 'content-type': 'application/json' } }
  );
}

Cloudflare (Worker):

// functions/api/hello.ts
export const onRequest: PagesFunction = async (context) => {
  const country = context.request.cf?.country || 'unknown';
  return new Response(
    JSON.stringify({ message: `Hello from ${country}` }),
    { headers: { 'content-type': 'application/json' } }
  );
};

Netlify (Edge Function):

// netlify/edge-functions/hello.ts
import type { Context } from "@netlify/edge-functions";

export default async (request: Request, context: Context) => {
  const country = context.geo?.country?.code || 'unknown';
  return new Response(
    JSON.stringify({ message: `Hello from ${country}` }),
    { headers: { 'content-type': 'application/json' } }
  );
};

Performance

Cold Start Benchmarks

Metric	Vercel (Serverless)	Vercel (Edge)	Netlify (Serverless)	Netlify (Edge)	Cloudflare Workers	Amplify (Lambda)
Cold start p50	180ms	<1ms	200ms	3ms	<1ms	250ms
Cold start p99	800ms	5ms	900ms	15ms	5ms	1200ms
Warm response p50	15ms	<1ms	20ms	<1ms	<1ms	20ms
Max bundle size	50 MB	4 MB	50 MB	20 MB	10 MB (compressed)	50 MB
Memory	1024-3008 MB	128 MB	1024 MB	512 MB	128 MB	128-10240 MB

Edge Function Constraints

Edge runtimes (V8 Isolates) are fast but restricted. No fs module, limited Node.js APIs, smaller bundle sizes, and shorter execution limits. If your function needs heavy computation or Node.js-specific APIs, serverless (Lambda-based) functions remain the better choice.

Build Speed

Scenario	Vercel	Netlify	Cloudflare Pages	Amplify
Next.js app (100 pages)	~45s	~70s	~90s	~120s
Static site (1000 pages)	~30s	~35s	~40s	~60s
Monorepo (Turborepo)	~20s (cached)	~60s	~80s	~90s
Concurrent builds (free)	1	1	1	1
Concurrent builds (paid)	Up to 12	Up to 3	1 (Pages)	Up to 5

Developer Experience

What Each Platform Excels At

Vercel:

• Zero-config Next.js deployments with instant rollbacks
• Speed Insights and Web Vitals baked into the dashboard
• vercel dev perfectly mirrors production environment locally
• Preview deployments with comment-powered feedback (Vercel Toolbar)

Netlify:

• Form handling without a backend (Netlify Forms)
• Split testing (A/B) built into the platform
• Plugin ecosystem (build plugins for Lighthouse, caching, etc.)
• Netlify CMS (now Decap CMS) integration for content teams

Cloudflare Pages:

• Unbeatable free tier (unlimited bandwidth)
• Native access to Workers KV, D1, R2, Queues, Durable Objects
• Fastest edge network in the industry (310+ PoPs)
• wrangler CLI for local development with full Workers API

AWS Amplify:

• Deep integration with 200+ AWS services
• Cognito for production-grade auth
• AppSync for managed GraphQL
• Fine-grained IAM controls for enterprise compliance

Pain Points

Platform	Common Frustration
Vercel	Pricing jumps sharply at scale; vendor lock-in with Next.js features
Netlify	Build times slower; limited serverless function duration
Cloudflare	Node.js compatibility gaps; smaller ecosystem of adapters
Amplify	Slow builds; complex debugging; AWS console complexity

When to Use Which

Decision Summary

Scenario	Recommended Platform
Next.js app with team of 1-5	Vercel
Static blog or marketing site	Netlify or Cloudflare Pages
Global app requiring <10ms TTFB everywhere	Cloudflare Pages
Project needing DynamoDB, Cognito, SQS	AWS Amplify
Budget-constrained hobby project	Cloudflare Pages (unlimited bandwidth)
Enterprise with compliance requirements	AWS Amplify (IAM, VPC, SOC2)
Monorepo with Turborepo	Vercel
Content site with CMS	Netlify + Decap CMS

Migration

Vercel to Cloudflare Pages

# 1. Install wrangler
npm install -D wrangler

# 2. Add OpenNext adapter for Next.js
npm install @opennextjs/cloudflare

# 3. Update build script in package.json
# "build": "opennextjs-cloudflare"

# 4. Create wrangler.toml
cat > wrangler.toml << 'CONF'
name = "my-app"
compatibility_date = "2026-03-01"
pages_build_output_dir = ".open-next"

[vars]
ENVIRONMENT = "production"
CONF

# 5. Deploy
npx wrangler pages deploy

Netlify to Vercel

# 1. Remove Netlify-specific files
rm netlify.toml
rm -rf netlify/

# 2. Remove Netlify plugins from package.json
npm uninstall @netlify/plugin-nextjs netlify-cli

# 3. Install Vercel CLI
npm install -g vercel

# 4. Initialize Vercel project
vercel

# 5. Move redirects to vercel.json or next.config.js
cat > vercel.json << 'CONF'
{
  "redirects": [
    { "source": "/old-path", "destination": "/new-path", "permanent": true }
  ]
}
CONF

# 6. Deploy
vercel --prod

Key Migration Considerations

Concern	Notes
Environment variables	All platforms use different naming; audit process.env references
Redirects/headers	Config format differs; convert _redirects / netlify.toml / vercel.json
Serverless functions	Path conventions differ (/api/* vs /.netlify/functions/* vs /functions/*)
Edge functions	Runtime APIs are not 100% compatible; test thoroughly
Build cache	Remote cache (Turborepo) is Vercel-specific; self-host for others
DNS propagation	Allow 24-48 hours when moving custom domains

Verdict

Vercel is the gold standard for Next.js projects and teams that value developer experience above all else. Its tight integration with the framework it created is unmatched, but costs climb quickly at scale.

Netlify remains the best choice for Jamstack purists who want form handling, split testing, and a mature plugin ecosystem without vendor lock-in to a specific framework.

Cloudflare Pages offers the most aggressive free tier and the fastest global edge network. If your application can work within Workers constraints, it delivers the best performance-per-dollar ratio in the industry.

AWS Amplify is the right answer when your backend is already AWS-native. It trades developer experience for access to the most comprehensive cloud service catalog on the planet.

Bottom Line

Start with Cloudflare Pages for budget-conscious projects, Vercel for Next.js teams that want zero-friction DX, Netlify for content-heavy static sites, and AWS Amplify when your infrastructure is already in AWS. The migration cost between platforms is moderate (1-3 days for most projects), so do not let lock-in anxiety paralyze your v1 launch.

Which Would You Choose?

Scenario 1: You are a solo indie hacker launching a SaaS product. You have zero revenue, your traffic is unpredictable, and every dollar counts. Your stack is Astro + a few API endpoints.

Recommendation: Cloudflare Pages

Unlimited bandwidth on the free tier is unbeatable for a pre-revenue project. You can deploy your Astro site with Workers for API endpoints and D1 for a database — all on the free or $5/month Workers Paid plan. If your product goes viral overnight, Cloudflare's edge network handles the traffic without surprise bills.

Scenario 2: Your 8-person startup is building a Next.js e-commerce app with ISR, image optimization, and per-PR preview deployments. The team wants the fastest DX possible.

Recommendation: Vercel

Vercel created Next.js and optimizes every feature for their platform. ISR, next/image, middleware, and preview deployments work flawlessly with zero config. The $20/user/month Pro plan is worth it for the DX gains. Be aware that costs will climb as traffic grows — plan to negotiate an Enterprise contract before you hit scale.

Scenario 3: Your content team manages 500+ pages with a headless CMS. They need A/B testing, form submissions without a backend, and easy rollbacks. The dev team is small and does not want to manage infrastructure.

Recommendation: Netlify

Netlify's built-in form handling, split testing (A/B), and Decap CMS integration make it the best platform for content-heavy teams. The plugin ecosystem covers Lighthouse audits, caching, and CMS webhooks. For a 500-page static site, Netlify's build and deploy pipeline is mature and reliable.

Scenario 4: Your enterprise has a microservices backend on AWS with DynamoDB, Cognito, and SQS. You need a frontend deployment platform that integrates with your existing AWS infrastructure and meets SOC 2 compliance requirements.

Recommendation: AWS Amplify

Amplify is the natural choice when your backend is already AWS-native. Cognito for auth, DynamoDB for data, and fine-grained IAM controls satisfy enterprise compliance requirements. The DX is worse than Vercel or Netlify, but the operational coherence of staying within one cloud provider outweighs the convenience gap.

Common Misconceptions

• "Vercel is only for Next.js" — Vercel supports Nuxt, SvelteKit, Astro, Remix, and static sites. However, advanced features like ISR and image optimization are most polished with Next.js.
• "Cloudflare Pages cannot run full-stack apps" — Cloudflare Workers, D1, KV, R2, and Queues provide a complete backend. The constraint is the V8 Isolates runtime, not the feature set. If your code runs in a Worker, you have a full-stack platform.
• "Netlify is dead because Vercel won" — Netlify serves different needs: form handling, split testing, and CMS integrations that Vercel does not offer. Netlify's composable architecture avoids single-vendor lock-in.
• "Vendor lock-in means you can never leave" — Migration between these platforms typically takes 1-3 days. The config files differ, but the application code stays the same. Lock-in anxiety is overrated for most projects.

Real Migration Stories

Kent C. Dodds: Netlify to Fly.io — Kent migrated his high-traffic site off Netlify because he needed a long-running Node.js server for his custom content pipeline, which did not fit Netlify's serverless model. The lesson: pick a platform that matches your architectural pattern, not just your deploy workflow.

Cal.com: Vercel to self-hosted — Cal.com, an open-source scheduling platform, moved off Vercel to self-hosted infrastructure as their traffic scaled. Vercel's per-seat pricing and bandwidth costs became untenable at their volume. They still use Next.js but deploy via Docker on their own servers.

Quiz

1. Which platform offers unlimited bandwidth on its free tier?

Cloudflare Pages. All other platforms cap bandwidth (Vercel: 100 GB, Netlify: 100 GB, Amplify: 15 GB).

2. What is the primary advantage of Vercel's Edge Functions over their Serverless Functions?

Edge Functions use V8 Isolates with sub-millisecond cold starts and run on ~70+ edge locations globally. Serverless Functions use AWS Lambda with ~250ms cold starts and run in specific regions.

3. Why might you choose Netlify over Vercel for a marketing site?

Netlify offers built-in form handling (no backend needed), A/B split testing, and Decap CMS integration — features Vercel does not provide. For content-heavy marketing sites, these built-in capabilities save significant development time.

4. What is the main limitation of Cloudflare Workers compared to traditional serverless?

Workers run in a V8 Isolate, not a Node.js environment. There is no fs module, limited Node.js API compatibility, a 10 MB compressed bundle size limit, and shorter execution time limits (30 seconds for Workers).

5. When does AWS Amplify make sense despite its worse developer experience?

When your backend is already AWS-native (DynamoDB, Cognito, SQS, etc.) and you need enterprise compliance controls (IAM, VPC, SOC 2). The operational coherence of staying within AWS outweighs the DX gap.

One-Liner Summary

Vercel is the gold standard for Next.js DX, Cloudflare Pages wins on free-tier generosity and edge speed, Netlify owns the content-site niche, and Amplify is the AWS on-ramp.