How to Launch Apps on Coolify: The Free Heroku Alternative Step‑by‑Step

Deploy, manage, and scale your web apps on Coolify without spending a dime

Before We Start: What You'll Walk Away With

By the end of this tutorial you’ll be able to spin up a Node.js or Python project on Coolify in under ten minutes, treat the platform’s free‑tier quirks like a familiar restaurant menu, and keep your app’s domain, environment variables, and logs under control without ever leaving the dashboard.

First you’ll grasp the core concepts that Coolify builds on, and you’ll know exactly where the free tier draws the line—think of it as checking the size limits before ordering a large pizza.

Next you’ll push a repo from GitHub, watch the deployment pipeline run, and have a live URL in seconds—just like dropping a pin on Google Maps and getting directions instantly.

Finally you’ll learn to add a custom domain, set secret keys, and read logs directly in the UI, similar to packing a suitcase where every item has its own compartment.

• Core concepts & limits – understand projects, services, and the free tier’s CPU, RAM, and container caps.

• One‑click deployment – clone a GitHub repo, select runtime (Node.js or Python), and hit “Deploy”.

• Management basics – add domains, edit .env variables, and tail logs without SSH.

• Tip: Keep your app under 512 MB RAM to stay within the free tier; it’s like ordering a small coffee instead of a venti.

• Tool: Use the “Metrics” tab to watch resource usage in real time, just as you’d glance at a speedometer while driving.

• Cheat sheet: Deploy → Settings → Logs are the three tabs you’ll visit most often.

Ready to see how easy it really is? Let’s jump into the first steps.

What Coolify Actually Is (No Jargon)

Coolify is an open‑source platform‑as‑a‑service that runs on Docker, giving you a Heroku‑style web UI without the price tag. It abstracts the container plumbing so you can push code, click “Deploy” and let the system spin up a build container, run migrations, and expose a live endpoint.

Imagine a self‑service kitchen: you walk in, drop your recipe card (the source code) on the counter, and the kitchen staff (Coolify) handles chopping, cooking, and plating. You don’t need to pre‑heat ovens or clean the pans – the platform does it all and hands you a ready‑to‑eat dish (your running app).

Because it’s built on Docker, every app lives in its own isolated container, just like each dish gets its own plate. The UI shows logs, env variables, and scaling knobs, so you stay in control without writing docker commands yourself.

Free tier limits are clear: one project, 500 MB RAM, and a 5‑minute build timeout. That’s enough for prototypes, side projects, or a quick demo. If you outgrow those numbers, the open‑source nature lets you spin up your own instance on any cloud.

In a Coolify tutorial you’ll see exactly how to connect a Git repo, set a build command, and launch the app – all from the same dashboard you’d use on Heroku.

Bottom line: Coolify gives you the comfort of a managed PaaS while keeping you in the driver’s seat.

The 3 Mistakes Everyone Makes With Coolify

Here are the three traps that bite most people the first time they try a Coolify tutorial.

Skipping the Docker Compose setup is like ordering a burger without specifying the toppings—you’ll get a mess on the plate. Without a proper docker-compose.yml, Coolify can’t resolve service links, and the build aborts with cryptic errors.

• Run coolify init to generate a starter file.

• Copy the example from the docs and adjust the image names.

Ignoring the free‑tier container quota is similar to trying to drive a car past the fuel gauge’s empty line; you’ll stall without any warning. Coolify silently drops deployments once you exceed the 1 GB limit, leaving you staring at a “deployment failed” badge.

• Check usage in the dashboard before each push.

• Keep images under 500MB to stay safe.

Misconfiguring environment variables feels like packing a suitcase without a passport—everything looks fine until you reach the border and get turned away. A missing DATABASE_URL or a typo in NODE_ENV crashes the app at runtime.

• Define vars in the “Environment” tab, not just in .env.

• Use the “Test” button to validate each entry before saving.

Spot these early and your first Coolify launch will feel like a smooth ride.

How to Deploy on Coolify: Step‑by‑Step

Think of the deployment as ordering a pizza: you pick the crust, add toppings, give the address, and wait for the doorbell.

• Sign up for a free Coolify account, then click Connect Repository and link the GitHub repo that holds your code.

• Pick a project template that matches your stack – Node.js, Python, Ruby, etc. It’s like choosing the pizza size before you add toppings.

Create a .coolify.yml at the root of the repo. Inside, define build: commands and the port your app listens on. Example for a Node app:

build:
  command: npm install && npm run build
port: 3000

• Open the Coolify UI, go to Environment Variables, and add keys such as DATABASE_URL or API_KEY. This step is the sauce that makes everything taste right.

• Hit the Deploy button. Coolify will spin up a Docker container and stream the build log – watch it like a live cooking show.

• When the log finishes, copy the auto‑generated https://your-app.coolify.app URL and open it. If you have a custom domain, add it under Domain Settings and point your DNS records to the provided CNAME.

• Tip: Keep the .coolify.yml simple at first; you can add advanced caching later.

Cheat sheet:

• .coolify.yml – build commands + port

• Env vars – set in UI, not in code

• Deploy – one click, watch logs

Now your app lives on Coolify, ready for traffic.

A Real Example: Deploying a Next.js Blog for Maya the Startup Founder

Maya’s marketing blog is a simple Next.js site, but she wants it live on Coolify without paying a cent.

• Create a GitHub repo called maya-blog and push her local next project.

• Add a .coolify.yml at the repo root so Coolify knows how to build.

• Define the environment variable NEXT_PUBLIC_API_URL in Coolify’s UI.

• When the free‑tier warning appears, click “Ignore limit” to keep the app running.

Here’s what Maya drops into .coolify.yml:

services:
  web:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    env:
      - NEXT_PUBLIC_API_URL=https://api.maya.com

