Self-Hosting Coolify: A Complete Guide to Your Own PaaS Platform (Laravel-Powered)

Self-Hosting Coolify: A Complete Guide to Your Own PaaS Platform (Laravel-Powered)

Coolify is a modern, open-source, self-hostable Platform as a Service (PaaS) that serves as a powerful alternative to Heroku, Vercel, Netlify, and Laravel Forge. Built primarily with Laravel (PHP), Livewire, Alpine.js, and Tailwind CSS, it enables developers and sysadmins to easily deploy static sites, full-stack applications, databases, and over 280 one-click services on their own servers.

#Why Coolify is Popular in 2025-2026

Coolify addresses key pain points in modern development and deployment:

• Full control over infrastructure without vendor lock-in or high cloud costs.
• Git-based deployments with automatic builds using Nixpacks or Docker.
• One-click services for databases (PostgreSQL, MySQL, Redis, MongoDB), monitoring tools, and more.
• Multi-server support and resource management.
• Developer-friendly UI with real-time logs, resource monitoring, and easy scaling.

It solves problems like complex Docker setups, manual server provisioning, and dependency on proprietary platforms. As of 2026, it boasts strong community growth, frequent updates, and adoption by teams seeking privacy, cost savings, and customization.

This guide provides a complete, actionable walkthrough for beginners to intermediate sysadmins. You can have a production-ready Coolify instance running in under an hour.

#Prerequisites

Hardware Requirements (Minimum):

• CPU: 2 cores
• RAM: 2 GB (4-8 GB recommended for multiple apps)
• Storage: 30 GB free (SSD preferred; more for app data and images)
• 64-bit architecture (AMD64 or ARM64)

Recommended for Production:

• 4+ cores, 8+ GB RAM, 100+ GB storage.

Supported Operating Systems:

• Ubuntu LTS (20.04, 22.04, 24.04) — best compatibility.
• Other Debian, RedHat (AlmaLinux, Rocky), SUSE, Arch, Alpine, or Raspberry Pi OS (64-bit).

Software & Accounts:

• A fresh server with root SSH access.
• A domain name (optional but recommended for HTTPS).
• GitHub/GitLab/Bitbucket account for deployments.
• Basic knowledge of Linux commands, SSH, and Docker.

Security Notes:

• Use a fresh server to avoid conflicts.
• Enable a firewall (UFW or firewalld).
• Set up SSH key-based authentication (disable password login for production).

#Installation Guide

We recommend the quick installation script for most users. All examples assume Ubuntu 22.04/24.04 as root user.

#Step 1: Prepare the Server

Update the system and install basic tools:

apt update && apt upgrade -y
apt install curl git wget jq openssl -y

Configure firewall (UFW example):

ufw allow OpenSSH
ufw allow 8000/tcp   # Coolify dashboard
ufw --force enable

#Step 2: Run the Quick Installation (Recommended)

curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash

Customize with Environment Variables (optional, run before the script):

env ROOT_USERNAME=admin \
ROOT_USER_EMAIL=admin@yourdomain.com \
ROOT_USER_PASSWORD=SuperSecurePass123! \
AUTOUPDATE=true \
bash -c 'curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash'

The installer:

• Installs Docker Engine (v24+).
• Sets up directories under /data/coolify.
• Configures SSH keys for server management.
• Starts Coolify services via Docker Compose.

Manual Installation (for non-LTS or troubleshooting):

1. Install Docker manually from official docs.
2. Create directories:

   mkdir -p /data/coolify/{source,ssh,applications,databases,backups,services,proxy,webhooks-during-maintenance}
   mkdir -p /data/coolify/ssh/{keys,mux}
   mkdir -p /data/coolify/proxy/dynamic
   

3. Generate SSH key:

   ssh-keygen -f /data/coolify/ssh/keys/id.root@host.docker.internal -t ed25519 -N '' -C root@coolify
   cat /data/coolify/ssh/keys/id.root@host.docker.internal.pub >> ~/.ssh/authorized_keys
   chmod 600 ~/.ssh/authorized_keys
   

4. Download files:

   curl -fsSL https://cdn.coollabs.io/coolify/docker-compose.yml -o /data/coolify/source/docker-compose.yml
   # ... (other files: docker-compose.prod.yml, .env, upgrade.sh)
   

5. Set permissions and start: chown -R 9999:root /data/coolify && docker compose -f /data/coolify/source/docker-compose.prod.yml up -d.

#Step 3: Access the Dashboard

After installation, visit http://YOUR_SERVER_IP:8000. Create your first admin account immediately (the registration page is open briefly).

