Coolify

Coolify is an open-source, self-hosted platform as a service: you point it at a Git repository and it builds, runs and serves your app on servers you own. It gives you the 'push and it deploys' experience of a hosted platform without handing your apps to someone else's cloud.

What a platform as a service does

Getting an app onto the internet by hand means a long list of jobs: rent a server, install Docker, build an image, start a container, open the right ports, point a domain at the server, set up a reverse proxy and get an SSL certificate so the site works over HTTPS. Each step is simple on its own, but a mistake in any one of them breaks the whole thing, and you have to repeat most of them every time you ship.

A platform as a service (PaaS) takes those jobs off your hands. You give it your code and a few settings, and it does the building, running and routing for you. Heroku made the idea popular, and platforms such as Vercel and Netlify do the same for front-end apps. The catch is that the platform runs on the provider's machines, on the provider's terms and prices.

Coolify describes itself as an open-source alternative to those platforms. The difference is where it runs: you install it yourself, and it deploys onto servers you control.

What 'self-hosted' changes

With Coolify you own the whole stack. The servers are yours: a virtual machine from any cloud provider, a dedicated box, or a machine at home. Coolify connects to each one over SSH, prepares Docker on it, and from then on manages your apps there.

That has a few useful consequences:

• You can host anywhere. Moving to a cheaper provider means adding a new server in Coolify, not rewriting your deployment.
• Your apps are ordinary Docker containers. Coolify is the control panel, not the runtime. Its documentation says that if the Coolify instance goes offline, the containers it deployed keep running.
• The code is open. Coolify is released under the Apache 2.0 licence, so you can read how it works and run it without a subscription. There is also a paid Coolify Cloud, where they host the control panel and you still bring your own servers.

If you are weighing up owning servers against renting managed services in general, the trade-offs in Cloud vs. on-prem apply here too.

What happens when you deploy

The core workflow is connecting a Git repository. Coolify works with GitHub, GitLab, Bitbucket and Gitea, and it can deploy again automatically whenever you push to the branch it watches.

Here is one push, from your laptop to a visitor's browser:

Building the app

Coolify needs to turn your repository into a container image, and it offers several ways to do that, called build packs:

• Nixpacks or Railpack, which inspect your code (a package.json, a requirements.txt) and work out how to build it without any config from you.
• A Dockerfile of your own, when you want full control over the image.
• Docker Compose, for an app made of several containers that belong together.
• A prebuilt image from a registry, when something else already builds it.

The automatic options are the fastest start. A Dockerfile is worth the extra effort once you care about image size, the exact runtime version or what ends up inside the container; Distroless Images covers how far you can take that.

The proxy and HTTPS

Every server Coolify manages runs a reverse proxy (Traefik by default, with Caddy as an option). The proxy listens on ports 80 and 443 for the whole server and forwards each request to the container that owns that domain. That is how many apps can share one server and one IP address.

When you give an app a domain and point the domain's DNS at your server, the proxy requests a certificate from Let's Encrypt and renews it before it expires. You never copy certificate files around by hand. Before you have a domain, Coolify can generate a temporary sslip.io address from the server's IP so you can test straight away.

Databases and one-click services

Most apps need somewhere to keep data. In Coolify a database is just another resource in your project: pick PostgreSQL, MySQL, MongoDB, Redis or another engine, and it starts in its own container with a persistent volume and generated credentials. Scheduled backups can be sent to S3-compatible storage.

Beyond databases, Coolify keeps a catalogue of preconfigured services (analytics tools, CMSs, monitoring and more) that you can start from a template. Frontends, backends, background workers and databases all sit together in one project on one dashboard, rather than spread across several providers.

A worked example: an API with Postgres

Say you have a small Node.js API that reads from PostgreSQL:

// server.js
const http = require("http");
const { Pool } = require("pg");
 
const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
});
 
http
  .createServer(async (req, res) => {
    const { rows } = await pool.query("SELECT now()");
    res.end(JSON.stringify(rows[0]));
  })
  .listen(process.env.PORT || 3000);

Nothing in the code knows about Coolify. It reads its settings from environment variables, which is what makes it easy to deploy anywhere. In Coolify you would:

1. Create a project and add a PostgreSQL database to it.
2. Copy the database's internal connection URL, which works from other containers on the same server.
3. Add a new application from your Git repository and let Nixpacks detect that it is a Node app.
4. Set DATABASE_URL to the URL from step 2, and tell Coolify the app listens on port 3000.
5. Give it a domain such as api.example.com, with an A record pointing at the server.
6. Deploy.

From then on, every push to the branch builds and ships a new version, and the API is served over HTTPS without you touching the proxy or the certificate.

Trade-offs

Self-hosting is not free of work. It moves the work.

• You are the operations team. Coolify automates deployments, but the server underneath is yours to patch, monitor and pay for. If the disk fills up at 3am, nobody else gets paged.
• One server is one point of failure. A managed platform spreads your app across its own infrastructure. A single virtual machine is only as reliable as that machine.
• The dashboard is the product. The video found setup excellent, with one-click options everywhere, but rated the interface lower for being inconsistent from screen to screen. Expect some hunting for settings while you learn it.
• Costs scale differently. A hosted platform charges per app, per build minute or per user. With Coolify you pay for the servers, however many apps you fit on them.

When to use it

Coolify fits well when you run several small apps, side projects or internal tools and want them on servers you already pay for, or when you need your data to stay on machines you control. It is also a gentle step up from deploying by hand, because everything it creates is a normal Docker container you can inspect.

A fully managed platform is the better fit when nobody on the team wants to look after servers, when you need traffic spread across regions, or when your app depends on a provider's own features such as edge functions.

Common mistakes

• Leaving the admin sign-up open. The first account created on a fresh install becomes the admin, with root access to the server. Create it as soon as the installer finishes.
• Forgetting DNS and ports. The certificate can only be issued once the domain points at the server and ports 80 and 443 are open.
• Running out of resources. The docs recommend at least 2 CPU cores and 2 GB of RAM for the server that runs Coolify. Builds are the heavy part, so a small server that runs apps comfortably can struggle to build them.
• Keeping backups on the same server. A backup that lives next to the database disappears with it. Send backups to separate storage.

Key takeaways

• Coolify is an open-source, self-hosted platform as a service that deploys apps onto servers you own.
• Connect a Git repository and it builds the app, runs it in Docker containers and redeploys on every push.
• A reverse proxy on each server routes domains to containers and handles HTTPS certificates automatically.
• Databases and common services are one-click resources that sit beside your apps in one dashboard.
• You trade a hosting bill and some lock-in for looking after the servers yourself.