5 Best Ways to Deploy a Next.js App in 2026 — Tested With Real Costs

The best way to deploy a Next.js app in 2026 depends on your team size, traffic, and budget. Vercel offers zero-config deploys but costs $20/seat/month. Cloudflare Pages is cheapest for static sites at $0-5/month. Self-hosted platforms give you full control for ~$25/month total. In an extreme edge case, one developer was billed $46,485 after a traffic spike on a static Vercel site — not typical, but a reminder that understanding usage-based pricing models matters before you deploy.

This guide compares five Next.js deployment platforms with actual commands, real 2026 pricing tables, and honest trade-offs. The self-hosting market hit $15.6 billion in 2024 and is projected to reach $85.2 billion by 2034. Developers are voting with their wallets.

TL;DR: A 5-person team on Vercel pays $189+/mo for seats, bandwidth, and monitoring. The same stack self-hosted costs $25/mo. Cloudflare Pages is cheapest for static sites ($0-5/mo). One developer's $46,485 Vercel bill from a traffic spike is an outlier, but it shows why understanding usage-based pricing matters.

Next.js Deployment Platforms Comparison 2026

Key takeaway: Vercel and Cloudflare focus on compute and edge delivery — observability is handled by specialized tools like Sentry, Plausible, or FullStory, which you add separately. That's a valid architectural choice that gives you flexibility. Self-hosted platforms like Temps take a different approach by bundling analytics, error tracking, and session replay into the platform itself, which simplifies the stack and reduces total cost.

How Does Vercel Handle Next.js Deployment?

Vercel created Next.js, which makes it the most tightly integrated option available. Zero-configuration deployments work immediately — connect your repo, push code, and your site goes live. According to Vercel's pricing page, Pro plans start at $20 per seat per month. For solo developers, that's reasonable. For teams, it adds up fast.

Deploy to Vercel

npm i -g vercel
vercel

Two commands. Your app is live with HTTPS, preview deployments, and automatic rollbacks.

Vercel Pricing Reality

The free tier works well for personal projects and prototypes. But once you're on Pro, costs multiply across team members. A 5-person team pays $100/mo in seat fees alone — before bandwidth or function invocations.

Best For

• Rapid prototyping where deployment speed matters most
• Marketing sites with predictable, moderate traffic
• Teams already invested in Vercel's ecosystem

Watch Out For

• Per-seat pricing: $20/user/month compounds quickly with growing teams
• Bandwidth surprises: media-heavy apps can trigger unexpected charges
• Vendor lock-in: Vercel-specific features (Edge Middleware, Image Optimization) don't transfer to other platforms

We've tracked multiple teams migrating off Vercel after their monthly bills crossed $200. The pattern is consistent: costs stay low during development, then spike unpredictably after launch.

What Is the Cheapest Way to Self-Host Next.js?

The self-hosting market is growing at 18.5% CAGR, from $15.6B in 2024 to a projected $85.2B by 2034. That growth reflects a broader trend: developers want ownership over their infrastructure. Temps is one of the platforms driving this shift — it delivers Vercel-style git push deployments on your own servers, with built-in analytics, error tracking, and monitoring included at no extra cost.

Deploy to Temps

# Connect your GitHub repo to the Temps dashboard
# Configure environment variables
# Push to deploy

# Or use CLI
bunx @temps-sdk/cli deploy

Pricing Reality

Infrastructure costs only. No per-seat fees. No bandwidth overages. What you see is what you pay.

What's Included Without Extra Cost

• Built-in web analytics (privacy-friendly, GDPR compliant)
• Error tracking (Sentry-compatible)
• Session replay
• Uptime monitoring
• Custom domains with automatic SSL
• Zero-downtime deployments

A Vercel setup with equivalent features — team seats plus Sentry, analytics, and monitoring — typically runs $200+/month. Self-hosting covers all of this for infrastructure cost alone.

But is self-hosting right for everyone? Not necessarily. If your team has zero DevOps experience and your app gets under 10K visitors monthly, Vercel's free tier might be the pragmatic choice. Self-hosting shines when costs start scaling.

Migration from Vercel

# No code changes required for standard Next.js apps
# 1. Export env vars from Vercel
# 2. Import to Temps
# 3. Update DNS
# 4. Deploy

Is Railway Good for Full-Stack Next.js Apps?

Railway charges $0.000463 per vCPU minute, which makes it one of the more transparent usage-based platforms. It excels when your Next.js app needs a database, Redis, or background workers alongside the frontend. Everything deploys from a single dashboard with minimal configuration.