• GitHub repo – Think of it like ordering a pizza: you pick the place (GitHub) and the toppings (your code), then Coolify delivers.

• .coolify.yml – This is the “recipe card” that tells Coolify how to cook your app, just like a recipe tells a chef which ingredients to use.

• Environment variable – Similar to setting your GPS destination, it points the Next.js app to the right API endpoint.

• Free tier limit warning – It’s the “parking meter” notice; you can acknowledge it and keep the spot for a while.

After committing the file, Maya links the repo in Coolify, clicks “Deploy,” and watches the logs turn green. Within minutes, her blog is live at https://maya-blog.coolify.app.

Cheat sheet

• Repo URL: https://github.com/yourname/maya-blog

• Env key: NEXT_PUBLIC_API_URL

• Ignore limit button: bottom of the “Resources” tab

That’s the whole “Next.js on Coolify” recipe, ready for Maya’s next launch.

The Tools That Make This Easier

Grab the tools you already trust, then treat Coolify like a well‑stocked kitchen where every ingredient has its place.

• GitHub – Your code lives here, and a simple push can fire a Coolify build. Think of it like ordering food online; the moment you click “order,” the kitchen starts preparing your dish.

• VS Code – Edit the .coolify.yml file with the Docker linting extension. It’s the kitchen’s timer, warning you before a dish burns.

• Postman – Shoot requests at your freshly deployed API to confirm it’s tasty. Like tasting a soup before serving, it catches flavor issues early.

• Cloudflare DNS – Point your custom domain to Coolify’s load balancer on the free plan. It’s the GPS that directs diners straight to your restaurant’s front door.

• Loki + Grafana – Stack these open‑source tools if you want logs served on a dashboard. Imagine a pantry inventory system that tells you exactly what’s running low.

Cheat sheet

• git push origin main – triggers the deploy.

• code .coolify.yml – opens the config in VS Code.

• Run a GET request in Postman to /health after deployment.

• Set an CNAME in Cloudflare pointing to app.coolify.io.

• Add Loki as a log driver in Docker, then view logs in Grafana.

With these five free‑or‑freemium tools, the Coolify tutorial feels less like a hurdle and more like a smooth ride.

Quick Reference: Coolify Deployment Cheat Sheet

Grab this cheat sheet when you’re ready to push code, and you’ll never wonder which button to click next.

• ✅ Create a free Coolify account – think of it like signing up for a new coffee loyalty card; you just need an email and then link your GitHub so Coolify can pull your repo.

• ✅ Add a .coolify.yml file – this is your recipe card. Define build, start, and ports just like you’d list ingredients, cooking time, and serving size.

• ✅ Set environment variables, Deploy, Verify URL – picture setting the GPS on your phone, hitting “go,” then checking the map’s endpoint to make sure you arrived.

• ❌ Avoid more than 2 containers on the free tier – the free plan is a compact car; squeeze in a third container and you’ll hit the mileage limit.

• 🔧 Use VS Code + Docker lint – Alex, a junior dev, lints his Dockerfile in VS Code before committing, catching syntax errors the same way a spell‑checker catches typos.

• 🔧 Test with Postman – treat each endpoint like a menu item; send a request, taste the response, and confirm the flavor matches expectations.

• Start: Sign up → link GitHub.

• Configure: Add .coolify.yml (build, start, ports).

• Secure: Set env vars in the dashboard.

• Deploy: Click “Deploy” and watch the logs.

• Validate: Open the provided URL, run a quick Postman check.

• Stay within limits: Keep containers ≤ 2, monitor usage in the “Resources” tab.

• Iterate fast: Edit locally, push to GitHub, hit “Redeploy.”

Keep this list open and you’ll breeze through any Coolify tutorial.

What to Do Next

First, lock in the process by pushing a tiny “Hello World” app – it’s the “order a coffee” of Coolify.

Deploy a sample app

- Clone a starter repo, run `git push coolify master`, and watch the build log.

- Verify the live URL returns `Hello World`. If it works, you’ve mastered the basic workflow.

Add a custom domain and enable HTTPS

- Think of this like swapping a restaurant’s generic table number for your own vanity plate.

- In Coolify, go to *Settings → Domains*, add `example.com`, then point the DNS A record to the provided IP.

- Flip the *Enable Cloudflare* switch; Coolify will auto‑issue a TLS certificate.

- Test with `curl -I https://example.com` – you should see `200 OK` and `strict-transport-security` headers.

Set up Loki/Grafana monitoring

- Imagine packing a suitcase for a weekend trip: you need the right tools, not every gadget.

- Deploy the `loki` and `grafana` services from Coolify’s marketplace.

- In each app’s *Env* tab, set `LOKI_URL=http://loki:3100` and enable `LOG_LEVEL=info`.

- Open Grafana, add Loki as a data source, then create a dashboard that tracks request latency across all your services.

These three steps take you from a fresh deployment to a production‑ready stack with visibility into every request.

💬 What’s the biggest hurdle you hit when moving from Heroku to Coolify?

About the Author

Abdullah Sheikh is the Founder & CEO at Exteed, where he leads a team of skilled developers specializing in Web2 and Web3 applications, Custom Smart Contracts, and Blockchain solutions.

With 6+ years of experience, Abdullah has built CRMs, Crypto Wallets, DeFi Exchanges, E-Commerce Stores, HIPAA Compliant EMR Systems, and AI-powered systems that drive business efficiency and innovation.

His expertise spans Blockchain, Crypto & Tokenomics, Artificial Intelligence, and Web Applications; building reliable and smooth web apps that fit the client’s goals and requirements.

📧 info@abdullah-sheikh.com · 🔗 LinkedIn · 🌐 abdullah-sheikh.com