---
title: From code to production in 10 minutes with Coolify
description: >-
  Deploy a web app on Coolify in 10 minutes. Covers Dockerfile vs Nixpacks, port
  configuration, and custom domain setup with SSL.
date: '2026-04-15'
lastUpdated: '2026-04-16'
keywords:
  - deploy app on coolify
  - coolify deployment guide
  - coolify dockerfile deploy
  - coolify custom domain setup
  - self-hosted PaaS
  - coolify nixpacks
  - coolify getting started
  - managed coolify hosting
type: article
author: Ross Hill
locale: en_CA
site_name: MapleDeploy
slogan: Powerful hosting on Canadian soil
organization_url: 'https://mapledeploy.ca/'
logo: 'https://mapledeploy.ca//api/logo/lockup'
creator: MapleDeploy
publisher: MapleDeploy
founding_date: '2026-01-13'
email: hello@mapledeploy.ca
geo_region: CA-ON
geo_placename: Toronto
address_country: CA
area_served: Canada
application_category: DeveloperApplication
app_url: 'https://app.mapledeploy.ca'
llms_txt: 'https://mapledeploy.ca/llms.txt'
offers: >-
  Starter $45/mo, Pro $95/mo, Ultra $195/mo, Ultra 32 $395/mo, Ultra 64 $695/mo
  CAD
in_language: en-CA
canonical_url: 'https://mapledeploy.ca/blog/deploy-app-coolify-guide'
---

You have a working application on your machine. A Next.js frontend, a Python API, a Go service. It runs locally. Now you need it on the internet, with a real URL, SSL, and a deployment workflow that doesn't require a systems engineering degree.

[Coolify](https://coolify.io) is an [open-source deployment platform](/open-source-stack) that handles the build, deploy, and hosting pipeline. Think of it as a self-hosted alternative to Heroku or Railway. Connect a Git repo, configure the build, and deploy. Here's the full workflow.

## Step 1: Connect your repository

In Coolify, set up a Git source under Sources in the sidebar. Coolify supports GitHub, GitLab, Bitbucket, and other providers. Authorize the app, select which repositories to share, and you're connected. This is a one-time setup. Every future project can use the same source.

{% content-image src="coolify-sources-zoom-content" caption="The Sources page after connecting a Git provider. One-time setup, then every project can use it." /%}

## Step 2: Create a project and application

Go to Projects, create a new one, then add a new resource. Select your repository and branch. Coolify will ask how you want to build it.

{% content-image src="coolify-add-resource-zoom-types" caption="Choose between public and private repository options when adding a new resource." width=1664 height=602 /%}

## Step 3: Pick your build method

You have two options: **Dockerfile** or **Nixpacks**.

**Dockerfile** is the reliable choice. You control the build, the dependencies, the runtime. If your repo already has a Dockerfile, select it and you're done.

**Nixpacks** auto-detects your language and framework. It works well for standard Node.js, Python, Go, and Ruby projects. For anything with a custom build process or a monorepo, Dockerfile is more predictable.

Either way, set the **"Ports Exposes"** field to match the port your application listens on. A Next.js app uses 3000. A Flask app uses 5000. If this doesn't match, the deploy will succeed but the app won't respond.

{% content-image src="coolify-app-config-zoom-network" caption="Set Ports Exposes to match the port your application listens on." /%}

## Step 4: Deploy and test

Hit deploy. Coolify pulls your code, builds the image, and starts the container. You can watch the logs in real time.

{% content-image src="coolify-deploy-log-zoom-log" caption="Timestamped logs show exactly what's happening at each step of the build and deployment." width=1600 height=543 /%}

Once it finishes, check the temporary URL under the "Links" dropdown at the top of the application page. If you see your app, it's working. If you see a 502, double-check the port configuration.

{% content-image src="coolify-links-temp-zoom-panel" caption="The Links dropdown shows your app's temporary URL. No DNS needed yet." /%}

At this point, your app is live. No domain setup required, no DNS, no certificates. Just a working URL you can share or test against.

## Step 5: Add a custom domain

When you're ready for a real URL, two things need to happen.

First, point your domain's DNS at your server. Create an A record with your server's IP address. If you're on MapleDeploy, you can find this in your dashboard or in Coolify under server settings.

Second, set the "Domains" field in your Coolify application to your full domain(s):

```
https://example.com,https://www.example.com
```

{% content-image src="coolify-app-config-zoom-general-config" caption="Enter your custom domains in the Domains field using the full URL format." width=1600 height=504 /%}

Redeploy, and Coolify will automatically provision an SSL certificate via Let's Encrypt. Give DNS a few minutes to propagate, and your app is live on your own domain with HTTPS.

## Common gotchas

**Port mismatch** is the most frequent issue. Your app listens on 8080, Coolify expects 3000. The deploy looks successful but nothing loads. Always verify "Ports Exposes" matches your app's actual port.

**Binding to localhost** breaks containerized apps. Your application needs to bind to `0.0.0.0`, not `127.0.0.1`. This is a Docker networking fundamental, but it catches people who haven't containerized before.

**Build-time vs. runtime environment variables.** By default, Coolify injects environment variables at runtime. If your framework needs them at build time (like `NEXT_PUBLIC_` variables in Next.js), toggle "Build Variable" on for those specific variables.

**Nixpacks detection failures.** If Nixpacks can't figure out your project, switch to a Dockerfile. You can generate a starting point by running `nixpacks build . --out .` locally, which saves the generated Dockerfile to your project directory. Adjust it to fit your needs.

## Why Dockerfile over Nixpacks?

Nixpacks is convenient. For a standard single-framework project with a clear `package.json` or `requirements.txt`, it just works. But convenience has limits.

Dockerfiles are explicit. You control the base image, the build steps, the runtime. When something breaks, the Dockerfile tells you exactly what happened. With Nixpacks, you're debugging an auto-generated build plan you didn't write.

For production workloads, Dockerfile wins on predictability. For quick prototypes, Nixpacks saves time. Use whichever matches the situation.

## Where MapleDeploy fits

Coolify is open source. You can install it on any VPS and manage everything yourself. Or you can skip the server administration entirely.

MapleDeploy gives you a fully managed Coolify instance on [Canadian infrastructure](/canadian-hosting) in Toronto. We handle the VM, OS updates, security patches, and monitoring. You get the deployment platform without the ops work.

Each server is a dedicated VM. No shared infrastructure, no noisy neighbors. Plans start at $45 CAD/month with a 30-day free trial. Connect your repo and deploy.

For the full step-by-step guide including server provisioning and troubleshooting, see our [getting started](/docs/deploy-your-first-app) documentation.

{% cta-section title="Deploy your first app" %}
30-day free trial. Push your repo, get a live URL. Plans start at $45 CAD/month.
{% /cta-section %}