Deploy to Railway

npm i -g @railway/cli
railway login
railway init
railway up

Railway Pricing Reality

Usage-based pricing means you only pay for what you consume. That's great for apps with variable traffic. It's less great for budgeting, since you won't know your exact bill until the month ends.

Best For

• Full-stack applications needing managed databases
• Apps requiring Redis, queues, or worker processes
• Projects wanting all services in one dashboard

Watch Out For

• No edge deployment: requests route to a single region
• Database connection limits: can hit ceilings under high concurrency
• Hobby tier sleeps: apps spin down after inactivity on the free plan

In our experience, Railway works best for apps in the $20-50/mo range. Once you're spending more than that, the lack of edge deployment and the connection-pooling limitations start to matter. We've seen teams outgrow Railway around the 200K visitors/month mark.

How Do You Deploy Next.js With Docker on a VPS?

A basic VPS on Hetzner or DigitalOcean starts at $4-6/month, making Docker the cheapest deployment method for Next.js at scale. According to a Barclays CIO Survey, 86% of CIOs plan to repatriate some cloud workloads to self-managed infrastructure. Docker gives you that control.

Step 1: Configure Standalone Output

Add output: "standalone" to your Next.js config. This produces a minimal production build that doesn't need the full node_modules directory.

/** @type {import('next').NextConfig} */
const nextConfig = {
  output: "standalone",
};
module.exports = nextConfig;

Step 2: Create Your Dockerfile

FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:20-alpine AS runner
WORKDIR /app
ENV NODE_ENV=production
COPY --from=builder /app/.next/standalone ./
COPY --from=builder /app/.next/static ./.next/static
COPY --from=builder /app/public ./public
EXPOSE 3000
CMD ["node", "server.js"]

This multi-stage build keeps the final image small — typically under 150MB.

Step 3: Deploy to Your VPS

docker build -t my-app .
docker run -d -p 3000:3000 my-app

For production, you'll want a reverse proxy (Nginx or Caddy) in front of Docker for SSL termination and caching. You'll also need a CI/CD pipeline — GitHub Actions is the most common choice.

Docker + VPS Pricing Reality

Best For

• Cost optimization at very high scale
• Strict compliance requirements
• Custom server configurations
• Teams with dedicated DevOps resources

Watch Out For

• No automatic scaling: you must configure this manually
• SSL setup required: Let's Encrypt with Certbot or a Caddy reverse proxy
• Security responsibility: you manage OS updates, patches, and firewall rules
• No built-in CI/CD: need GitHub Actions, GitLab CI, or similar

Who should avoid this approach? Anyone without DevOps experience or time to maintain servers. The $10/mo you save over a managed platform isn't worth it if a misconfigured firewall leads to a breach.

How Do You Deploy Next.js to Cloudflare Pages With Wrangler?

Cloudflare Pages offers unlimited bandwidth on all plans, including the free tier. With over 300 edge locations worldwide, it's the fastest option for static-heavy Next.js sites. And if you're searching for how to run wrangler pages deploy .next, you're in the right place — we'll cover every step.

Quick Deploy: Static Next.js to Cloudflare Pages

For purely static Next.js exports, deployment takes four commands:

npm i -g wrangler
wrangler login
wrangler pages project create my-app
wrangler pages deploy .next

The wrangler pages deploy .next command uploads your built Next.js output directly to Cloudflare's global edge network. Your site gets a .pages.dev subdomain immediately, with custom domain support available in the dashboard.

Full SSR Deploy: Using @cloudflare/next-on-pages

Static export is straightforward. But what if your app uses server-side rendering, API routes, or server components? You'll need the @cloudflare/next-on-pages adapter:

npm install @cloudflare/next-on-pages

Add a build script to your package.json:

{
  "scripts": {
    "pages:build": "npx @cloudflare/next-on-pages",
    "pages:deploy": "wrangler pages deploy .vercel/output/static"
  }
}

Then build and deploy:

npm run pages:build
npm run pages:deploy

Configuring wrangler.toml for Next.js

For more control, create a wrangler.toml in your project root:

name = "my-nextjs-app"
compatibility_date = "2026-01-01"
compatibility_flags = ["nodejs_compat"]

[build]
command = "npx @cloudflare/next-on-pages"

[[kv_namespaces]]
binding = "MY_KV"
id = "your-kv-namespace-id"

The nodejs_compat flag is critical — without it, many Node.js APIs that Next.js depends on won't work in the Workers runtime.

