Coolify: Self-Hosted PaaS Alternative to Vercel & Heroku

Image: GitHub

Have you ever been happily deploying your app on Vercel or Heroku, only to see the price tag jump out of nowhere? Or maybe you're fed up paying $20/month just to host a small side project? If so, it might be time to meet Coolify — a PaaS (Platform as a Service) you can run entirely on your own server.

What exactly is Coolify? How do you install and use it? And most importantly, is it a worthy alternative to Vercel or Heroku? Let's break it all down in this article.

What Is Coolify?

Coolify is an open-source PaaS (Platform as a Service) that you can self-host on your own server. Think of it as Vercel or Heroku, but running on your infrastructure — completely free, with no limits.

The project is built with PHP (Laravel) for the backend and Svelte 5 for the frontend. Coolify is distributed under the Apache-2.0 license, so you're free to use, modify, and deploy it however you like.

On GitHub, Coolify has amassed over 60,000 stars — a staggering number for a PaaS project. That alone shows how many developers trust and run Coolify in production.

Why Is Coolify So Popular?

Here are a few reasons Coolify keeps trending in the developer community:

1. Open-source & Free — No monthly fees, no vendor lock-in. Everything stays in your hands.
2. 60K+ GitHub Stars — This isn't some throwaway side project. The community is active and growing.
3. Built with Laravel — Mature, battle-tested PHP, not an experimental framework.
4. 280+ One-Click Services — From databases to CMS platforms, just click to deploy.
5. Docker-based — Everything runs inside containers, keeping things secure and isolated.
6. Automatic SSL — Free HTTPS via Let's Encrypt, configured in seconds.
7. Built-in Monitoring — CPU, RAM, disk, and logs — all visible from the dashboard.

Coolify's Key Features

1. One-Click Deploy

One of Coolify's biggest strengths is its one-click deploy capability. You can deploy an application in just a few clicks without needing deep knowledge of Docker or DevOps.

Supported deployment frameworks include:

• Next.js, Nuxt.js, SvelteKit, Astro — Popular frontend frameworks
• Laravel, Django, Rails, Express — Backend frameworks
• Static sites — Plain HTML/CSS/JS
• Docker Compose — For custom applications

# Deploy from a GitHub repository
# Just enter the repo URL, pick a branch, and click Deploy!
# Coolify automatically detects Dockerfile or buildpacks

2. Managed Databases

Coolify makes it easy to deploy database services:

• PostgreSQL
• MySQL / MariaDB
• MongoDB
• Redis
• SQLite
• Clickhouse

# Example: Deploy PostgreSQL from Coolify
# 1. Open Dashboard > Services
# 2. Click "New" > PostgreSQL
# 3. Enter a database name
# 4. Click Deploy
# 5. Done! The connection string is available immediately

The connection string is ready to copy and paste straight into your application. No manual configuration needed.

