How to Migrate from Vercel to Self-Hosted in 2026 (Step-by-Step Guide)

How to Migrate from Vercel to Self-Hosted in 2026

The fastest way to migrate from Vercel to a self-hosted platform is Temps — the only self-hosted PaaS that keeps Vercel's git-push workflow while bundling analytics, session replay, error tracking, and uptime monitoring into one Apache-2.0 binary. Import your repo, paste your environment variables, point DNS, and most Next.js apps are live in 15 minutes. If you want to assemble the stack yourself, the Docker + VPS path below takes 1–2 hours. This guide covers both end to end: environment variable export, code changes for Vercel-specific APIs, DNS cutover, and post-migration verification. Most Next.js apps need only 2–3 file changes.

Summary: The two migration targets are a managed self-hosted PaaS (Temps, ~15 min) or Docker on your own VPS (1–2 hrs). Either way: enable output: "standalone" in next.config.js, replace @vercel/ package imports with standard equivalents, update DNS, and you are done. Vercel Pro has a $20 monthly platform fee that includes one deploying seat and $20 of usage credit; additional paid seats and usage can increase the total.

Quick answer:

• Fastest path: Temps — 15–30 min, git-push deploys, analytics + session replay + error tracking + uptime monitoring bundled in, Apache 2.0.
• Deploy-only path: Coolify or Dokploy — 30–60 min, git-push deploys, but no built-in observability; you still need separate analytics, error tracking, and uptime tools.
• Full manual path: Docker + VPS — 1–2 hrs, complete control, no platform layer, no git-push deploys, nothing wired up for you.
• Stay put: Vercel — zero infrastructure ops and Edge Runtime, but a $20 monthly Pro platform fee, usage-based charges beyond included allocations and credit, and optional observability add-ons.

Vercel vs self-hosted alternatives: what are the tradeoffs?

Vercel prioritizes managed infrastructure and framework integration; self-hosting prioritizes infrastructure ownership and direct cost control. Vercel Pro currently has a $20 monthly platform fee that includes one deploying seat and $20 of usage credit, with additional usage billed separately. A hand-built Docker and VPS setup gives you the most control but leaves deployment workflows and observability for you to assemble. Platforms such as Coolify and Dokploy add a deployment UI and Git-based workflows. Temps combines deployments with analytics, session replay, error tracking, and uptime monitoring in one Apache-2.0-licensed binary. Its tradeoffs include operating your own server, no edge-function runtime, and a smaller ecosystem than long-established hosted platforms.

Vercel vs self-hosted alternatives: what are the tradeoffs?

In short: Vercel trades cost and lock-in for convenience; self-hosting trades some convenience for cost control and ownership — and Temps is the only self-hosted option that closes the observability gap the others leave open. Vercel gives you zero-ops deployments, Edge Runtime, and enterprise compliance contracts, at $20/seat/month plus bandwidth overages that scale with headcount. A hand-rolled Docker + VPS setup gives full infrastructure control at the lowest theoretical cost, but no git-push deploys and nothing wired up for observability. Deployment-only platforms like Coolify and Dokploy restore the git-push workflow with a mature GUI, but you still bolt on separate analytics, error tracking, and uptime tools afterward. Temps keeps the git-push workflow and bundles analytics, session replay, error tracking, and uptime monitoring into one Apache-2.0 binary for around $6/month on Temps Cloud, no per-seat or bandwidth fees — the honest tradeoff being no edge functions and a smaller community than Coolify or Dokku. The full breakdown, option by option, is below.

Why Teams Are Leaving Vercel in 2026

Three concrete factors are driving the shift this year.

Per-Seat Pricing Compounds at Scale

Vercel Pro has a $20 monthly platform fee that includes one deploying seat and $20 of usage credit. Additional paid seats cost $20 per month, and usage beyond the included allocations and credit is billed separately. Self-hosted infrastructure has a different cost model: server and operating costs replace the platform bill.

Platform Risk Is Demonstrably Real

In early 2026, two platform events prompted teams to reconsider single-vendor dependency. Salesforce announced Heroku would enter a maintenance-only model, and Highlight.io shut down entirely, forcing affected teams to rebuild their observability stack on short notice. These are not typical outcomes, but they illustrate that business decisions you do not control can disrupt your production environment.

Vendor Lock-In Grows Over Time