Setting Up CI/CD With GitHub Actions

Most teams want automatic deploys on push. Here's a working GitHub Actions workflow:

name: Deploy to Cloudflare Pages
on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: "20"
      - run: npm ci
      - run: npx @cloudflare/next-on-pages
      - uses: cloudflare/wrangler-action@v3
        with:
          apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
          command: pages deploy .vercel/output/static --project-name=my-nextjs-app

Cloudflare Pages Pricing Reality

Unlimited bandwidth is the standout feature here. On Vercel, a media-heavy site serving 1M visitors could easily generate $100+ in bandwidth fees. On Cloudflare, that same bandwidth costs nothing.

Cloudflare Pages has become the quiet default for cost-conscious teams running static-heavy Next.js sites. The unlimited bandwidth on free tier effectively subsidizes the entire hosting cost for most marketing sites and documentation portals. We've seen teams move their marketing site to Cloudflare Pages while keeping their app on a different platform — a split deployment strategy that cuts costs without sacrificing SSR capabilities.

What Works Well on Cloudflare Pages

• Static exports and ISR pages served from 300+ edge locations
• Image optimization via Cloudflare Images
• Unlimited bandwidth on all plans including free
• Git integration with GitHub and GitLab for automatic deploys
• Custom domains with free SSL

What Doesn't Work (or Works Differently)

• Node.js API routes: must be rewritten as Workers (different runtime, not full Node.js)
• Middleware: runs as a Worker, and some Next.js middleware features remain unsupported
• Large server-side pages: Workers have a 10ms CPU time limit on the free plan
• Build timeout: 20-minute limit can be tight for large monorepos
• Dynamic rendering: server components with database access require additional setup

Which Platforms Support Zero-Config CI/CD for Next.js?

One of the most searched questions in 2026 is how to deploy Next.js with zero configuration CI/CD — no GitHub Actions YAML, no build scripts, just connect your repo and push. Here's what each platform offers:

Vercel — The gold standard. Connect GitHub/GitLab, push to any branch, get a preview deployment URL in your PR. Production deploys happen on merge to main. No configuration files needed.

Temps — Same git-push workflow as Vercel, running on your own servers. Connect your repo in the dashboard, and every push triggers a build with preview URLs. The difference: you also get analytics, error tracking, and session replay on every preview deployment — not just production.

# Temps: connect repo, then every git push auto-deploys
git push origin main  # → production deploy
git push origin feature-branch  # → preview deployment with unique URL

Railway — Connects to GitHub and auto-deploys on push. No preview deployments on the free plan — you need the Pro tier.

Cloudflare Pages — Git integration with GitHub/GitLab. Preview deployments on every PR. Build configuration sometimes required via wrangler.toml for SSR apps.

Docker + VPS — No CI/CD included. You must set up GitHub Actions, GitLab CI, or another pipeline yourself. This is the main trade-off for maximum control.

If zero-config deployment is a priority and you don't want to manage CI/CD pipelines, Vercel, Temps, and Cloudflare Pages are your best options. The difference comes down to cost model (per-seat vs infrastructure-only) and what's included beyond deployment.

Which Platforms Support Next.js Edge Runtime?

The Next.js Edge Runtime lets you run server-side code at the network edge — closer to your users — for lower latency on dynamic pages. Not every platform supports it:

When edge runtime matters: If your users are globally distributed and you serve dynamic, personalized pages (not just static content), edge runtime reduces Time to First Byte (TTFB) significantly. For most SaaS apps serving users in 1-2 regions, origin-based SSR (Railway, Temps, Docker) performs well enough.

When it doesn't matter: Static sites, ISR pages, and apps with a CDN in front don't benefit much from edge runtime. A well-configured CDN (which Cloudflare, Vercel, and Temps all provide) handles the latency problem for static content.

How Should You Decide Which Platform to Use?

Choosing a deployment platform isn't just about cost — though cost matters a lot. With 86% of CIOs planning to repatriate some cloud workloads, the industry is clearly moving toward more ownership and less vendor dependence. Your choice should reflect where you are today and where you're heading.

Choose Vercel if:

• You're prototyping and need maximum deployment speed
• Budget isn't a primary concern
• You want the tightest possible Next.js integration

Choose self-hosting if:

• You're running production applications at scale
• You want predictable costs that don't grow with your team size
• You need built-in analytics, monitoring, and error tracking
• Data sovereignty or compliance matters to your organization

Choose Railway if:

• Your app needs databases and backend services
• You want everything managed in one dashboard
• Regional (non-edge) deployment is acceptable for your users