3. Automatic SSL (Let's Encrypt)

No more wrestling with manual SSL setup. Coolify automatically configures Let's Encrypt for every domain you add.

# Add a domain in the Coolify Dashboard:
# 1. Open application > Settings > Domains
# 2. Enter domain: myapp.example.com
# 3. Add a CNAME record in your DNS:
#    myapp.example.com -> your-server-ip
# 4. SSL is automatically active within seconds

4. Monitoring & Logs

Coolify's dashboard includes fairly comprehensive built-in monitoring:

• Real-time CPU & RAM usage
• Disk usage monitoring
• Container logs (streaming)
• Health checks
• Deployment history

You can monitor your server and application health without installing additional tools like Grafana or Datadog.

5. Docker-Based Architecture

All applications and services in Coolify run inside Docker containers. This provides several advantages:

• Isolation — Each app is separated and won't interfere with others
• Portability — Easily migrate to any server running Docker
• Reproducibility — The same build always produces the same output
• Resource Control — Set CPU and RAM limits per container

6. Collaborative Features

Coolify also supports team collaboration:

• Multi-user access with role-based permissions
• Team management — Invite team members
• Webhooks & notifications — Alerts to Slack, Discord, or email
• Git integration — Auto-deploy when you push to a specific branch

7. 280+ Services

This is what sets Coolify apart. You can deploy 280+ services with a single click, including:

• CMS: WordPress, Ghost, Strapi, Directus
• Monitoring: Uptime Kuma, Grafana, Prometheus
• DevOps: Gitea, Drone CI, Woodpecker CI
• Database: PostgreSQL, MySQL, MongoDB, Redis
• Message Queue: RabbitMQ, Redis Pub/Sub
• File Storage: MinIO, Nextcloud
• And many more!

Installing Coolify

Prerequisites

Before installing Coolify, make sure your server meets these requirements:

• OS: Ubuntu 20.04/22.04/24.04, Debian 11/12, or any Debian-based OS
• RAM: Minimum 2GB (4GB+ recommended)
• Disk: At least 20GB of free space
• Access: SSH root or sudo access
• Domain: A domain pointing to your server's IP (optional but recommended)

Install via Script (Recommended)

The easiest way to install Coolify is using the official install script:

# SSH into your server
ssh root@your-server-ip
 
# Run the install script
curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash

This script will:

1. Install Docker and Docker Compose if they aren't already present
2. Download all required images
3. Set up a PostgreSQL database for Coolify itself
4. Configure a reverse proxy (Traefik)
5. Generate secret keys and credentials
6. Start all services

The installation typically takes 3-5 minutes, depending on your server's internet speed.

Install via Docker Compose (Manual)

If you prefer a manual setup, here's the Docker Compose configuration:

# docker-compose.yml
version: '3.8'
 
services:
  coolify:
    image: ghcr.io/coollabsio/coolify:latest
    container_name: coolify
    restart: always
    ports:
      - "8000:8000"
    volumes:
      - /data/coolify:/data/coolify
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - APP_ENV=production
      - APP_DEBUG=false
    networks:
      - coolify-network
 
  postgres:
    image: postgres:15-alpine
    container_name: coolify-db
    restart: always
    volumes:
      - postgres-data:/var/lib/postgresql/data
    environment:
      POSTGRES_DB: coolify
      POSTGRES_USER: coolify
      POSTGRES_PASSWORD: your-secure-password-here
    networks:
      - coolify-network
 
volumes:
  postgres-data:
 
networks:
  coolify-network:
    driver: bridge

# Start everything
docker compose up -d
 
# Check status
docker compose ps

After Installation

Once installation is complete, access the Coolify dashboard at:

http://your-server-ip:8000

On first launch, you'll be prompted to create an admin account. Enter your email and a strong password, then log in.

Configuring a Domain for the Dashboard

To avoid accessing the dashboard via IP, you can set up a custom domain:

# Add an A record with your DNS provider
coolify.yourdomain.com -> your-server-ip

In the Coolify Dashboard:

1. Go to Settings > Instance
2. Enter the domain: coolify.yourdomain.com
3. Save — SSL will activate automatically

Using Coolify

Deploying Your First Application

Alright, time to deploy your first app! Let's try deploying a Next.js application:

Step 1: Connect Your Repository

# In the Coolify Dashboard:
# 1. Click "New Application"
# 2. Select "From Git"
# 3. Connect GitHub/GitLab/Bitbucket
# 4. Choose your repository
# 5. Select a branch (usually main)

Step 2: Configure the Build

Coolify will automatically detect that this is a Next.js project. You can override the configuration if needed:

# Example Dockerfile for Next.js
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build
 
FROM node:20-alpine AS runner
WORKDIR /app
COPY --from=builder /app/.next/standalone ./
COPY --from=builder /app/.next/static ./.next/static
COPY --from=builder /app/public ./public
 
EXPOSE 3000
ENV PORT 3000
CMD ["node", "server.js"]

Step 3: Deploy

# Click the "Deploy" button on the dashboard
# Wait for the build to finish (usually 2-5 minutes)
# The app will be automatically accessible on the subdomain

Deploying a Database

Need a database for your application? Just click:

# In the Coolify Dashboard:
# 1. Click "New" > "PostgreSQL"
# 2. Name: my-database
# 3. Username: myuser
# 4. Password: (generate a random one)
# 5. Click "Deploy"
#
# The connection string will be available on the service page:
# postgresql://myuser:***@coolify-db:5432/my-database

Connecting an Application to a Database

After both the database and app are deployed, you need to link them:

# On the application page > Environment Variables
# Add:
DATABASE_URL=postgresql://myuser:***@coolify-db:5432/my-database

// Example in Node.js / Next.js
// lib/db.js
import { Pool } from 'pg';
 
const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
});
 
