Deploy Apps with Coolify - A Self-Hosted Alternative to Laravel Forge

Laravel Forge costs $12-39/month depending on features. Ploi, RunCloud, and similar tools have their own pricing. If you're already paying for a VPS, adding another subscription for deployment feels redundant.

Coolify is open source and does most of what these paid tools do. You install it on your server, point it at your Git repos, and it handles deployments, SSL certificates, databases, and more.

What Coolify actually does

You get a web UI for deploying apps from Git, managing environment variables, and spinning up databases. SSL happens automatically via Let's Encrypt. There's also PR preview deployments and basic monitoring.

Under the hood it's all Docker, but you don't need to write Dockerfiles for common frameworks. Nixpacks handles that.

Requirements

You'll need a VPS with:

At least 2GB RAM (4GB recommended)
2 CPU cores minimum
Ubuntu 22.04 or Debian 12 (other distros work but are less tested)
Root access

Coolify installs Docker and everything else it needs.

Installing Coolify

SSH into your server as root:

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

That's the whole installation. The script installs Docker, sets up Coolify, and starts the services. Takes about 2-3 minutes.

Once done, open http://YOUR_SERVER_IP:8000 in your browser. You'll create an admin account on first visit.

Initial setup

After logging in, Coolify walks you through setup:

1. Add your server

Click "Servers" and add localhost. Coolify needs to manage the server it's running on. It verifies the Docker connection automatically.

2. Connect GitHub (optional)

Go to "Sources" and add your GitHub account. This enables automatic deployments when you push code. You can also use deploy keys for individual repos if you prefer.

3. Create a project

Projects are just folders for organizing your apps. Create one and give it a name.

Deploying a Laravel app

Let's deploy a Laravel application:

1. Add a new resource

Inside your project, click "New Resource" and select the application type. For Laravel, you have options:

Nixpacks - Auto-detects Laravel and builds appropriately
Dockerfile - If you have your own
Docker Compose - For complex setups

Nixpacks works well for standard Laravel apps. Select it.

2. Configure the repository

Enter your Git repository URL. If you connected GitHub, you can browse your repos directly.

Set the branch (usually main or master) and the build directory (leave empty for root).

3. Set environment variables

Click the "Environment Variables" tab. Add your Laravel config:

APP_KEY=base64:your-key-here
APP_ENV=production
APP_DEBUG=false
DB_CONNECTION=mysql
DB_HOST=your-database-host
DB_DATABASE=your_database
DB_USERNAME=your_user
DB_PASSWORD=your_password

For the database, you can either use an external one or create one in Coolify (covered below).

4. Configure the domain

Under "Settings", add your domain. Coolify generates SSL certificates automatically via Let's Encrypt.

5. Deploy

Hit "Deploy". Coolify clones your repo, builds the Docker image, and starts the container. First builds take a few minutes.

Setting up a database

Coolify can run databases alongside your apps:

1. Add a database resource

In your project, click "New Resource" and select a database type. PostgreSQL, MySQL, MariaDB, MongoDB, and Redis are available.

2. Configure it

Set the database name, username, and password. Coolify handles the Docker container and persistent storage.

3. Get the connection details

Once running, click on the database resource. You'll see the internal hostname (something like database-xyz123), port, and credentials.

Use the internal hostname in your app's environment variables. Since both containers run on the same Docker network, they can communicate directly.

Automatic deployments

To deploy automatically when you push:

1. Enable webhooks

In your application settings, find the webhook URL. It looks like: https://your-coolify-domain.com/api/webhooks/xxxxx

2. Add to GitHub

Go to your GitHub repo → Settings → Webhooks → Add webhook. Paste the URL, select "application/json", and trigger on push events.

Now every push to your configured branch triggers a deployment.

Deployment previews

Coolify can deploy preview environments for pull requests:

1. Enable PR deployments

In your app settings, turn on "Pull Request Deployments".

2. Configure the preview domain

Set a wildcard domain or let Coolify generate subdomains like pr-123.preview.yourdomain.com.

Each PR gets its own isolated environment. Merged or closed PRs clean up automatically.

Monitoring and logs

Coolify includes basic monitoring:

Logs - Real-time application logs in the UI
Deployment history - See past deployments and roll back if needed
Resource usage - CPU and memory graphs for containers

For serious monitoring, you'll want external tools. But for basic visibility, it's enough.

Backups

Coolify can backup databases to S3-compatible storage:

1. Add a storage destination

Go to Settings → Storage and add your S3 bucket credentials. Works with AWS S3, Backblaze B2, MinIO, or any S3-compatible service.

2. Configure backups

On your database resource, enable scheduled backups. Set the frequency and retention period.

Updating Coolify

Coolify updates itself. Check for updates in Settings → Update. One click applies the latest version.

When Coolify isn't enough

Coolify handles straightforward deployments well. For more complex scenarios, you might outgrow it:

Multi-server deployments - Coolify recently added this, but it's less mature than Kubernetes
Complex networking - Custom Docker networks or service meshes need manual work
High availability - No built-in load balancing between app instances

For most single-server deployments though, it does the job without the monthly fee.

Need a server for Coolify? Our VPS plans start at $5/month with enough resources to run Coolify and several applications. Check availability.