How to Migrate from Vercel to Coolify 2026
How to Migrate from Vercel to Coolify 2026
Vercel's Pro plan costs $20/user/month, and bandwidth overages add up quickly for high-traffic sites. Coolify gives you the same git push deployments, automatic SSL, and preview deployments — self-hosted on your own VPS. Here's how to migrate and what to expect.
TL;DR
Install Coolify on a VPS (one-line installer), connect your Git repository, map your Vercel build settings, set environment variables, point your domain's DNS to Coolify, and push. Preview deployments, SSL, and rollbacks all work. The main limitation: you lose Vercel's global edge network — your app runs on one server instead of 100+ edge locations.
Key Takeaways
- Coolify supports any Nixpacks-detected framework: Next.js, Nuxt, SvelteKit, Remix, Astro, and more
- Git push deployments, preview URLs for PRs, automatic SSL — all built in
- You lose Vercel's global edge network and Edge Runtime
- Serverless functions run as regular server-side code (Node.js), not true serverless
- For static sites and standard SSR apps, the edge network difference is rarely significant
- Cost comparison: $20+/month/user on Vercel vs $10-20/month total VPS for Coolify
Why Teams Leave Vercel
Vercel's pricing model compounds at scale. The Pro plan is $20/user/month — a 5-developer team pays $100/month before any bandwidth or build minutes. Bandwidth at $0.40/GB adds up for image-heavy or high-traffic sites. Teams that deploy frequently hit build minute limits and face overage charges.
For applications where edge distribution genuinely matters (global user bases needing sub-100ms latency), Vercel's edge network is worth the cost. But most internal tools, B2B SaaS products, and content sites serve audiences concentrated in one or two regions. For these, a well-configured VPS serves requests in 50-100ms from a single geographic location — imperceptible to users in that region.
Compare Coolify vs Dokku if you're deciding between the two major self-hosted Heroku/Vercel alternatives. Coolify's web UI and Docker Compose support make it more versatile; Dokku's CLI-first approach and buildpack compatibility make it a better Heroku drop-in. For the full landscape, see best one-click deploy platforms open source.
Step 1: Set Up Coolify
# Install on a VPS (Ubuntu/Debian)
curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash
The installer sets up Docker, configures the Coolify agent, and starts the web dashboard. Access at http://your-server-ip:8000 and create your admin account.
For production, put Coolify behind a reverse proxy with SSL, or use Coolify's built-in domain management (it can serve itself over HTTPS with automatic certificate management). Configure your DNS with an A record pointing coolify.yourdomain.com to your server IP.
VPS sizing:
- Single app, low traffic: 2 vCPU, 2 GB RAM ($6-10/month Hetzner/DigitalOcean)
- Multiple apps or build-heavy: 4 vCPU, 8 GB RAM ($20-40/month)
- Production with databases: 8 vCPU, 16 GB RAM ($50-80/month)
Step 2: Connect Git Repository
- New Resource → Application
- Connect GitHub/GitLab (OAuth) or use a deploy key for private repos
- Select your repository and branch
- Coolify auto-detects the framework via Nixpacks (Next.js, Nuxt, SvelteKit, etc.)
For GitHub: configure the Coolify GitHub App in Settings → Source Providers. This enables:
- Automatic deployments on push
- PR preview deployments
- Status checks on pull requests
Step 3: Configure Build Settings
Map your Vercel settings to Coolify:
| Vercel Setting | Coolify Setting |
|---|---|
| Framework Preset | Auto-detected (or manual Nixpacks/Dockerfile) |
| Build Command | Build command |
| Output Directory | Publish directory |
| Install Command | Install command |
| Node.js Version | Base image (or NIXPACKS_NODE_VERSION env var) |
| Environment Variables | Environment variables (UI) |
| Root Directory | Base directory |
| Ignored Build Step | Not directly supported |
For Next.js apps, Coolify sets up a Node.js server that runs next start — this works for all Next.js features including API routes, Server Actions, and streaming. The difference from Vercel is that this runs as a persistent server process rather than serverless functions.
Specifying Node.js version:
# As environment variable
NIXPACKS_NODE_VERSION=20
# Or create .nvmrc in your project root
echo "20" > .nvmrc
Step 4: Set Up Domain and SSL
- Point your domain's DNS A record to your Coolify server IP
- In Coolify → Application → Domains → add
yourdomain.com - Enable HTTPS — Coolify provisions Let's Encrypt certificates automatically
- Add
www.yourdomain.comas an alias if needed
SSL is configured automatically. Coolify handles certificate provisioning, renewal, and rotation without any manual action. The Traefik reverse proxy that Coolify uses internally manages certificate lifecycle.
For multiple domains on the same server, Coolify routes traffic to the correct application based on the Host header — standard virtual hosting via Traefik.
Step 5: Migrate Environment Variables
# Export from Vercel
vercel env pull .env.production
Add each variable in Coolify → Application → Environment Variables. Coolify distinguishes between:
- Build-time variables (available during
npm run build) - Runtime variables (available to the running application)
- Secret variables (hidden in UI after saving)
For NEXT_PUBLIC_* variables (exposed to the browser), set them as build-time variables. For server-only secrets (database URLs, API keys), set as runtime secrets.
Step 6: Handle Serverless Functions
This is the main architectural difference. Vercel runs Next.js API routes as serverless functions that spin up on demand. Coolify runs your Next.js app as a persistent Node.js process.
Next.js API routes: Work identically. Coolify runs next start, which handles /api/* routes as regular Express-like handlers. The only difference is cold starts don't exist — the process is always warm.
Server Actions: Work identically on Coolify. Server Actions are part of the Next.js server runtime, not Vercel-specific.
Edge Runtime: Vercel's Edge Runtime (export const runtime = 'edge') is Vercel-specific. On Coolify, these routes fall back to the standard Node.js runtime. For most use cases, this makes no difference. If you use Edge Runtime specifically for geographic distribution of API responses, this is a genuine feature gap.
What you lose:
- True serverless scaling (auto-scale to zero, auto-scale to many)
- Vercel's edge network (global CDN-level API execution)
- Edge Runtime specific features (
EdgeConfig,waitUntil, etc.) - Automatic function isolation (a memory leak affects the whole server, not just one function)
What you gain:
- Persistent connections (WebSockets, long-polling work without workarounds)
- No cold start latency
- No function size limits
- No execution time limits (no 10-second limit on API routes)
Step 7: Set Up Preview Deployments
Coolify supports PR preview deployments:
- Application → Settings → enable Preview Deployments
- PRs automatically get a unique URL like
pr-123.app.yourdomain.com - Merged PRs clean up automatically
Preview deployment URLs are temporary and use Coolify's wildcard subdomain configuration. Set up a wildcard DNS record: *.app.yourdomain.com → your-server-ip.
Step 8: Rollbacks
Coolify maintains deployment history and supports rollbacks:
- Application → Deployments → click any previous deployment
- Click Rollback — the previous build is redeployed without rebuilding
- Zero-downtime rollback via Coolify's blue-green deployment model
This matches Vercel's rollback functionality. Previous deployments are retained in Coolify's database along with their build artifacts, allowing instant rollback to any historical deployment.
Cost Comparison
| Scenario | Vercel Pro | Coolify + VPS | Savings |
|---|---|---|---|
| 1 developer | $20/month | $10/month (VPS) | $120/year |
| 3 developers | $60/month | $20/month | $480/year |
| 5 developers | $100/month | $30/month | $840/year |
| + bandwidth overage | $100-500+/month | $0 | $1,200-6,000/year |
The savings scale significantly if you have bandwidth-heavy applications. Vercel charges $0.40/GB of bandwidth beyond the included amount. A site serving 1 TB/month pays $200/month extra in bandwidth — more than the VPS hosting cost.
Migration Timeline
| Day | Task |
|---|---|
| Day 1 | Install Coolify, connect repo, configure build settings |
| Day 2 | Set up domain, SSL, environment variables |
| Day 3 | Test deployment end-to-end, verify all routes work |
| Week 2 | Switch DNS to Coolify, monitor for issues |
| Week 3 | Cancel Vercel (after confirming all traffic on Coolify) |
Common Pitfalls
Build memory: Coolify's default build memory limit may cause out-of-memory errors for large Next.js apps with many pages (100k+ static pages, large bundles). Increase the Docker build memory limit in Coolify's server settings if you see OOM errors during build.
Image optimization: Vercel's image optimization (next/image) is served from Vercel's CDN by default. On Coolify, image optimization runs on your server. For image-heavy sites, ensure your server has sufficient CPU and memory for concurrent image processing, or configure a CDN (Cloudflare, BunnyCDN) in front of your Coolify server.
Static assets and CDN: Vercel automatically serves static assets from a global CDN. On Coolify, static assets are served from your server. Add Cloudflare (free tier) or another CDN in front of your domain to cache static assets globally and reduce load on your server.
Zero-downtime for long deploys: Coolify's default deployment strategy may cause brief downtime during deploys for apps with long startup times. Configure a health check endpoint and enable Coolify's zero-downtime mode to avoid this.
Post-Migration: Observability and Operational Readiness
One of the most significant differences between Vercel and Coolify is the observability layer. Vercel provides an integrated dashboard showing request volume, error rates, function execution times, and build history without any configuration. With Coolify, you have the deployment platform but no application observability by default.
Before considering the migration complete, set up at minimum an uptime monitor and an error tracker. For uptime monitoring, Uptime Kuma is the most popular self-hosted option — it takes about 10 minutes to deploy on the same VPS as Coolify and immediately gives you HTTP monitoring with Slack, email, or PagerDuty notifications on downtime. For error tracking, the Sentry to GlitchTip migration guide covers a Sentry-compatible self-hosted error tracker that works with any Next.js application by changing a single DSN URL. Together, these two tools replicate the most critical observability features of Vercel's dashboard.
For infrastructure metrics — CPU, memory, disk, and network usage on your VPS — Coolify's dashboard shows basic server health. For more detailed monitoring, install Netdata or a Prometheus exporter on the server. Netdata is the lowest-friction option: a single install command gives you a real-time metrics dashboard within minutes.
Log aggregation is another gap. Vercel shows function logs in the dashboard in real time. With Coolify, application logs are in Docker container log files on the server. For debugging, docker logs --tail 100 container-name is sufficient. For production log management with search and alerting, the Better Stack alternatives guide covers Grafana Loki as the standard self-hosted log aggregation solution, deployable on the same VPS.
Deploying Databases and Services Alongside Applications
One advantage Coolify has over Vercel that is often overlooked is its ability to deploy databases, background workers, and other services alongside your application — all managed from the same dashboard. Vercel's Postgres and KV services add monthly cost and are tightly coupled to Vercel's platform. Coolify supports deploying PostgreSQL, MySQL, Redis, MongoDB, and many other services as first-class resources on the same server or on dedicated database servers connected via Coolify's server management.
For a typical Next.js application that needs PostgreSQL and Redis, you can provision both in Coolify within minutes, connect them via environment variables, and your application has a complete backend without any external service dependencies. This setup eliminates the per-GB and per-request costs that Vercel's managed database services charge, replacing them with the flat cost of server storage and compute.
The Coolify vs CapRover vs Dokploy comparison is useful if you are evaluating different self-hosted PaaS options before committing. The Coolify vs CapRover vs Dokploy comparison and the Coolify vs Vercel cost comparison both provide detailed breakdowns of the technical and financial differences.
The Bottom Line
Coolify is the right choice for teams that want Vercel-like deployment UX without Vercel's per-seat pricing. You get git push deployments, automatic SSL, preview URLs, and a polished web dashboard — at the cost of managing a VPS and accepting a single-region deployment instead of Vercel's edge network.
For teams where the edge network genuinely matters (global API performance, ISR at the edge), Vercel's value proposition is real. For the majority of applications — content sites, B2B SaaS, internal tools, developer portfolio projects — a well-configured VPS on Coolify delivers equivalent performance for users in your primary geographic market.
Compare deployment platforms on OSSAlt — features, pricing, and self-hosting options side by side.
See open source alternatives to Vercel on OSSAlt.