export default pool;

# Example in Python / Django
# settings.py
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'my-database',
        'USER': 'myuser',
        'PASSWORD': os.environ.get('DB_PASSWORD'),
        'HOST': 'coolify-db',
        'PORT': '5432',
    }
}

Deploying a Custom Docker Compose Stack

If your application needs multiple services, you can deploy using Docker Compose:

# Example: Deploy Laravel + Redis + Queue Worker
version: '3.8'
 
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: laravel-app
    restart: always
    ports:
      - "8080:80"
    environment:
      - APP_ENV=production
      - APP_KEY=${APP_KEY}
      - DB_CONNECTION=pgsql
      - DB_HOST=postgres
      - DB_PORT=5432
      - DB_DATABASE=laravel
      - DB_USERNAME=laravel
      - DB_PASSWORD=${DB_PASSWORD}
      - REDIS_HOST=redis
    volumes:
      - ./storage:/var/www/html/storage
    depends_on:
      - postgres
      - redis
 
  queue:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: laravel-queue
    restart: always
    command: php artisan queue:work --sleep=3 --tries=3
    environment:
      - APP_ENV=production
      - DB_HOST=postgres
      - REDIS_HOST=redis
    depends_on:
      - postgres
      - redis
 
  postgres:
    image: postgres:15-alpine
    container_name: laravel-db
    restart: always
    volumes:
      - postgres-data:/var/lib/postgresql/data
    environment:
      POSTGRES_DB: laravel
      POSTGRES_USER: laravel
      POSTGRES_PASSWORD: ${DB_PASSWORD}
 
  redis:
    image: redis:7-alpine
    container_name: laravel-redis
    restart: always
 
volumes:
  postgres-data:

# In Coolify:
# 1. New Application > Docker Compose
# 2. Paste the docker-compose.yml above
# 3. Add your environment variables
# 4. Click Deploy

Setting Up Auto-Deploy via Webhook

To automatically update your app every time you push to GitHub:

# In Coolify Dashboard > Application > Source
# 1. Enable "Auto Deploy"
# 2. Select branch: main
# 3. The webhook URL will be generated automatically
#
# Copy the webhook URL and add it in GitHub:
# Repository > Settings > Webhooks > Add webhook
# Payload URL: https://coolify.yourdomain.com/webhook/xxxxx
# Content type: application/json
# Events: Just the push event

Monitoring Your Application

Once deployed, you can monitor the application from the dashboard:

# In Coolify Dashboard > Application > Monitor
# - CPU Usage: Real-time graph
# - Memory Usage: Per-container stats
# - Network: In/Out traffic
# - Logs: Streaming logs with filtering

Comparison: Coolify vs Vercel vs Heroku vs Netlify

When Should You Use Coolify?

• You have your own server — VPS, dedicated server, or even a Raspberry Pi
• Limited budget — You don't want to pay $20-50/month for hosting
• You need full control — Server access, logs, and configuration
• Multi-service apps — Database + queue + cache all on one platform
• Privacy-conscious — Your data must stay within your own infrastructure
• Small teams — Collaborative deployment without DevOps overhead

When Should You Use Vercel/Heroku?

• Small projects — Static sites or simple apps that don't need a database
• Zero maintenance — You don't want to manage a server at all
• Large teams — Enterprise features and SLAs are a must
• Global CDN — You need edge deployment across multiple regions

Use Cases: Homelab & Production

Homelab

Coolify is extremely popular in the homelab community — people who run servers at home for learning and hosting personal services:

# Example homelab stack with Coolify:
# 1. Deploy Uptime Kuma (website monitoring)
#    - Click "New" > "Uptime Kuma"
#    - Add domain: status.myhome.lan
#
# 2. Deploy Nextcloud (file sharing)
#    - Click "New" > "Nextcloud"
#    - Add domain: cloud.myhome.lan
#
# 3. Deploy Gitea (self-hosted GitHub)
#    - Click "New" > "Gitea"
#    - Add domain: git.myhome.lan
#
# 4. Deploy Ghost (blog)
#    - Click "New" > "Ghost"
#    - Add domain: blog.myhome.lan
#
# Everything runs on a single VPS / mini PC!