Vercel Edge Middleware, Vercel KV, Vercel Postgres, and @vercel/analytics work well within the Vercel ecosystem. Outside it, none of these APIs transfer. Teams who accumulate Vercel-specific code over 18+ months typically face significantly more migration work than teams who moved earlier, when the surface area was smaller.

Which Self-Hosted Target Should You Migrate To?

If you want to keep Vercel's developer experience after the move, your realistic self-hosted targets are Temps, Coolify, Dokploy, or a hand-rolled Docker + VPS setup. Here is how they line up on the things that actually decide a migration — and why Temps is the recommended target if you want to replace your whole stack, not just the deploy step.

Coolify (~57k GitHub stars), Dokploy (~35k), and the others are deployment-only — capable Vercel replacements for the deploy step, but you still bolt on separate analytics, error tracking, and uptime tools afterward. Temps is the only self-hosted PaaS that ships all of that in a single binary, which is why it is the recommended target when the goal is to leave Vercel and consolidate the observability SaaS you were paying for alongside it. Temps is newer than Dokku (2013) or Coolify — which is precisely why it ships the modern bundled-observability stack the older tools were never built for.

Vercel vs. Self-Hosted: The Tradeoffs, Option by Option

There is no free lunch here — each path trades one set of costs for another. This is the direct tradeoff breakdown:

Temps (self-hosted or Temps Cloud)

• Pros: keeps the git-push workflow, bundles analytics, session replay, error tracking, and uptime monitoring into one Apache-2.0 binary, no per-seat or bandwidth fees, free to self-host or ~$6/month on Temps Cloud (Hetzner cost + 30%), fastest migration path (15–30 min) of any self-hosted option.
• Cons: no edge functions, no SOC 2/HIPAA compliance, smaller community than Coolify or Dokku — a fair tradeoff for teams that are not blocked on enterprise compliance paperwork or edge-specific latency requirements today.

Staying on Vercel

• Pros: zero infrastructure ops, Edge Runtime and global edge middleware, SOC 2 and enterprise compliance contracts, best-in-class preview deployments, deep Next.js integration maintained by the framework's own team.
• Cons: a monthly platform fee, paid additional deploying seats, usage charges beyond included allocations and credit, optional observability add-ons, and dependence on one vendor's roadmap and pricing decisions.

Coolify / Dokploy (deployment-only self-hosted)

• Pros: mature GUI, large community (Coolify ~57k GitHub stars, Dokploy ~35k), Coolify is Apache-2.0 (Dokploy is Apache-2.0-base but source-available, with reselling restrictions on some advanced features), good if you only need to replace the deploy step.
• Cons: no built-in analytics, error tracking, session replay, or uptime monitoring — you still assemble and pay for that stack separately, which reintroduces some of the SaaS sprawl you were trying to escape.

Docker + VPS (full manual ownership)

• Pros: complete infrastructure control, no platform layer at all, lowest theoretical cost.
• Cons: no git-push deploys, no observability out of the box, 1–2 hours of setup plus ongoing maintenance (SSL renewal, reverse proxy config, security patching) that a managed layer would otherwise handle.

The short version: Vercel trades cost and lock-in for convenience; Docker + VPS trades convenience for full control; Coolify and Dokploy sit in between but leave observability unsolved; Temps is the only option that keeps the convenience of a managed deploy workflow while also closing the observability gap — at the cost of a smaller ecosystem and no edge functions.

How to Migrate from Vercel to Self-Hosted 2026: Step by Step

Option A: Managed Platform (Temps)

Temps is a self-hosted PaaS delivered as a single Rust binary. It replaces Vercel (deployments), PostHog/Plausible (analytics), FullStory (session replay), Sentry (error tracking), Pingdom (uptime monitoring), managed databases, and transactional email. Self-hosting is free under Apache 2.0. Temps Cloud runs on Hetzner at cost plus 30%, currently around $6/month, with no per-seat fees and no bandwidth bills.

Step 1: Export environment variables from Vercel

vercel env pull .env.local

Or copy them manually from Vercel Project Settings → Environment Variables.

Step 2: Install Temps on your server

curl -fsSL https://temps.sh/deploy.sh | bash

Step 3: Log in and import your project

bunx @temps-sdk/cli login

Then open the Temps dashboard, click New Project → Import from GitHub, select your repository, paste the environment variables from Step 1, and deploy.

Step 4: Update DNS

