# Coolify and Claude Code: Deploy a Project to Your Own VPS
> Installing Coolify, connecting GitHub, deploying Next.js, domain and HTTPS, MCP, VPS requirements, and troubleshooting. Dollar-denominated technical prices and original limitations.
Source: https://ailoot.ai/blog/en/coolify-claude-code-deploy/
Canonical: https://ailoot.ai/blog/en/coolify-claude-code-deploy/
Language: en
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-087
Revision: sha256-29819d5ecfb8849284629d877f0ac51434d20d578d4affa6a983ec7beaa29522
[Ailoot Documentation](https://ailoot.ai/docs/) — reference materials for working with the service.
## Platform Limitations and Payment Terms in 2026
Key takeaway
Free plans work until you first exceed a limit; after that, an international card is required. Heroku closed its free tier to everyone in 2022 and entered sustaining mode in February 2026. With self-hosted Coolify, you own the server; there is no per-seat billing and no vendor lock-in.
A typical vibe-coder scenario in 2026: you build an MVP in Cursor or Claude Code in an evening, move it to a GitHub repository, open vercel.com → connect the repo → reach the subscription screen → enter your card → get `Transaction declined`.
This is not a bug or a temporary outage.
Railway, Render, Heroku — it’s the same story. Heroku actually closed its free tier to everyone in 2022, and in February 2026 the project entered sustaining mode — no new features and no new Enterprise contracts. For a user with an unsupported card, this means: “the door is closed; go around through an intermediary charging a 20% commission.”
You can pay through virtual Visa cards in Kazakhstan or corporate payment services. But that means +20% to the price, +30 minutes for every transaction, and the risk that your account will be blocked when the payment processor sees a country mismatch.
The original example included three attempts — on Vercel Pro, Railway, and Render.
## What Is Coolify, and How Does a Self-Hosted Platform Work?
Key takeaway
Coolify is an open-source, self-hostable PaaS and a direct alternative to Heroku, Vercel, and Netlify. It installs with a single curl command on any VPS running Ubuntu. Under the hood, it uses Docker + Traefik for reverse proxying and Let's Encrypt for HTTPS. It supports GitHub integration, webhooks for automatic deployments, S3 backups, and 280+ one-click services (PostgreSQL, Redis, MinIO). The self-hosted version is free forever with no limits. It has 55,800 stars on GitHub and an Apache-2.0 license.
Coolify is an open-source project built with Laravel + Docker that turns any blank VPS into an application deployment platform. Install Coolify once, then do everything else through the web interface: connect GitHub, choose a repository, and click Deploy.
The official documentation puts it briefly and precisely:
Coolify is an open-source and self-hostable alternative to Heroku / Netlify / Vercel, etc.
— Coolify GitHub README, https://github.com/coollabsio/coolify
Under the hood, Coolify consists of four parts:
1. **Web interface built with Laravel 12 + Livewire 3 + Tailwind v4** — a dashboard for managing your applications.
2. **Docker + Docker Compose** — each application runs in a container, isolated from the others.
3. **Reverse proxy (Traefik or Caddy)** — receives incoming HTTP/HTTPS traffic and routes it to containers.
4. **Let's Encrypt integration** — automatically issues and renews SSL certificates for all domains.
Key features that make Coolify functionally comparable to Vercel:
| Feature | Vercel | Coolify |
|----|----|----|
| Auto-deploy on git push | ✅ | ✅ (via GitHub webhook) |
| Free HTTPS | ✅ | ✅ (Let's Encrypt) |
| PR preview deployments | ✅ | ✅ (via GitHub App) |
| Environment variables UI | ✅ | ✅ |
| Database backups | ❌ (no databases of its own) | ✅ (to S3-compatible storage) |
| PostgreSQL / Redis / MongoDB | \$20+/month each | ✅ One-click, free |
| Scheduled tasks (cron) | ❌ | ✅ (cron syntax) |
| Per-seat billing | \$20/seat/month | None |
| Vendor lock-in | High (Edge Functions, ISR) | Zero (your Docker) |
| Global CDN | ✅ | ❌ (your VPS only) |
A global CDN is the only thing Coolify doesn’t include out of the box. That’s the honest answer. If your project has a global audience and you need to reduce latency for users in the US and Europe, put Cloudflare in front; it’s free for static content.
Price: **the self-hosted version is free forever** with no limits on the number of applications, servers, or deployments. Coolify Cloud is available for \$5/month for 2 servers + \$3 for each additional one — but the servers themselves are still yours; Coolify Cloud simply hosts the dashboard.
The latest release is **v4.1.0 from May 18, 2026**. New features include the Railpack build pack in beta, audit logging, configuration diffs between deployments, and a native MCP endpoint (read-only). Source: [GitHub releases](https://github.com/coollabsio/coolify/releases).
## Which VPS Should You Get for Coolify in 2026?
Key takeaway
Coolify requires a minimum of 2 vCPU, 2 GB RAM, 30 GB SSD, and Ubuntu LTS (20.04, 22.04, or 24.04). A VPS like this can comfortably run 3–5 vibe-coded projects in parallel.
Coolify’s minimum requirements come directly from the [official documentation](https://coolify.io/docs/get-started/installation):
| Parameter | Minimum | Recommended |
|-------------|----------------------------------|---------------------------|
| CPU | 2 cores | 2–4 cores |
| RAM | 2 GB | 4 GB (with headroom for builds) |
| Storage | 30 GB | 50–80 GB (for images + databases) |
| Architecture | AMD64 or ARM64 (64-bit) | AMD64 |
| OS | Ubuntu LTS 20.04 / 22.04 / 24.04 | 22.04 LTS |
| Root | Required | Via SSH key, not password |
The minimum — 2 GB RAM — is a **hard lower limit**. With 1 GB, the installer gets as far as Docker, runs into OOM (out of memory), and hangs. Don’t skimp on RAM.
Price sources: [Timeweb Cloud](https://timeweb.cloud/services/vds-vps), [FirstVDS](https://firstvds.ru/products/vds_vps_hosting), and [Selectel](https://selectel.ru/services/cloud/vps-vds/).
If you need more power (a 100 GB database, several Postgres instances), get Aeza Dedicated.
What NOT to get:
- **Shared VPS with 512 MB–1 GB RAM** — not enough even for Coolify. This is for static sites on nginx, not for a PaaS.
## How to Install Coolify in 5 Minutes
Key takeaway
Installation is a single curl command from the docs. Once it starts, a web interface appears on port 8000. There you create the first admin user and see an empty dashboard. The actual time from a blank Ubuntu installation to running Coolify is 5–7 minutes, of which 3–4 minutes go to `apt-get install docker`. The script fetches the required dependencies and configures Docker itself; all you need to do is wait for it to finish.
**Step 1. Connect to the VPS over SSH.**
After you create a VPS with the provider, the server’s IP address and root password will appear in an email or in the control panel. Connect from your local machine:
```bash
ssh root@1.2.3.4
```
If the provider gave you an SSH key instead of a password, connect with `-i path/to/key`. From here on, I assume you’re on a fresh Ubuntu 22.04 or 24.04 LTS installation.
**Step 2. Run the Coolify install command.**
One command from the [official documentation](https://coolify.io/docs/get-started/installation):
```bash
curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash
```
The script does three things:
1. Checks the system (Ubuntu LTS? root? AMD64?)
2. Installs Docker and Docker Compose if they aren’t already installed
3. Downloads the Coolify images (`coolify/coolify`, `coolify/realtime`, `traefik`) and runs them in the background via docker-compose
This takes 3–5 minutes. You’ll see `apt-get` logs scroll by, followed by `docker pull`. When you see `Coolify v4.1.0 is now running`, go to step 3.
**Step 3. Open the web interface.**
Open this in your browser:
```
http://1.2.3.4:8000
```
Coolify will show a setup wizard — a form for creating the first user. Enter an email and password and save them. This user automatically becomes an admin; you don’t need any other users yet.
After saving, you’ll land on an empty dashboard: a sidebar on the left with Resources / Projects / Servers / Sources / Notifications / Settings, and a prompt in the center to “Add your first resource.”
**Step 4. Open ports in the provider’s firewall (not UFW).**
Coolify is already running, but from the outside only port 8000 (the dashboard) is accessible. To let users reach your applications, you need to open ports 80 (HTTP) and 443 (HTTPS):
| Port | Purpose |
|----|----|
| 22 | SSH access to the server |
| 80 | Receives HTTP traffic, required for Let's Encrypt validation |
| 443 | Receives users’ HTTPS traffic |
| 8000 | Coolify dashboard (we’ll close this after configuring a custom domain for the dashboard) |
An important pitfall from the official documentation:
Docker uses NAT-based iptables rules that can bypass traditional Linux firewalls such as UFW.
— Coolify Docs (firewall), https://coolify.io/docs/knowledge-base/server/firewall
That means that even if you enable UFW and close all ports, Docker will still expose its containers through iptables. UFW is useless here. The solution is to **open and close ports in the provider’s control panel**, not through UFW. With Timeweb / Selectel / Aeza, you do this in the “Network → Firewall” section of the web console.
**Step 5 (optional). Bind the dashboard to your domain.**
To visit `https://coolify.example.com` instead of `http://1.2.3.4:8000`, create a DNS A record `coolify.example.com → 1.2.3.4`, go to **Settings → Instance Settings → Instance Domain** in Coolify, enter your subdomain, and save. Coolify will request a Let's Encrypt certificate and, a minute later, reload the dashboard over HTTPS.
After that, you can close port 8000 in the firewall — the dashboard will be available over HTTPS on the standard port 443.
## How to Connect GitHub: App or PAT?
Key takeaway
Coolify supports two ways to connect to GitHub: **GitHub App** (recommended) and **Personal Access Token (PAT)**. Use GitHub App: setup takes 5 minutes with the wizard, PR previews work, and permissions can be scoped granularly at the repository level. PAT is an outdated option for legacy cases; it has no preview deployments and carries the risk of global access to all your repositories.
In Coolify, go to **Sources → + Add → GitHub App**. Coolify will show a three-screen wizard:
1. **Name & description** — name the source (enter `github-main`) and optionally add a description.
2. **Configure on GitHub** — a button that takes you to GitHub.com and automatically opens a GitHub App creation form with the correct permissions.
3. **Confirm** — after returning from GitHub, click “Save.”
In the second step, GitHub will ask you to confirm the permissions Coolify requests:
| Permission | Level | Purpose |
|-----------------|------------|----------------------------------------------|
| Contents | Read-only | Clone the repository |
| Pull Requests | Read-write | Create preview deployments and comment on PRs |
| Email addresses | Read-only | Identify commits |
| Metadata | Read-only | List repositories |
These are **minimum permissions** — the GitHub App cannot see your private keys, cannot write to `main`, and cannot access repositories you haven’t explicitly connected.
Personal Access Token (PAT) is the old method; I **recommend not using it**. Downsides:
- PAT grants global access to all your repositories (including private ones)
- PR previews don’t work — that feature is exclusive to GitHub App
- The token lasts a long time (90 days, a year, or indefinitely) — if it leaks, that’s bad
Use PAT only if you work with an organization repository where security policy prohibits GitHub Apps and there is no way around it.
After saving the source in Coolify, you’ll see the GitHub App in the dashboard with a list of connected repositories. When you create a new application, you’ll be able to select any of them with one click.
## How to Deploy a Next.js Project from Claude Code in 6 Steps
Key takeaway
The complete path from a blank Claude Code setup to a live site: 1) run `claude` in an empty folder, describe the project, and Claude generates the code; 2) run `git init && git remote add` (Claude can do this itself via a slash command); 3) push to GitHub; 4) in Coolify, choose “+ New Resource → Application” and select the repository; 5) add environment variables; 6) Deploy. Coolify will detect that it’s Next.js, choose the Nixpacks build pack, build a Docker image in 3–5 minutes, and provide a temporary domain using a free wildcard DNS service with HTTPS out of the box.
**Step 1. Describe the project to Claude Code in an empty folder.**
```bash
mkdir my-vibe-app
cd my-vibe-app
git init
claude
```
In the session:
```
Build a Next.js 14 app router project:
- a home page with a list of users
- /api/users endpoint returns an array from the database
- Postgres via Prisma
- Tailwind for styles
- .env.example with DATABASE_URL
- README.md with instructions for running the project
```
Claude will generate the file structure, package.json, prisma/schema.prisma, and .env.example. Also ask:
```
Create a Dockerfile for production builds and a .dockerignore.
```
This is optional — Coolify will build with Nixpacks even without a Dockerfile. But a Dockerfile gives you control over the process, and it’s faster for larger projects.
**Step 2. Create a GitHub repository and push to it.**
You can do this manually through the GitHub UI + `git remote add origin ...`, but Claude Code can do it itself:
```
/commit-push-pr Initial Next.js app generated with Claude Code
```
Or just say: “Commit everything and push it to a new repository `my-vibe-app` under my account.” Claude will use the `gh` CLI to create a private (or public) repository and make the first push. Source: [official Claude Code command](https://github.com/anthropics/claude-code/blob/main/.claude/commands/commit-push-pr.md).
**Step 3. Create an Application in Coolify.**
In the Coolify dashboard, click **+ New → Application**. A form will open:
1. **Source** — select `github-main` (the GitHub App you connected in the previous H2)
2. **Repository** — select `my-vibe-app` from the list
3. **Branch** — `main`
4. **Build Pack** — Coolify will detect it automatically. If there’s a Dockerfile, it will use `dockerfile`. Otherwise, it will use `nixpacks`. You can override this manually.
5. **Domain** — leave the suggested value for now; it’s temporary and you’ll replace it with your own later
6. **Port** — `3000` for Next.js by default
Save.
**Step 4. Add environment variables.**
In the created application, open the **Environment Variables** tab. Add the variables one at a time:
```
DATABASE_URL=postgresql://user:pass@db-host:5432/mydb
NODE_ENV=production
ANTHROPIC_API_KEY=sk-ant-...
```
If you don’t have a database, create one directly in Coolify: **+ New → Database → PostgreSQL**. Coolify will launch a Postgres container in 30 seconds and provide an internal DATABASE_URL in the format `postgresql://postgres:pass@postgres-xyz:5432/postgres` — put it in your application.
All variables are encrypted in the Coolify database and are not shown in build logs.
**Step 5. Click Deploy.**
In the top-right corner, there’s a blue Deploy button. Live logs will appear in the Logs tab:
```
[stage: clone] Cloning ''
[stage: build] Detected Next.js, using Nixpacks
[stage: build] Installing Node 20, npm 10
[stage: build] npm install (245s)
[stage: build] npm run build (87s)
[stage: deploy] Creating container my-vibe-app-xyz
[stage: deploy] Container started, health check passed
[stage: proxy] Traefik routing configured
[stage: ssl] Let's Encrypt cert issued
```
The first build takes 3–5 minutes (it pulls the Node base image and installs dependencies). Subsequent builds take 60–90 seconds thanks to Docker layer caching.
When the status changes to **Running**, copy the application URL shown in Coolify’s **Domains** field and open that exact URL in your browser. Use that value as `` below; the angle-bracket label is a placeholder, not a real address. Your home page should appear, with HTTPS out of the box. A free wildcard DNS service resolves subdomains containing an IP address. Coolify uses it for temporary domains so you can open the site right away without configuring your own DNS.
**Step 6. Check that everything works.**
Open the application URL from the previous step with `/api/users` appended, for example `/api/users` without duplicating the slash. This is the JSON endpoint created in Step 1; the application’s root URL is the home page. If there’s a 500 error, you’ll see the stack trace in the Logs tab. The most common problem with a first deployment is that DATABASE_URL points to a nonexistent database. Fix it by creating a PostgreSQL instance in Coolify (see step 4 above) and replacing DATABASE_URL.
15 minutes, starting from the moment you order the VPS. In the original example, this workflow took 12–18 minutes on a fresh server.
## How to Configure a Custom Domain and HTTPS
Key takeaway
A custom domain connects in 3 steps: create a DNS A record pointing to the server IP, enter your domain in Coolify’s Configuration instead of the temporary domain, enable Automatic HTTPS, and click Redeploy. Let's Encrypt will automatically issue an SSL certificate 2–3 minutes after DNS propagation (usually 5–30 minutes). The key requirement is that DNS must already resolve by the time you click Redeploy; otherwise, Let's Encrypt validation will fail and you’ll have to wait 12 minutes before the next attempt.
**Step 1. Create a DNS A record in your registrar’s control panel.**
The original examples use domains hosted at Reg.ru, Beget, or Timeweb. The process is the same:
| Record type | Name | Value |
|------------|---------------------------|------------------------|
| A | `app` (or `@` for the root) | `1.2.3.4` (server IP) |
Save it, open a console, and check:
```bash
dig app.example.com +short
# Should return 1.2.3.4
```
If it returns nothing or a different IP, DNS hasn’t propagated yet. Wait 5–30 minutes.
**Step 2. Enter your domain in Coolify.**
In the application, open the **Configuration → General** tab. In the **Domains** field, replace the temporary application URL copied from Coolify with `https://app.example.com` (using your own configured domain). Enable **Automatic HTTPS** (it’s usually enabled by default).
Save and click **Redeploy**.
**Step 3. Wait for the Let's Encrypt certificate.**
The build logs will show:
```
[stage: ssl] Requesting Let's Encrypt cert for app.example.com
[stage: ssl] HTTP challenge sent to /.well-known/acme-challenge/xxx
[stage: ssl] Validation passed, cert issued
[stage: ssl] Cert installed, HTTPS enabled
```
In 2–3 minutes, your site will be available at `https://app.example.com` with a green padlock in the address bar.
What can go wrong with Let's Encrypt (the top 3 issues from the [official troubleshooting guide](https://coolify.io/docs/troubleshoot/dns-and-domains/lets-encrypt-not-working)):
1. **Port 80 is closed in the firewall.** Let's Encrypt validates with an HTTP challenge — it sends a request to `http://app.example.com/.well-known/acme-challenge/xxx`. Validation won’t pass without port 80. Open it in the provider’s firewall.
2. **Cloudflare proxy is enabled (orange cloud).** It intercepts the Let's Encrypt request and returns its own placeholder page — validation fails. The solution is to switch to “DNS only” (gray cloud) or configure a DNS-01 challenge through the Cloudflare API.
3. **DNS hasn’t propagated yet.** If you created an A record 30 seconds ago and immediately clicked Redeploy, Let's Encrypt won’t see your domain. Wait 5–30 minutes for DNS to propagate across servers.
Let's Encrypt rate limit: **5 failed attempts per hour for one domain**, with recovery at a rate of 1 every 12 minutes. If you hit the limit, don’t click Redeploy 10 times in a row; check the logs, fix the problem, and try again in 12 minutes.
## How Does Claude Code Manage Coolify Through MCP?
Key takeaway
Through the Model Context Protocol, Claude Code gets direct access to the Coolify API — you can say “deploy this application” to start a build, check status, read logs, or update environment variables. Starting with v4.1.0 (May 18, 2026), Coolify provides a native MCP endpoint without third-party servers — but it’s read-only for now.
Model Context Protocol (MCP) is a standard from Anthropic that lets Claude Code communicate with external systems (see the [guide to MCP servers](https://ailoot.ai/blog/en/mcp-servers-claude-code/) for more). Connect an MCP server and Claude gets a set of tools it can call. Coolify also provides a native option.
**Native MCP in Coolify v4.1.0 (new in May 2026).**
The v4.1.0 changelog dated May 18, 2026, says:
> Added instance-level MCP support with read-only tools for Coolify resources and API/UI.
Coolify now provides its own MCP endpoint — you can connect Claude Code directly without third-party servers. For now, it’s **read-only** (application lists, statuses, configurations), with no modification operations. But that’s enough for most tasks like “tell me about the infrastructure.”
Connect it through `.mcp.json`:
```json
{
"mcpServers": {
"coolify-native": {
"url": "https://coolify.example.com/api/v1/mcp",
"headers": {
"Authorization": "Bearer "
}
}
}
}
```
Wait for full write access in native MCP in v4.2 or v4.3 — the Coolify team promised it by the end of 2026.
## 5 Pitfalls on Your First Deployment — and How to Avoid Them
Key takeaway
The most common errors on a first deployment are insufficient RAM, a closed port 80, Cloudflare proxy breaking Let's Encrypt, UFW failing to protect Docker, and choosing PAT instead of GitHub App. They’re all covered in the official docs, but it’s easy to run into them without hands-on experience. Below is a 5-point checklist based on the original experience of installing Coolify for the first time.
**Pitfall 1: Less than 2 GB RAM — installation fails with OOM.**
Symptom: `curl install.sh` reaches `docker pull coolify/coolify`, hangs at 70%, then the process is killed with `Killed (signal 9)`. The `dmesg | tail` logs show `Out of memory: Killed process`.
Fix:
```bash
# Create a 4 GB swap file to solve the problem temporarily
sudo fallocate -l 4G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
```
For the long term, upgrade to 4 GB RAM. Coolify works with swap, but builds of large Next.js projects may fail.
**Pitfall 2: UFW is enabled, but Docker still opens ports.**
Symptom: you enabled UFW and closed all ports except 22, but your application is still accessible from the internet on some random port (such as 3000).
The reason, from the [official documentation](https://coolify.io/docs/knowledge-base/server/firewall):
Coolify runs on Docker, which uses NAT-based iptables rules and can bypass traditional Linux firewalls such as UFW.
— Coolify Docs (firewall), https://coolify.io/docs/knowledge-base/server/firewall
Fix: use the **firewall in your provider’s control panel**, not UFW. Timeweb / Selectel / Aeza have a “Firewall” or “Network → Firewall” section where you configure rules at the virtual network level — they work before packets reach Docker.
**Pitfall 3: Cloudflare proxy (orange cloud) breaks Let's Encrypt.**
Symptom: after Redeploy, the logs show `Let's Encrypt validation failed - challenge returned 403`.
Reason: Cloudflare proxies the Let's Encrypt HTTP request and returns its own page instead of your challenge file.
Fix — choose one of two options:
1. **Switch to “DNS only”** (the gray cloud in Cloudflare). Downside: you lose Cloudflare CDN and protection.
2. **Configure a DNS-01 challenge through the Cloudflare API.** In Coolify, go to Settings → SSL Configuration, select the Cloudflare provider, and enter an API token with Zone:Read and DNS:Edit permissions. Let's Encrypt will validate through a TXT record instead of HTTP.
The second option is more complicated to set up, but preserves the Cloudflare proxy.
**Pitfall 4: PAT instead of GitHub App — PR previews don’t work.**
Symptom: you connected GitHub through a Personal Access Token; everything works, but preview deployments aren’t created for PRs. You opened a PR in GitHub, but nothing appeared in Coolify.
Reason: PR previews are an exclusive GitHub App feature. PAT doesn’t receive `pull_request` events through a webhook.
Fix: reconnect GitHub through App. Sources → Add → GitHub App → complete the wizard. You can delete the old PAT source.
**Pitfall 5: “Coolify == Vercel” is not entirely true.**
What Coolify **doesn’t do** out of the box:
| Vercel | Coolify | What to do |
|----|----|----|
| Global CDN | No | Put Cloudflare in front (free for static content) |
| Incremental Static Regeneration | No | `revalidatePath` works only on your server |
| Image optimization | No | Use `next/image` with a local loader or Cloudflare Images |
| Autoscaling during peaks | No | Scale manually; upgrade your VPS |
| Edge Functions | No | Use regular API routes |
If your project is a high-traffic SaaS with a global audience and latency requirements of \< 100 ms worldwide, Coolify isn’t a fit; choose Vercel Enterprise. If you’re a vibe-coder with an MVP you’re testing with 100–1,000 users a day, Coolify covers everything.
The 15 minutes in this guide’s title refers to the happy path for the first deployment of one project. A complete infrastructure setup with monitoring, backups, and alerts takes an evening or two. Be honest with yourself.
## How Much Will You Save in a Year Compared to Vercel?
Key takeaway
There’s a “hidden time tax” of 5–10 hours for initial setup and 1–2 hours a month for maintenance.
The Vercel figures below are the article’s May 2026 scenario estimates, not current quotes. They are only one side of the comparison. Self-hosted Coolify has no license fee, but a VPS, backups, storage, traffic, and operations still cost money. Obtain a quote that meets the requirements above; a numeric VPS price was not supplied in these scenarios, so claiming a fixed saving would be unsupported.
Let **C** be the total monthly infrastructure bill for the chosen VPS, backup storage, extra traffic, monitoring, and any paid dashboard option. Include each expense once. Let **r** be your hourly cost of operations work, using the same currency throughout. The article’s time estimate is 5–10 hours initially plus 1–2 hours per month: **17–34 hours in the first year** and **12–24 hours in later years**.
| Scenario | Vercel estimate/month | Vercel/year | Coolify infrastructure/month | Coolify first-year TCO, including labor | First-year saving versus Vercel |
|----|----|----|----|----|----|
| One prototype, 100,000 visits/month | $20 base + ~$5 bandwidth = $25 | $300 | C | 12C + (17–34)r | $300 − 12C − (17–34)r |
| Five projects on one VPS | $20 base + $30 bandwidth/functions = $50 | $600 | C | 12C + (17–34)r | $600 − 12C − (17–34)r |
| Three developers, five projects | $60 seats + $30 bandwidth = $90 | $1,080 | C | 12C + (17–34)r | $1,080 − 12C − (17–34)r |
Use a separate C for each scenario if the workloads need different server sizes. For a monthly comparison, spread the initial setup time across 12 months: the first-year monthly equivalent is **C + (17–34)r/12**. Later-year TCO is **12C + (12–24)r**. These formulas compare the stated Vercel estimate with self-hosting expenses; include any comparable operations cost on the Vercel side too. A negative saving means self-hosting costs more under your inputs. Do not count the same engineer’s full salary again if r already includes it.
Before switching, fill in C from a real provider quote and backup plan, choose r, then compare actual usage over a month. Without those inputs, the article supports a cost model, not a dollar saving claim.
The main benefit isn’t the money. When you move to Coolify, **the category “dependent on someone else’s payment policy” disappears**. Virtual intermediary cards with a 20% commission are no longer needed.
Coolify isn’t a cheaper Vercel. It’s a different category of product: you own the infrastructure, take responsibility for it, and save money by accepting its complexity.
If deploying a prototype is your first task after generation in Claude Code, then managing the environment (env, secrets, scheduled tasks, backups) is part of [**context engineering**](https://ailoot.ai/blog/en/context-engineering/). Without a structure for “where everything lives,” Claude gets lost, and you lose time on every change.
More materials are available on [Ailoot](https://ailoot.ai/).
## Questions about Coolify and Claude Code: Deploy a Project to Your Own VPS
### Which URL should return JSON after deployment?
Copy the application URL shown in Coolify’s Domains field and open its /api/users path. The root URL is the home page; /api/users is the JSON endpoint specified in the example project.
### How do I calculate whether self-hosting saves money?
Add the monthly VPS, backups, storage, traffic, monitoring, and optional dashboard charges into C. First-year self-hosting TCO is 12C plus 17–34 hours at your hourly cost; compare it with the scenario’s annual Vercel estimate and include comparable operations costs on both sides.
## Ailoot · The company and its project portfolio
Ailoot combines established operating experience, a large client base, stable service and ongoing KPI control.
The company and its project portfolio: millions of customers; monthly sales in the billions.
Ailoot brings that operating experience to API access for AI features in customer products, agents, applications and automations.