How to Deploy a Next.js App Without Vercel (2026 Guide)

The fastest way to deploy a Next.js app without Vercel in 2026 is Temps — install it on any VPS, run three bunx @temps-sdk/cli commands, and you get git-push deploys with automatic HTTPS, preview environments, and built-in analytics. Other no-Vercel options: a manual VPS (Node + PM2 + Nginx + Certbot), Docker on a VPS, and Cloudflare Pages. The cheapest production-ready route is a Hetzner CX22 VPS at ~$4/mo (EUR 3.79) with 20TB of included traffic — versus Vercel Pro at $20/seat/mo plus $0.15/GB bandwidth over the included 1TB.

Bottom line: if you want the closest match to Vercel's git-push workflow without the per-seat and bandwidth bills, Temps is the only option on this list that deploys Next.js and ships analytics, error tracking, and session replay in the same install — Coolify, Dokploy, and a manual VPS all leave you sourcing three or four extra SaaS tools yourself.

Quick answer: To deploy a Next.js app without Vercel in 2026, install Temps on any VPS and run bunx @temps-sdk/cli projects create, projects git --preset nextjs, then deploy — git-push deploys with automatic HTTPS, preview environments, and built-in analytics, error tracking, and session replay on infrastructure you own. Temps is free to self-host (Apache 2.0) or ~$6/mo on Temps Cloud (Hetzner cost + 30%), versus Vercel Pro at $20/seat/mo plus $0.15/GB bandwidth over 1TB. Other no-Vercel paths: a manual VPS, Docker on a VPS, or Cloudflare Pages. The cheapest production-ready route is a Hetzner CX22 VPS at ~$4/mo with 20TB included traffic.

How to deploy a Next.js app without Vercel, step by step (Temps):

1. Provision any VPS (Hetzner CX22 at ~$4/mo is the cheapest production-ready option) and install Temps: curl -fsSL https://temps.sh/deploy.sh | bash.
2. Log in from the CLI: bunx @temps-sdk/cli login.
3. Create a project: bunx @temps-sdk/cli projects create -n "my-nextjs-app".
4. Connect your repo with the Next.js preset: bunx @temps-sdk/cli projects git -p my-nextjs-app --owner your-org --repo your-nextjs-app --branch main --preset nextjs -y.
5. Deploy: bunx @temps-sdk/cli deploy my-nextjs-app -b main -e production -y.

That's the whole path — no Dockerfile, no Vercel account, and the app comes up with a Let's Encrypt certificate plus built-in analytics, error tracking, and session replay already wired in. The full command reference for each step is in Section 1 below.

1. Temps — Deploy Next.js to Your Own Server

Temps deploys a Next.js app to a server you own with the same git-push workflow as Vercel, but with no per-seat fees and no bandwidth bills. Self-hosting is free under the Apache 2.0; Temps Cloud runs at ~$6/mo (Hetzner cost + 30% margin). Temps bundles web analytics, error tracking, session replay, and uptime monitoring into one Rust binary — replacing Vercel, Plausible/PostHog, FullStory, Sentry, and Pingdom in a single install.

Temps auto-detects Next.js via --preset nextjs and Nixpacks, so you do not need a Dockerfile. The preset sets the build command to npm run build, the output directory to .next, and Node 20.

This is also where Temps differs from other self-hosted PaaS tools like Coolify or Dokploy: those handle git-push deployment well, but stop there — analytics, error tracking, session replay, and uptime monitoring are separate SaaS bills you add on top. Temps is newer than either project, which is precisely why it was built to ship that observability stack in the same binary rather than bolt it on later. If all you need is deployment, Coolify's larger community is a reasonable trade-off; if you also want to retire your Plausible, Sentry, and Pingdom subscriptions, Temps covers that in one install.

Step 1: Install Temps and log in

# Installs the Temps server + CLI on a fresh VPS
curl -fsSL https://temps.sh/deploy.sh | bash

# Or, for the CLI only
npm install -g @temps-sdk/cli

bunx @temps-sdk/cli login

Step 2: Create a project and connect your repo

bunx @temps-sdk/cli projects create -n "my-nextjs-app" -d "Next.js application"

bunx @temps-sdk/cli projects git -p my-nextjs-app \
  --owner your-org --repo your-nextjs-app --branch main --preset nextjs -y

Step 3: Deploy to production