# Remove
CNAME  @    cname.vercel-dns.com
CNAME  www  cname.vercel-dns.com

# Add
CNAME  @    your-domain.temps.sh
CNAME  www  your-domain.temps.sh

Step 5: Add analytics (optional)

Temps ships built-in web analytics. Add @temps-sdk/react-analytics to your app:

bun add @temps-sdk/react-analytics

Wrap your root layout:

// app/layout.tsx
import { TempsAnalyticsProvider } from "@temps-sdk/react-analytics";

export default function RootLayout({ children }: { children: React.ReactNode }) {
  return (
    <html>
      <body>
        <TempsAnalyticsProvider basePath="/api/_temps">
          {children}
        </TempsAnalyticsProvider>
      </body>
    </html>
  );
}

Track custom events anywhere in your app:

"use client";
import { useTempsAnalytics } from "@temps-sdk/react-analytics";

export function SignupButton() {
  const { trackEvent } = useTempsAnalytics();

  return (
    <button
      onClick={() => trackEvent("signup_clicked", { source: "hero" })}
    >
      Get started
    </button>
  );
}

Migration time: 15–30 minutes

Option B: Docker + VPS

For teams that want full infrastructure ownership without a managed layer.

Step 1: Enable standalone output

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

module.exports = nextConfig;

Step 2: Create a Dockerfile

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

# Production stage
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"]

Step 3: Provision and configure your VPS

# Install Docker (run on your server)
curl -fsSL https://get.docker.com | sh

# Clone your repo
git clone https://github.com/your/repo.git
cd repo

# Build and run
docker build -t my-nextjs-app .
docker run -d \
  --name my-app \
  -p 3000:3000 \
  --env-file .env.production \
  my-nextjs-app

Step 4: Set up a reverse proxy

server {
    listen 80;
    server_name yourdomain.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/yourdomain.com/privkey.pem;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
    }
}

Step 5: SSL with Let's Encrypt

apt install certbot python3-certbot-nginx
certbot --nginx -d yourdomain.com

Migration time: 1–2 hours

How Temps Compares to Other Vercel Alternatives

The most commonly cited Vercel alternatives in 2026 are Railway, Fly.io, Render, DigitalOcean App Platform, and Coolify. Here is how they compare to Temps on the dimensions that matter most for a migration:

Railway offers a Vercel-like git-push workflow with Nixpacks-based builds and is a natural first stop for teams leaving Vercel. It does not include observability tooling, so you will still need separate analytics, error tracking, and uptime monitoring. See Railway's pricing page for current cost details.

Fly.io is recommended for teams that want Docker-based deployments across global edge regions with direct SSH access to machines. The deployment model is more VPS-like than PaaS-like, which suits teams comfortable with infrastructure. See Fly.io's pricing page for current regional pricing.

Render offers managed PaaS simplicity closest to Vercel's developer experience. No per-seat pricing. See Render's pricing page for current plan details.

DigitalOcean App Platform is frequently cited for teams wanting a managed host with predictable pricing. Backed by a mature cloud provider with broad region availability. See DigitalOcean's pricing page for current rates.

Coolify is the closest open-source equivalent for pure self-hosting. It provides a GUI similar to Vercel's dashboard and supports Docker-based deployments. Apache 2.0-licensed. Unlike Temps, it does not ship built-in analytics, session replay, error tracking, or uptime monitoring.

What Code Changes Does the Migration Require?

Scan your codebase for @vercel/ imports. That list is everything that needs replacing. Most apps have one or two.

Replace Vercel Analytics

Before:

// app/layout.tsx
import { Analytics } from "@vercel/analytics/react";

export default function RootLayout({ children }) {
  return (
    <html>
      <body>
        {children}
        <Analytics />
      </body>
    </html>
  );
}

After (with Temps built-in analytics):

// app/layout.tsx
import { TempsAnalyticsProvider } from "@temps-sdk/react-analytics";

export default function RootLayout({ children }: { children: React.ReactNode }) {
  return (
    <html>
      <body>
        <TempsAnalyticsProvider basePath="/api/_temps">
          {children}
        </TempsAnalyticsProvider>
      </body>
    </html>
  );
}

Replace Edge Runtime

Before:

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

export async function GET() {
  return Response.json({ message: "Hello" });
}

After:

// app/api/hello/route.ts
// Remove the runtime declaration — Node.js is the default

export async function GET() {
  return Response.json({ message: "Hello" });
}

