Self-Hosting with Coolify in 2026: Real-World Benchmarks, Cost Breakdown, and Honest Trade-offs vs. Vercel & Render

Take a three-person team on Vercel Pro, 1.5 TB of traffic, and a campaign that pushes 70 million edge requests. By my reading of the published rates, that's a bill near $199. The seats are only $60 of it.

Here's the arithmetic. Pro includes 1 TB of transfer and charges $0.15 per GB after that, so 526 GB of overage is about $79. Edge requests past the included 10M cost $2 per million, so 60M extra is $120. Each seat comes with a $20 usage credit, which absorbs $60 of the $199 in overage. That leaves $60 + $138.90 = $198.90.

This is a modeled scenario, not an invoice. But nobody gets surprised by $20 a seat. They get surprised by the meters underneath it.

The pattern is familiar. You push to Git, you get a preview URL, you never open a terminal. Then a crawler finds your search endpoint, or a teammate joins, or someone merges a route without cache headers, and the bill stops being a rounding error.

Coolify's pitch is that a cheap VPS can act as your own Vercel. v4 left beta in April 2026 after two years and 474 beta releases, and v4.1 added Railpack builds, audit logging, and an MCP server. The software is real now. What's left is whether the ops work eats the savings. Let's find out.

Coolify vs Vercel vs Render: The Hard Numbers

The rate cards (October 2026)

Vercel Pro: $20 per user per month with a $20 usage credit. Active CPU is $0.128/hour, provisioned memory $0.0106/GB-hour, and function invocations $0.60 per million.

Render: In April 2026 the $19-per-member Professional plan became a flat $25/month Pro plan with unlimited members. The catch is bandwidth: Pro includes 25 GB, with $0.15 per GB beyond that, a 20x cut from the legacy plan's 500 GB. Compute is separate: a Starter web service is $7, a Standard (2 GB) is $25, and Postgres Basic-1gb is $19. Key Value Starter is $10.

Hetzner Cloud: The prices you saw in older posts are gone. New orders from June 15, 2026 price the CX23 at €5.49, the CAX11 at €5.99 and the CAX21 at €10.49, while existing instances keep their old price. IPv4 adds €0.50 a month, and 20 TB of traffic is included. One caution: one analysis found the cost-optimized plans labelled "Currently not available" on Hetzner's page. Check the order screen before you plan around a specific SKU. New accounts can start with €20 in credits through my referral link, which covers a CAX21 for nearly two months.

DigitalOcean: The 2 vCPU / 4 GiB Droplet is $24/month with 4 TB of transfer included, and weekly backups add 20%.

What it adds up to

The Render micro-SaaS figure: $25 Pro + $25 web + $7 worker + $19 Postgres + $10 Redis = $86. Then 250 GB of egress less the 25 GB included, at $0.15, adds $33.75. That's about $120, before Postgres storage, which is billed separately at $0.30 per GB.

A few notes the table can't hold:

• Vercel's $20 is deceptive for full-stack apps. It doesn't run your worker, database, or Redis. You buy those elsewhere, and now you have four dashboards and four invoices.
• Previews are free on Coolify until RAM runs out. On Render, previews run as real instances and show up as compute on the bill.
• Logs are a quiet upsell. Vercel keeps runtime logs 1 hour on Hobby, 1 day on Pro, and 3 days on Enterprise. If you need more, log drains cost $0.50 per GB. On Coolify, logs live on your disk until you delete them.

Hands-On Benchmarks: Run These Yourself

I'm not going to invent numbers for you. Every "we measured 42 ms" post you've read without a methodology section is the reason people distrust benchmark posts. What I can give you is a harness you can run in under an hour, plus the figures other people have published.

Setup. Deploy the same Next.js 15+ app (one static route, one route that hits Postgres) to a Coolify box on Hetzner, a Render Standard service, and Vercel Pro. Put all three in or near Frankfurt. Generate load from a fourth machine that isn't on any of those networks. Run each test three times and report the median.

TTFB under 50 concurrent users

In k6, http_req_waiting is time to first byte.