Choose Docker + VPS if:

• You have DevOps expertise in-house
• You need maximum infrastructure control
• You're optimizing costs at very high scale (1M+ visitors)

Choose Cloudflare Pages if:

• Your site is primarily static or uses ISR
• Global edge performance is critical
• You're on a tight budget and want unlimited bandwidth

What Does Each Platform Actually Cost? Real Scenarios

The self-hosted PaaS market now includes tools like Coolify with 52,890+ public instances, which shows how much demand exists for alternatives to managed cloud platforms. Here's what real-world scenarios actually cost across all five options.

Scenario: SaaS with 5 developers, 100K monthly visitors

Scenario: Marketing site with 500K monthly visitors

Scenario: Side project, solo developer

For side projects, Vercel's free tier is hard to beat. The cost question only becomes relevant once you add team members or scale past the free tier limits.

Frequently Asked Questions

What is the best way to deploy a Next.js app in 2026?

It depends on your team size and traffic. For solo developers and prototypes, Vercel's free tier is unbeatable. For teams running production apps, self-hosting saves $100-200/month by eliminating per-seat fees. Cloudflare Pages is best for static-heavy sites needing unlimited bandwidth.

How much does it cost to deploy Next.js?

Costs range from $0 (Vercel free tier, Cloudflare Pages) to $189+/month for a 5-person team on Vercel Pro. Self-hosted options run $15-25/month for 100K visitors. Railway's usage-based pricing at $0.000463 per vCPU minute lands somewhere in between. The biggest variable isn't hosting — it's per-seat fees.

Can I deploy Next.js without Vercel?

Absolutely. Next.js is a portable framework. Standard apps work without code changes on Railway, Docker, Cloudflare Pages, or any self-hosted platform. The main migration tasks are exporting environment variables and updating DNS records. Vercel-specific features like Edge Middleware may need minor adjustments.

How do I deploy Next.js to Cloudflare Pages?

Install the Wrangler CLI (npm i -g wrangler), authenticate with wrangler login, then run wrangler pages deploy .next for static sites. For SSR support, install @cloudflare/next-on-pages, run the adapter, then deploy with wrangler pages deploy .vercel/output/static. Cloudflare offers unlimited bandwidth on all plans including free.

What is the cheapest way to host a Next.js app?

For static sites, Cloudflare Pages is free with unlimited bandwidth. For dynamic apps, Docker on a VPS starts at $4-6/month. Self-hosted PaaS platforms offer a middle ground: managed deployment experience at infrastructure cost. The self-hosting market's 18.5% CAGR growth suggests developers increasingly prefer this route.

Which Next.js deployment platforms support zero-config CI/CD?

Vercel, Temps, Cloudflare Pages, and Railway all support automatic deployments from GitHub/GitLab — connect your repo, push code, and the platform builds and deploys automatically. Preview deployments (unique URLs per PR) are available on Vercel, Temps, and Cloudflare Pages. Docker + VPS requires manual CI/CD setup via GitHub Actions or similar.

Which platforms support Next.js edge runtime in 2026?

Vercel has native edge runtime support. Cloudflare Pages supports it via the Workers runtime (with some Node.js API limitations). Temps serves static assets via Pingora edge proxy with SSR on your origin servers. Railway and Docker deployments are single-region only. Edge runtime matters most for globally distributed dynamic content — static sites get similar performance from a CDN.

How do I deploy Next.js at scale with multiple apps?

For agencies or teams managing many Next.js apps, the cost difference between platforms compounds quickly. Running 50+ sites on Vercel can cost $1,000+/month in seat fees alone. Self-hosted platforms like Temps or Docker let you run hundreds of apps on a few servers for $50-100/month total. One developer documented their analysis of running 500 Next.js sites on a VPS vs Vercel, finding 10-20x cost savings with self-hosting.

Last updated March 23, 2026. Pricing verified against each platform's current pricing page.

Related guides:

• How to Migrate from Vercel to Self-Hosted -- step-by-step migration guide if you've decided to switch
• Next.js Hosting Costs in 2026: Calculate Your Real Bill -- detailed cost formulas for your specific setup
• How to Deploy Next.js in Under 5 Minutes with Temps -- walkthrough of the Temps deployment flow
• Temps vs Coolify vs Netlify -- deeper comparison of self-hosted platforms
• Vercel Cost Savings with Temps -- detailed Vercel bill breakdown and alternatives
• Zero-Downtime Deployments -- how to deploy without dropping requests