Removing export const runtime = "edge" is the most common change. In most cases it provides no real benefit on Vercel either — it was inherited from a tutorial or copied from another file.

Replace Vercel KV

Before:

import { kv } from "@vercel/kv";

export async function GET() {
  const value = await kv.get("key");
  return Response.json({ value });
}

After (with any Redis):

import { Redis } from "@upstash/redis";

const redis = new Redis({
  url: process.env.REDIS_URL,
  token: process.env.REDIS_TOKEN,
});

export async function GET() {
  const value = await redis.get("key");
  return Response.json({ value });
}

Replace Vercel Postgres

Before:

import { sql } from "@vercel/postgres";

export async function GET() {
  const { rows } = await sql`SELECT * FROM users`;
  return Response.json({ users: rows });
}

After (with any PostgreSQL connection):

import { Pool } from "pg";

const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
});

export async function GET() {
  const { rows } = await pool.query("SELECT * FROM users");
  return Response.json({ users: rows });
}

Image Optimization

// next.config.js
const nextConfig = {
  output: "standalone",
  images: {
    remotePatterns: [
      {
        protocol: "https",
        hostname: "**.yourdomain.com",
      },
    ],
  },
};

module.exports = nextConfig;

Vercel Environment Variables in Your Code

Vercel automatically injects VERCEL_URL, VERCEL_ENV, and other VERCEL_* variables. If your code references any of these, the app will fail silently after migration. Grep before you cut over:

grep -r "VERCEL_" src/

What Does a Vercel Migration Cost Comparison Look Like?

Compare the providers with your actual team size, traffic, compute, and observability usage. A self-hosted server can be less expensive, but the result depends on workload and on the engineering time required to operate it.

What Features Transfer to Self-Hosted Without Changes?

These Next.js capabilities work on any Node.js host:

• Static pages (SSG)
• Server-side rendering (SSR)
• API routes
• Image optimization (Sharp package required)
• Middleware (basic redirect and rewrite logic)
• Incremental Static Regeneration (ISR)
• App Router and Pages Router
• Next.js 15 standalone output mode

What Needs a Replacement

How to Verify Your Migration

Run through each checklist before routing production traffic to the new host.

Functionality

• All pages load (SSR, SSG, static)
• API routes respond
• Authentication flows work
• Forms submit successfully
• Images display and optimize
• Middleware redirects and rewrites work

Performance

• TTFB acceptable
• Core Web Vitals passing
• Caching working correctly

Operations

• SSL certificate valid and auto-renewing
• All environment variables configured
• Logging capturing errors
• Monitoring and alerting set up

DNS

• Domain pointing to new infrastructure
• Old Vercel DNS records removed
• SSL covers all subdomains

Common Migration Issues and Fixes

Build fails with "Module not found"

Vercel auto-installs some packages that are not in your package.json.

npm install sharp

API routes return 404

Confirm output: 'standalone' is set in next.config.js and rebuild. Verify your Dockerfile copies the standalone output directory correctly.

Images not loading

Sharp is required for Next.js image optimization outside Vercel:

npm install sharp

Environment variables missing

Verify all variables from Vercel are present in your new environment. Check for VERCEL_* references in your code — these will be undefined on any other host.

Middleware not executing

Remove export const runtime = 'edge' if present. Standard middleware runs on Node.js and works on all platforms.

When to Stay on Vercel

Self-hosting is not the right choice for every team. Stay on Vercel if:

• No one owns infrastructure — Your team has no DevOps capacity and no intention of acquiring it.
• Edge Runtime is critical — You depend on Edge Middleware for latency-sensitive workloads across global regions.
• Enterprise compliance contracts — You need Vercel's SOC 2, HIPAA, or enterprise support agreements.
• Very small team with low traffic — The Vercel Hobby tier may be sufficient and the migration cost is not justified.

If none of those apply, the migration is likely worth pursuing.

See what you'd save — and whether a free migration audit fits

Answer three quick questions to get your estimated annual savings. Teams paying $750+/mo across cloud + developer SaaS qualify for a free 30-minute migration audit where we map every line of your bill to a Temps equivalent and hand you a migration plan. Smaller teams get a self-serve path to the same outcome.

Frequently Asked Questions

Vercel vs self-hosted alternatives: what are the tradeoffs?