One gotcha: with 50 VUs and sleep(1), k6 tops out around 50 requests per second. That won't stress any of the three boxes enough to separate their p95s. The script below sleeps 0.1 s instead, which raises the ceiling to roughly 500 requests per second. Remove the sleep entirely for a saturation test, but watch the CPU on your load generator.

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  scenarios: {
    ttfb_50vu: { executor: 'constant-vus', vus: 50, duration: '2m' },
  },
  thresholds: { http_req_waiting: ['p(95)<400'] },
};

export default function () {
  const res = http.get(__ENV.TARGET_URL);
  check(res, { 'status 200': (r) => r.status === 200 });
  sleep(0.1);
}

k6 run -e TARGET_URL=https://your-app.example.com/api/dashboard script.js
npx autocannon -c 50 -d 60 https://your-app.example.com/api/dashboard   # quick check

Cold start vs. always-on

sleep 900   # let the platform idle the function out
curl -s -o /dev/null -w "ttfb=%{time_starttransfer}s total=%{time_total}s\n" "$TARGET_URL/api/health"

Repeat ten times, spaced out. Test the Render tier you'd actually pay for, since free instances sleep.

What the architecture predicts

Until you've run the harness, here's what each platform's design suggests. These are expected profiles, not measurements.

What I'd bet on, and why. A persistent container should win on cold starts, since nothing has to boot. It may also win on database-heavy routes, since it can hold open connections to a Postgres sitting on the same host. I'd expect Vercel to win on build speed, since remote caching is its whole business. If your numbers say otherwise, publish them anyway. That's the interesting post.

The overhead you can measure from other people's work

Coolify isn't free in resources. Independent testing puts its idle overhead at 500 MB to 1.2 GB of RAM, depending on whether monitoring is enabled. Idle CPU runs around 5–7%. One measurement put Traefik at roughly 60 MB of that total. Dokploy, a lighter alternative, idles near 350 MB.

On build times, one published data point: a Node app that took 3m20s to build with Nixpacks dropped to 1m45s with Railpack after the first cached build. That's someone else's Proxmox node, so treat it as a direction, not a verdict.

The practical rule: a 4 GB box loses a quarter of its RAM before your app starts. Run Postgres and Redis next to your app on 8 GB.

Production Setup, Step by Step

1. Server and install

Create an Ubuntu 24.04 LTS server on Hetzner Cloud (CAX21 recommended) or DigitalOcean (4 GB Droplet), attach your provider's cloud firewall allowing only 22, 80, and 443 (plus 8000 temporarily), then:

ssh root@YOUR_SERVER_IP
apt update && apt upgrade -y
apt install -y unattended-upgrades
curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash

Read the install script before you pipe it to bash, because it runs as root. Open http://YOUR_SERVER_IP:8000 and create the admin account immediately. Until someone registers, the setup page is open to anyone who finds the port. Then set your instance domain to https://panel.yourdomain.com and close port 8000.

2. Cloudflare DNS and TLS

1. Add an A record for panel.yourdomain.com and a wildcard like *.apps.yourdomain.com, both DNS-only (grey cloud) at first.
2. Let Traefik complete its Let's Encrypt challenge. Coolify configures Traefik v3 automatically from container labels.
3. Switch to Proxied (orange cloud) once certificates issue.
4. Set Cloudflare's SSL/TLS mode to Full (strict). Never Flexible, which creates redirect loops.

3. A Dockerfile worth trusting

Nixpacks infers a build from your repo with no Dockerfile. That's handy for a prototype. For production I'd rather own the build than debug an auto-detection guess at midnight. Set output: 'standalone' in next.config.js, then:

FROM node:22-alpine AS base
RUN apk add --no-cache libc6-compat
WORKDIR /app

FROM base AS deps
COPY package.json package-lock.json ./
RUN npm ci

FROM base AS builder
COPY --from=deps /app/node_modules ./node_modules
COPY . .
ENV NEXT_TELEMETRY_DISABLED=1 NODE_ENV=production
RUN npm run build

FROM base AS runner
ENV NODE_ENV=production PORT=3000 HOSTNAME=0.0.0.0
RUN addgroup --system --gid 1001 nodejs && adduser --system --uid 1001 nextjs
COPY --from=builder /app/public ./public
COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static
USER nextjs
EXPOSE 3000
CMD ["node", "server.js"]