Enable HTTPS (strongly recommended):

• Use Coolify's built-in Let's Encrypt support or a reverse proxy like Traefik/Caddy (one-click in Coolify).

#Configuration

Coolify uses a .env file and Docker Compose for core settings.

Sample .env Excerpt (located at /data/coolify/source/.env):

APP_NAME=Coolify
APP_ENV=production
APP_DEBUG=false
APP_URL=http://your-coolify-domain.com

DB_CONNECTION=pgsql
DB_HOST=postgres
DB_PORT=5432
DB_DATABASE=coolify
DB_USERNAME=coolify
DB_PASSWORD=your_secure_db_password

REDIS_HOST=redis
REDIS_PASSWORD=your_secure_redis_password

# Security
APP_KEY=base64:your_random_key_here
APP_ID=your_unique_app_id

# Advanced
PUSHER_APP_ID=...
PUSHER_APP_KEY=...
# etc.

Key Configurations:

• Docker Networks: Customize address pool via install env vars.
• Auto Updates: Enabled by default; toggle in settings.
• Resource Limits: Set per-project in the UI.
• SSH & Servers: Coolify manages remote servers via SSH keys. Add your first server (the host itself) in the dashboard under "Servers".

Database & Redis: Coolify runs its own PostgreSQL and Redis internally. For production apps, deploy dedicated ones via one-click services.

Environment Variables for Deployed Apps: When deploying a Laravel app, set variables like APP_KEY, DB_CONNECTION, etc., directly in the Coolify project settings.

#Usage: Deploying Your First Application

1. Add a Server (if not using the host): Dashboard → Servers → Add New (provide SSH details).
2. Create a Project: Projects group related resources.
3. Deploy an Application:
   • Select "Application" → Connect Git repo (public/private with SSH key).
   • Choose build pack (Nixpacks auto-detects Laravel, Node, etc.).
   • Set build commands, start command, ports.
   • Add environment variables and persistent storage volumes.

Example: Deploy a Laravel App:

• Repo: Your Laravel GitHub repo.
• Build Pack: Nixpacks.
• Port: 80 or app port.
• Env Vars: Include DB_HOST pointing to a deployed PostgreSQL service.
• Deploy: Click "Deploy". Watch real-time logs.

One-Click Services:

• Databases, WordPress, Ghost, Vaultwarden, etc. — select and deploy in minutes.

Monitoring & Management:

• Real-time CPU/RAM/disk usage.
• Logs, terminal access inside containers.
• Backups (configure scheduled backups).

Testing the Setup:

• Deploy a simple static site or the official Coolify example.
• Access via assigned domain or IP:port.
• Verify database connections and cron/scheduler jobs (Coolify supports scheduled tasks).

#Screenshots and Visuals

Coolify Dashboard Overview
(Imagine a clean, modern UI showing projects, servers, resources, and activity feed. Dark/light mode available.)

Deployment Logs Example
(Terminal output with build progress, successful deployment message.)

Architecture Diagram
Coolify → Docker Swarm/Compose → Apps/Services → Reverse Proxy (Traefik) → Internet.

#Troubleshooting Common Issues

• Installation Fails on Docker: Ensure no Snap Docker; purge and reinstall official Docker.
• Port 8000 Conflict: Check docker ps and stop conflicting containers.
• SSH Connection Issues: Verify keys in ~/.ssh/authorized_keys and permissions (600).
• Database Connection Errors: Double-check env vars and service links in Coolify.
• Out of Resources: Monitor with htop; add swap or upgrade server.
• HTTPS Issues: Ensure domain DNS points correctly; check Let's Encrypt logs.
• Update Problems: Run the upgrade script manually: /data/coolify/source/upgrade.sh.

Logs Location: /data/coolify directories and docker logs coolify.

Join the official Discord for community support.

#References

• Official Docs
• GitHub Repo
• Installation Script Source
• Coolify Examples

#Conclusion

Self-hosting Coolify gives you a powerful, Laravel-driven PaaS that rivals commercial offerings while keeping data under your control and costs low. Benefits include faster deployments, easier management of complex stacks, and scalability across multiple servers.

Next Steps:

• Secure with fail2ban, regular backups, and monitoring (e.g., Uptime Kuma).
• Integrate with CI/CD via webhooks.
• Explore advanced features like private registries, custom Dockerfiles, and AI-assisted deployments.
• Scale by adding remote servers or moving to a cluster.

With Coolify, you transform a simple VPS into a full development and hosting platform. Start small, deploy your first app today, and enjoy the freedom of self-hosting. For questions or custom setups, the vibrant community and detailed docs have you covered.