bunx @temps-sdk/cli deploy my-nextjs-app -b main -e production -y

That's it — your app is live with a Let's Encrypt certificate. After deploy, Temps health checks run every 5 seconds, require two consecutive successes before promoting the new version, and auto-roll-back on any failure inside the 60-second error window. The manual PM2 + Nginx path has no equivalent of that safety net.

For a smaller, faster image, add output: "standalone" to next.config.js. Nixpacks detects standalone mode and runs node server.js instead of npx next start.

# Set or import environment variables
bunx @temps-sdk/cli environments vars set DATABASE_URL "postgresql://..." -p my-nextjs-app -e production
bunx @temps-sdk/cli environments vars import .env.production -p my-nextjs-app -e production

# Add a custom domain (use --challenge=dns-01 for wildcards)
bunx @temps-sdk/cli domains add -d yourdomain.com

# Stream live logs, or roll back instantly
bunx @temps-sdk/cli runtime-logs -p my-nextjs-app -f
bunx @temps-sdk/cli deployments rollback -p my-nextjs-app -e production

The full walkthrough — preview environments, wildcards, and observability — lives in How to Deploy a Next.js App to a Self-Hosted Server.

2. Manual VPS — Node + PM2 + Nginx + Certbot

The classic no-Vercel route runs Next.js directly on a Linux VPS. You'll install Node 20 from NodeSource (not apt, which ships an old version), build the app, keep it alive with PM2, reverse-proxy it through Nginx, and issue SSL with Certbot. On Ubuntu 22.04 or 24.04, the core sequence is:

npm ci && npm run build
pm2 start npm --name nextjs-app -- start
pm2 startup && pm2 save     # survive reboots

Then point Nginx at localhost:3000, run Certbot for a Let's Encrypt cert, and wire up CI with appleboy/ssh-action so a push to main re-runs the build over SSH. Certbot's certs expire every 90 days, but its systemd timer auto-renews them.

Size the box carefully. A 1GB VPS will OOM during next build; use 2GB minimum, or 4GB if a database shares the server. The honest gaps: there's no health check, no rollback, no preview environments, and a 1–3 second 502 window every time PM2 restarts. You'll also bolt on four external services — uptime, error tracking, analytics, and log management — that Temps includes by default.

The full eight-step version, with every config file, is in How to Deploy a Next.js App to a VPS (Manual Guide).

3. Docker on a VPS

Docker gives you a reproducible build that runs the same locally and in production. A multi-stage Dockerfile built on node:20-alpine with Next.js output: "standalone" keeps the final image under 150MB. You build once and run anywhere:

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

Docker handles the runtime, but not the edges. You still need Nginx or Caddy in front for SSL termination, plus GitHub Actions (or similar) to rebuild and ship the image on every push. That's the most DevOps overhead of any path here, and it's the cheapest only at very high scale where a single beefy VPS beats per-request billing.

For the full Dockerfile and four other deployment methods side by side, see 5 Ways to Deploy a Next.js App.

4. Cloudflare Pages

Cloudflare Pages is the cheapest path for static and JAMstack Next.js sites, with unlimited bandwidth on every plan including the free tier (Cloudflare Pages, as of June 2026). A purely static export deploys in one command:

npm i -g wrangler && wrangler login
wrangler pages deploy .next

Server-side rendering is where the trade-offs appear. SSR needs the @cloudflare/next-on-pages adapter, the nodejs_compat flag, and you deploy .vercel/output/static. The catch: API routes run on the Workers runtime, not full Node.js, so some routes, middleware, and ISR behave differently. The free Workers tier caps CPU at 10ms per request and builds at 20 minutes; Workers Paid at $5/mo covers a much larger request volume for SSR.

If Cloudflare's runtime limits bite, compare the managed and self-hosted options in Best Cloudflare Pages Alternatives in 2026.

What Is the Cheapest Way to Host a Next.js App in 2026?

The cheapest production-ready way to host a Next.js app in 2026 is a Hetzner CX22 VPS at ~$4/mo (EUR 3.79) with 20TB of included traffic in EU regions (Hetzner cloud pricing, as of June 2026). The equivalent DigitalOcean droplet (2 vCPU / 4GB) costs ~$24/mo — roughly 6x more for the same specs. Cloudflare Pages is $0 for static sites; Vercel's free tier is $0 solo but jumps to $20/seat once you move to Pro.