3b. Three Next.js traps when leaving Vercel

Running output: 'standalone' in Docker works. But Vercel quietly handles three things for you, and now you own them:

1. Image optimization CPU spikes. Next.js <Image> optimization runs on the fly inside your container. Without sharp in your production image, Next.js falls back to slower, memory-heavy routines, or fails outright. Add sharp explicitly to your package.json, and cache /_next/image* aggressively at the Cloudflare edge.
2. ISR and data cache persistence. By default, Next.js stores its Incremental Static Regeneration cache on the container's local filesystem (.next/cache). Every fresh deploy gets a fresh container, and that cache starts empty. If you lean on revalidatePath or revalidateTag, mount a persistent volume at .next/cache for a single container, or point a custom cacheHandler at your Coolify Redis instance if you run more than one.
3. Serverless vs. persistent DB connections. On Vercel you need a pooler (PgBouncer, Prisma Accelerate) so hundreds of short-lived functions don't exhaust Postgres. On Coolify, your app is one long-running Node process. Keep your Prisma or Drizzle pool modest (connection_limit=10), because during a zero-downtime rollover the old and new containers both hold connections at the same time.

4. Backups that actually leave the building

In Coolify, go to Storages → Add S3 Compatible, then enable scheduled backups on the database.

Cloudflare R2:  https://<ACCOUNT_ID>.r2.cloudflarestorage.com   region: auto
Backblaze B2:   https://s3.<region>.backblazeb2.com
Schedule:       0 3 * * *     (daily, 03:00 server time)

On cost: Cloudflare R2 charges $0.015 per GB-month with no direct egress fee, and the free tier covers 10 GB. A few gigabytes of nightly dumps costs pennies. Backblaze B2 is $6.95/TB, with free egress up to three times what you store and $0.01/GB after that. That's fine for backups, since you rarely download them. It's not "zero egress" in the R2 sense.

Then do the step everyone skips: restore a backup into a scratch database (pg_restore or psql, depending on the dump format). A backup you've never restored is a hope.

Where Self-Hosting Bites

You own the disk. Builds and image layers pile up. Watch both bytes and inodes:

df -h && df -i
docker system df

Schedule cleanup, but be careful with it. This is safe:

docker image prune -af --filter "until=168h"
docker builder prune -af --filter "until=168h"

Do not add --volumes to a blanket docker system prune on a box that hosts databases. Unused-volume cleanup is how a stopped Postgres container loses its data.

ufw doesn't protect Docker ports. Docker writes its own iptables rules, so a port published by a container can be reachable even if ufw says deny. Use your provider's cloud firewall as the real perimeter, and don't publish database ports.

Your control plane is an internet-facing admin panel. Researchers disclosed 11 vulnerabilities in Coolify in January 2026, including three rated CVSS 10.0. They're fixed in the v4.0.0 stable release. The project responded, but "keep it patched and behind HTTPS" is now your job.

Zero-downtime deploys have gaps. Coolify can't do zero-downtime deploys through Docker Compose today, only via Dockerfile, Nixpacks, or single-image deployments. Know which one your stack uses.

At 3 AM, a single box is still a single point of failure. Hetzner advertises a 99.9% per-server SLA, which by simple math allows about 43 minutes of downtime a month. Coolify v4 can manage multiple remote servers over SSH, so you can offload builds to a dedicated build server or deploy stateless app containers across several nodes behind a load balancer. What it doesn't give you out of the box is automatic database failover or stateful clustering. One small mercy: if the Coolify control plane dies, your deployed containers keep serving traffic. A dead database node is a different story. Your safety net is tested backups, a written rebuild runbook, and an external monitor like Better Stack that pages you.

Email won't work out of the box. Many providers restrict outbound port 25, and fresh VPS IP ranges have weak sender reputation. Use a transactional email service for password resets and receipts.

The decision rubric

Stay on managed PaaS if:

• Nobody on your team wants to be on call for a Linux box
• An hour of downtime costs you more than a month of hosting savings
• Your traffic is spiky enough that scale-to-zero genuinely saves money
• You need multi-region or high availability without building it yourself

Move to Coolify if:

• Seats, previews, or bandwidth are most of your bill, not compute
• Your load is steady and predictable
• You're comfortable reading docker logs and restoring from a dump
• You'll actually apply updates and test backups

The Stack I'd Pick

• VPS: Hetzner Cloud. Best price-to-spec I found, even after the 2026 increases. Mind the IPv4 fee and confirm your plan is orderable. ARM CAX plans are EU-only.
• Alternative VPS: DigitalOcean. Cleaner console and datacenters outside Europe. Per-second billing started January 2026.
• Backups: Cloudflare R2 or Backblaze B2. Both speak S3, and both work with Coolify's backup storage.
• Monitoring: Better Stack or UptimeRobot. Non-negotiable when you're the on-call team. Check their current free-tier limits before you commit.

Frequently Asked Questions

Is Coolify really cheaper than Vercel?

For a solo hobby project on Vercel's free tier, no. Free beats €6 a month. Once you add team seats ($20 each on Vercel Pro), a worker, a database, or traffic past the bandwidth allowance, the gap opens fast. In the micro-SaaS scenario above, the same stack costs about $120 a month on Render and roughly €11 on a Hetzner CAX21 running Coolify.

Can Coolify run Next.js 15 in production?

Yes. With output: 'standalone' in next.config.js and a multi-stage Dockerfile, Coolify runs the App Router, Server Actions, API routes, and middleware without any proprietary adapter. You do take on image optimization, ISR cache persistence, and database connection pooling yourself (see section 3b).

How much RAM does Coolify need?

Independent testing puts Coolify's idle overhead at roughly 500 MB to 1.2 GB, depending on whether monitoring is enabled. It installs on a 2 GB VPS, but that leaves little room. A 4 GB server is workable for the control plane plus a small app. If Postgres and Redis share the box, go to 8 GB so builds don't trigger Linux OOM kills.

What happens if my Coolify control panel crashes?

Your live apps stay online. Coolify orchestrates Docker containers, so if the dashboard process stops, Traefik and your application containers keep serving traffic. You just can't deploy or change settings until it's back.

Does Docker bypass UFW firewall rules on Ubuntu?

Yes. Docker writes its own iptables rules, so a container port published with -p (like 5432:5432) can be reachable from the internet even when ufw says deny. Use your provider's cloud firewall (Hetzner Cloud Firewall or DigitalOcean Cloud Firewalls) as the real perimeter, and keep databases on internal Docker networks without published ports.

Which is better for Coolify database backups: Cloudflare R2 or Backblaze B2?

Both speak S3 and both work with Coolify. R2 includes 10 GB free, charges $0.015 per GB-month after that, and has no direct egress fee, which suits small dumps and frequent restore tests. B2 costs $6.95/TB ($0.00695 per GB-month), about half of R2's per-GB rate, with free egress up to three times what you store, so it gets cheaper as your archives grow.

The Bottom Line

You're choosing which tax to pay. Vercel and Render charge in dollars: seats, meters, and a bandwidth allowance that just got 20x smaller on Render. Coolify charges in attention: patching, backups, and the occasional 3 AM page.

For steady micro-SaaS workloads where bandwidth and workers drive the bill, an ~€11 box is hard to argue with. For a pre-revenue prototype, free tiers still win. If you're on the fence, keep your current platform running for a month, run the k6 script above against both, and let your own numbers settle it.

Sources & pricing notes

Prices checked October 2026 and excluding VAT where noted. Rate cards change often, so re-verify before publishing.

• Render workspace plans: https://render.com/docs/new-workspace-plans
• Render outbound bandwidth: https://render.com/docs/outbound-bandwidth
• Vercel limits and log retention: https://vercel.com/docs/limits
• Vercel pricing calculator (rates verified May 2026): https://makerkit.dev/pricing-calculator/vercel
• Hetzner price adjustment: https://docs.hetzner.com/general/infrastructure-and-availability/price-adjustment/
• DigitalOcean Droplet pricing: https://www.digitalocean.com/pricing/droplets
• Coolify v4/v4.1 overview: https://www.bitdoze.com/coolify-v5-self-hosted-paas-review/
• Coolify vs Dokploy resource use and CVEs: https://www.virtua.cloud/learn/en/concepts/coolify-vs-dokploy-self-hosted-paas