Easy Self Host Icon

Self-Host Like a Pro using Coolify: Your Own Hosting Platform

Video

Transcript

Hey everyone, welcome back to Easy Self Host.

Today we’re diving into Coolify—the all-in-one self-hosting platform for your apps and side projects.

It gives you the similar experience of services like Heroku or Netlify, but everything runs on your own servers.

Coolify bundles the tricky parts of self-hosting—server management, reverse proxies, SSL certificates, backups—into one smooth package.

In this video we’ll spin up a Coolify server, deploy some pre-built services, a Docker Compose stack, and even our own code.

I’ll use a cloud VPS for the demo, but the steps are mostly the same on a home server.

Along the way I’ll point out key differences—like how to handle SSL certificates.

Alright, let’s spin up our Coolify server.

I’m starting with a fresh DigitalOcean server, but these steps work almost exactly the same on other VPS providers or a home server.

Once the server is live, I’ll SSH in.

Before installing Coolify, I’m adding Tailscale VPN so the Coolify admin portal isn’t exposed to the open internet.

If your server stays on your home network, you can skip this step.

Tailscale is the free mesh VPN I’ve covered on the channel before.

It’s perfect for managing your cloud servers.

Let’s run the install script.

Then bring the Tailscale node up, and log in to the account.

Remember to run Tailscale on your local machine too, so you have a secure path to the server.

In the Tailscale dashboard you should now see both devices.

Next, let’s make sure our server is secure.

Coolify will listen on port 8000, and we don’t want that open to the Internet.

In our VPS firewall, keep only what we need: allow SSH on port 22, and regular web traffic on ports 80 and 443, and—if you want Tailscale to run faster—allow its UDP traffic on 41641.

Everything else should stay blocked.

Apply the rule and we’re set.

Now let’s run Coolify’s install script.

When it finishes it prints a public URL.

Because we blocked port 8000, that URL won’t load.

Instead we can connect through the Tailscale address on port 8000.

On a home server, simply use the server IP and the same port.

First time we log into Coolify, we need to create an admin account.

Coolify then asks where you want to deploy apps.

You can pick localhost—the server we’re on now—or add another server over SSH.

I’ll keep it simple and choose localhost.

That drops us into the main dashboard.

On the left you’ll see Projects—think of them as folders for your apps.

Right now we don’t have any apps, but we will add some later.

Below that is Servers, a list of every server Coolify manages.

Coolify can orchestrate multiple servers, but today we’re working with just this one.

Click the server and you’ll get its settings.

The first thing I like to set is a wildcard domain.

I’ll set it as coolify.ezsh.app, which gives every app on this server an address like something.coolify.ezsh.app.

To make that work, point both coolify.ezsh.app and  .coolify.ezsh.app in your DNS to the server’s IP.

Remember to swap it with your own domain.

If the IP is public, Coolify grabs SSL certificates automatically with Let’s Encrypt.

On a private home server you’ll need a DNS challenge instead.

Open the Proxy tab. You’ll see Coolify’s Traefik config inside a Docker Compose snippet.

Swap the HTTP challenge for a DNS challenge config: delete the two httpChallenge lines and add the two dnsChallenge lines.

The second line names your DNS provider—Traefik’s docs list all supported providers and the variables they need.

I’m using Cloudflare, so I also add the environment variable CF_DNS_API_TOKEN.

That’s all we need to touch for now—we’ll explore the rest of the dashboard when we start deploying apps.

Now let’s deploy our first application from a template in Coolify.

Inside the project, click Add Resource.

Coolify shows a long list of service templates—you’ll recognize many apps I’ve covered before.

Here I’m choosing Docmost as an example.

Coolify pre-fills almost everything for us.

The only tweak I’ll make is the service name and domain.

The default includes a random suffix, so I’ll shorten it to just docmost.

Now hit Deploy and wait for it to run.

Once it finishes, head to that URL.

I find that it takes a few seconds for the reverse proxy to properly set up the domain, so you might see this “connection not private” page.

Just wait for a few seconds and retry.

Now our Docmost app is live.

Let’s quickly test the app.

If we take a closer look, Coolify’s templates are all just Docker Compose under the hood

So we can bring our own Compose files, too.

Let’s deploy Karakeep (also called Hoarder in my previous video) from my custom docker compose file.

Let’s add another resource in the project, and select Docker Compose Empty.

Here is the Docker Compose file, which is mostly the same as in my previous video.

But Coolify adds a touch of magic so your stack hooks into the Coolify UI and Traefik proxy.

Here’s what to notice in the file:

There is an empty environment called SERVICE_FQDN_KARAKEEP_3000

This tells Coolify to proxy requests of the service domain name to the karakeep service on port 3000.

So you don’t have to write proxy rules

NEXTAUTH_URL is meant to be hard-coded with your service domain.

Instead we reference SERVICE_FQDN_KARAKEEP, a global variable Coolify generates from whatever domain we enter later.

Any other global variables like this KARAKEEP_SECRET will become editable in Coolify’s UI.

Click Save, we will get a service generated in Coolify.

I’ll also edit the service name and the domain name prefix to Karakeep.

Then let’s go to the environment variables.

You’ll see all those global variables we’ve referenced

And we can configure them here.

At the bottom we have the SERVICE_FQDN_KARAKEEP, pre-filled with the domain we choose.

Now let’s click Deploy and wait.

When it finishes, open the link.

Let’s click around in the app, and—yep—Karakeep is live and working.

Coolify also lets you deploy code straight from a GitHub repo—perfect for your own projects.

To demonstrate this, I vibe-coded a simple todo app and pushed it to GitHub.

In Coolify, click Public Repository in the resource page, paste the repo URL, and it fetches the code.

I’m using the default Nixpacks builder, which only requires a tiny config file in the repo that tells Coolify how to build and run the app.

My app requires a few environment variables to set up the authentication.

I’ll configure them in Coolify.

After these are set, hit Deploy, and Coolify will build our code, spin up the container, and map the domain.

Depending on the code complexity and the server specs, this process may take a while.

After it finishes, open the link in your browser and you can use my TODO app.

Let’s do a quick testing here.

First, we need to log in with the username and password set with the environment.

Now we are in a Kanban board where we can create and manage our tasks.

Back to Coolify, it also supports a few features to help us manage our deployments.

For example, we can view our container logs directly from the dashboard.

We can also connect to the terminal inside the container to fix something.

These are the essentials of self-hosting with Coolify.

Resources