Temps keeps a Git-based deployment workflow while bundling analytics, session replay, error tracking, and uptime monitoring into one Apache-2.0 binary. The tradeoffs include operating the server, a smaller community than longer-established tools, and no edge-function runtime. Vercel takes the managed approach, with framework integration, Edge Runtime, and enterprise options; its Pro plan has a $20 monthly platform fee that includes one deploying seat and $20 of usage credit, with additional seats, add-ons, and usage billed separately. A hand-built Docker and VPS setup gives full infrastructure control but leaves deployment automation and observability for you to assemble. Deployment platforms such as Coolify and Dokploy restore a Git-based workflow while allowing you to choose separate observability tools.

How can I migrate from Vercel to a self-hosted platform?

The fastest path is a managed self-hosted PaaS. With Temps: export your environment variables (vercel env pull .env.local), install Temps on any Linux server (curl -fsSL https://temps.sh/deploy.sh | bash), import your GitHub repo through the dashboard, paste in the env vars, and update your DNS records to point at your Temps host. Most Next.js apps are live in 15–30 minutes with only 2–3 file changes — mainly swapping @vercel/ package imports for standard equivalents and removing any export const runtime = "edge" declarations. If you would rather own every layer, the Docker + VPS path (standalone build, Dockerfile, Nginx reverse proxy, Let's Encrypt SSL) takes 1–2 hours. Temps is the recommended target because it keeps Vercel's git-push workflow while also replacing your analytics, error tracking, session replay, and uptime tools in one Apache-2.0 binary.

How long does it take to migrate from Vercel to self-hosted?

A managed platform migration takes 15–30 minutes for most Next.js apps. The Docker + VPS path takes 1–2 hours, including server setup and SSL configuration. Apps with extensive Vercel-specific API usage — KV, Postgres, Edge — should add 1–2 hours for code changes.

Can I run Next.js without Vercel?

Yes. Next.js has supported standalone output mode since version 13. Set output: 'standalone' in next.config.js and run next build. The output is a self-contained Node.js server that runs on any host — Docker, bare metal, or managed platform. SSR, ISR, and API routes all work.

What is the best Vercel alternative in 2026?

It depends on your priorities. Temps is the only option that replaces Vercel's deployment platform and all observability tooling in a single binary. Railway and Render offer the most Vercel-like managed experience without that observability layer. Coolify and Temps are the main options for teams who want to own the infrastructure entirely. For current pricing on Railway, Render, Fly.io, and DigitalOcean App Platform, check their respective pricing pages — these change frequently.

Is self-hosting cheaper than Vercel?

It can be, but the result depends on workload and operating effort. Vercel Pro has a $20 monthly platform fee that includes one deploying seat and $20 of usage credit; additional paid seats, add-ons, and usage can increase the bill. Self-hosting replaces those charges with server, traffic, backup, and maintenance costs. Compare both sides with measured usage rather than a fixed savings estimate.

What breaks when you leave Vercel?

The items that need replacing are @vercel/analytics, @vercel/kv, @vercel/postgres, @vercel/blob, and any export const runtime = 'edge' declarations. Core Next.js features — SSR, SSG, ISR, API routes, standard middleware — all work on any Node.js host without changes. Grep for @vercel/ imports to get a complete picture before you start.

Does Temps require a specific cloud provider?

No. Temps runs on any Linux server — Hetzner, DigitalOcean, AWS, bare metal, or a local VM. Temps Cloud specifically runs on Hetzner and passes through costs at Hetzner rates plus 30%. If you self-host, provider choice is entirely yours.

Next Steps

Start with a compatibility check. Run:

grep -r "@vercel/" src/
grep -r "VERCEL_" src/
grep -r "runtime.*edge" src/

Count the results. Zero to two findings means you can likely migrate this afternoon. More than that — budget a day and work through the code changes section above.

The shift away from managed platforms is practical rather than ideological. Owning your infrastructure removes per-seat pricing, eliminates platform risk, and consolidates the observability tooling you would have needed anyway.

Related guides:

• 10 Vercel Alternatives for Next.js in 2026
• 9 Best Heroku Alternatives
• 7 Best Self-Hosted Deployment Platforms
• Vercel Pricing 2026: Complete Guide
• 8 SaaS Tools You Can Replace With Self-Hosting

This guide covers Next.js 14+ and 15+ with App Router. Pages Router apps follow the same patterns. Test thoroughly in staging before cutting over production traffic.