Production Use Cases

For production scenarios, Coolify is also trusted by many companies:

1. Startup MVPs — Deploy an MVP in minutes, not days
2. Agencies/Consultancies — Host all client projects on one platform
3. SaaS Applications — Full-stack apps with databases, queues, and monitoring
4. Internal Tools — Dashboards, admin panels, and internal company tools
5. API Backends — REST/GraphQL APIs with auto-scaling containers

# Example production deployment:
# Server: 4 vCPU, 8GB RAM, 80GB SSD (~$20/month on Hetzner)
#
# Services that can run:
# - Laravel app (main application)
# - PostgreSQL (database)
# - Redis (cache + queue)
# - MinIO (file storage)
# - Uptime Kuma (monitoring)
# - Gitea (source code)
# - Nginx Proxy Manager (reverse proxy)
#
# Total cost: ~$20/month for ALL of this
# Compare with Vercel Pro ($20) + PlanetScale ($39) + Upstash ($10)
# = $69/month

Tips & Best Practices

1. Resource Management

# In Coolify Dashboard > Server > Resources
# Set limits for each container:
# - CPU: Max 2 cores per app
# - RAM: Max 1GB per app
# - Disk: Monitor usage regularly
#
# This prevents one app from consuming all server resources

2. Backup Strategy

# Coolify stores data in /data/coolify
# Set up regular backups:
sudo crontab -e
 
# Add:
0 2 * * * tar -czf /backup/coolify-$(date +\%Y\%m\%d).tar.gz /data/coolify
0 3 * * * docker exec coolify-db pg_dump -U coolify coolify > /backup/db-$(date +\%Y\%m\%d).sql

3. Security Hardening

# 1. Enable a firewall (UFW)
sudo ufw allow 22/tcp
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable
 
# 2. Disable SSH root login
sudo sed -i 's/PermitRootLogin yes/PermitRootLogin no/' /etc/ssh/sshd_config
sudo systemctl restart sshd
 
# 3. Auto-update Coolify
# In Dashboard > Settings > Updates
# Enable "Auto Update"

4. Performance Tips

# For servers with limited RAM (< 4GB):
# 1. Use Alpine images for all services
# 2. Limit concurrent builds: Settings > Builds > Max concurrent: 1
# 3. Disable unnecessary monitoring
# 4. Use swap as a safety net:
sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

FAQ

Is Coolify safe for production?

Yes, Coolify uses Docker containers for isolation, data encryption, and automatic SSL. Many companies already run it in production. That said, make sure you also follow security best practices like firewalls, SSH hardening, and regular backups.

What's the minimum RAM required?

A minimum of 2GB RAM is needed, but 4GB+ is recommended if you're running multiple services simultaneously. To save on RAM, use Alpine images and limit resources per container.

Can I run it on a cheap VPS?

Absolutely! Coolify runs fine on a VPS costing $5/month (1 vCPU, 2GB RAM) for small projects. For production, a $10-20/month VPS is more than sufficient.

Is there a user-friendly admin panel?

Yes! Coolify features a modern, web-based dashboard that's very intuitive. You can deploy, monitor, and manage all your services from a single page.

What about support and documentation?

Coolify has comprehensive documentation at docs.coollabs.io, an active community on Discord, and GitHub Issues for bug reports. For enterprise features, paid support is also available from the Coolify team.

Conclusion

Coolify addresses a problem developers have long faced: how to deploy applications easily without vendor lock-in and expensive monthly fees.

With 60K+ stars, support for 280+ services, and a Docker-based architecture, Coolify is a serious contender as an alternative to Vercel, Heroku, and Netlify — especially if you want:

• Full control over your infrastructure
• Predictable hosting costs (just pay for the server!)
• Flexibility to deploy anything
• Better data privacy

If you're curious, try installing Coolify on your VPS now. Within 5 minutes, you could have your own powerful, free-forever deployment platform.

Links:

• Website: coolify.io
• GitHub: github.com/coollabsio/coolify
• Docs: docs.coollabs.io
• Discord: discord.gg/coolify

This article was written in August 2026. Features and pricing may change over time. Always check the official documentation for the latest information.