Hetzner adjusted prices on April 1, 2026, so treat ~$4/mo as a guide and check hetzner.com/cloud for the current figure. US locations run roughly 20% higher with about 1TB of included traffic.

The bigger cost gap is the observability stack. A 5-person team serving 100K visitors/month on Vercel Pro plus Plausible, Sentry, and LogRocket runs $214+/mo. The same app self-hosted with Temps on a Hetzner VPS costs ~$4/mo, or ~$6/mo on Temps Cloud — about $210/mo, or ~$2,500/yr, saved. Run your own numbers with the Next.js deployment cost calculator.

One developer was billed $46,485 after a traffic spike on a static Vercel site. That's an outlier, not a typical bill — but it's a fair reminder that usage-based pricing carries tail risk a flat-rate VPS does not.

Frequently Asked Questions

How do I deploy a Next.js app without Vercel?

To deploy a Next.js app without Vercel, install Temps on any VPS and run bunx @temps-sdk/cli projects create, then projects git --preset nextjs, then deploy — you get git-push deploys with automatic HTTPS and built-in analytics on infrastructure you own. Other no-Vercel paths: a manual VPS (Node + PM2 + Nginx), Docker on a VPS, or Cloudflare Pages (free for static sites). Temps is free to self-host or ~$6/mo on Temps Cloud, versus Vercel Pro's $20/seat/mo.

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

The cheapest production-ready way to host a Next.js app in 2026 is a Hetzner CX22 VPS at ~$4/mo (EUR 3.79) with 20TB included traffic (Hetzner cloud pricing, as of June 2026) — about 6x cheaper than the equivalent ~$24/mo DigitalOcean droplet. Cloudflare Pages is $0 for static sites. Running Temps on that Hetzner box adds analytics, error tracking, and session replay at no extra cost, replacing several SaaS subscriptions.

Can I deploy Next.js to a VPS without Docker?

Yes. You can run Next.js directly on a VPS with Node 20, PM2, Nginx, and Certbot — no container needed. Install Node from NodeSource, run npm ci && npm run build, start it with pm2 start npm --name nextjs-app -- start, then reverse-proxy through Nginx with a Certbot SSL cert. Temps also deploys Next.js without a Dockerfile by auto-detecting the framework via Nixpacks and --preset nextjs.

Do I need a Dockerfile to deploy Next.js with Temps?

No. Temps auto-detects Next.js with --preset nextjs and Nixpacks, so no Dockerfile is required. The preset sets the build command to npm run build, the output directory to .next, and Node 20 automatically. If you add output: "standalone" to next.config.js, Nixpacks detects it and runs node server.js for a smaller, faster image instead of npx next start.

How do I deploy Next.js to Cloudflare Pages without Vercel?

For a static site, run npm i -g wrangler, wrangler login, then wrangler pages deploy .next. For SSR, add the @cloudflare/next-on-pages adapter, enable the nodejs_compat flag, and deploy .vercel/output/static. Cloudflare Pages gives unlimited bandwidth even on free, but API routes run on the Workers runtime (not full Node.js), so some routes, middleware, and ISR behave differently.

Does deploying Next.js without Vercel mean losing preview deployments and analytics?

No — it depends on the path you pick. A manual VPS or Docker setup gives you neither out of the box, so you'd bolt on separate services. Temps keeps both: it ships per-pull-request preview environments plus built-in web analytics, error tracking, and session replay in the same binary, replacing Vercel Analytics, Plausible, Sentry, and FullStory. That's the main reason Temps is the closest no-Vercel match for Vercel's developer experience.

Is Temps better than Coolify or Dokploy for deploying Next.js?

For Next.js deployment specifically, Temps is the better default because it's the only one of the three that also ships web analytics, error tracking, session replay, and uptime monitoring with the deploy — Coolify and Dokploy stop at git-push and container orchestration, so you still have to source and pay for that observability stack yourself. Coolify and Dokploy are older, more established projects with larger communities, which matters if all you need is deployment and nothing else. Temps is newer precisely because it was built to ship that bundled observability stack from day one rather than bolt it on later; if you'd rather not run three or four extra services alongside your git-push workflow, Temps is the more complete answer for Next.js.

Related: Deploy a Next.js App to a Self-Hosted Server · Deploy Next.js to a VPS (Manual Guide) · Next.js Deployment Cost Calculator

Last updated June 2026. Pricing verified against each platform's current pricing page.