Choose the Coolify deployment method that matches the artifact you already maintain. Use a Git repository for source-controlled projects, a Dockerfile when that file is the complete build input, Git-based Docker Compose for multi-container stacks, an existing Docker image when another system already builds the image, and a one-click Service when Coolify has a maintained template for the software.
Antihost offers VPS plans with one-click Coolify, NVMe storage and a 14-day free trial.
The important distinction is that a deployment method tells Coolify what it receives, while a build method tells it how to create images from Git source. Once that distinction is clear, choosing a path becomes a question of source-of-truth ownership, topology, and release workflow.
As an Amazon Associate I earn from qualifying purchases.
Quick decision table
| Your situation | Choose | Reason |
|---|---|---|
| Your application source is in Git and should deploy from selected commits or Git events | Git repository | You retain versioned source, selectable build strategies, webhooks, and pull-request preview support. |
| One self-contained Dockerfile defines a single custom image | Dockerfile without Git | The Dockerfile is the build input stored in Coolify. |
| Several containers share networks, volumes, or service configuration held in a Compose file | Git-based Docker Compose | Compose owns the multi-service runtime definition. |
| A separate CI system already publishes versioned images | Existing Docker image | Coolify pulls and runs the published artifact instead of rebuilding source. |
| The software is available in Coolify’s maintained template library | One-click Service | Coolify supplies an initial Docker Compose stack for the software. |
What Coolify actually controls
Coolify is a control plane for infrastructure, not the machine that executes every workload. The Coolify instance stores configuration and coordinates deployments. Docker on each connected server runs your applications, databases, and services.
Self-hosted and cloud control planes
With self-hosted Coolify, you operate the Coolify instance yourself. With Coolify Cloud, the Coolify team operates that control plane. In both models, you provide the servers on which workloads run. The deployment method changes how an application is assembled or obtained; it does not move the workload into the dashboard itself.
#1 Best Overall
Where HTTP traffic goes
Incoming HTTP traffic reaches the reverse proxy on the server running the workload. It does not pass through the Coolify dashboard or API as a proxy hop. This matters when you plan firewall rules, DNS, TLS termination, server capacity, and network access between services.
Deployment method versus build method
Coolify separates two decisions that are easy to confuse:
- Deployment method: the artifact Coolify receives, such as a Git repository, Dockerfile, Compose definition, or image reference.
- Build method: the process used to create images when the deployment input is Git source.
For a Git repository, the available build strategies include Nixpacks, Railpack, Static, Dockerfile, and Docker Compose. Nixpacks and Railpack are therefore not separate source types. They are automatic build choices inside the Git deployment path.
| Git build strategy | Use it when |
|---|---|
| Nixpacks or Railpack | Framework and build commands can be detected automatically and you do not need a custom image recipe. |
| Static | The repository already contains finished website files that only need to be served. |
| Dockerfile | The repository includes a custom Dockerfile that defines the image. |
| Docker Compose | The repository defines multiple services or keeps runtime wiring in Compose. |
Git repository deployments
The Git path is the general-purpose choice for a team that owns application source code. Coolify checks out the selected commit, applies the chosen build strategy, creates or obtains the required images, and updates the runtime.
Why Git is usually the default
- Every deployment can be tied to a commit, making the deployed source identifiable.
- Build and runtime configuration can be reviewed alongside application changes.
- Webhooks can start deployments from repository events.
- Pull-request preview environments are available for workflows that need them.
- You can switch among automatic detection, static serving, a custom Dockerfile, and Compose without changing the source location.
When Git is the wrong fit
Do not choose Git merely because the project is stored somewhere online. If another CI system already produces the image you want to run, an existing-image deployment avoids rebuilding it. If the only input is a short, self-contained Dockerfile and no repository files are needed, the non-Git Dockerfile path is simpler.
Dockerfile deployments without Git
In this method, you enter a Dockerfile in the Coolify dashboard. Coolify stores that text, builds an image from its instructions, and creates the application container.
Free tools Windows power users keep installed
One-click scans. No signup required.
Good use cases
- A small experiment or internal utility.
- A single image whose Dockerfile contains everything required to build it.
- A temporary workload where introducing a repository would add unnecessary process.
The critical limitation
A Dockerfile entered without Git cannot use COPY to read arbitrary project files from a repository. If the image needs application source, package manifests, static assets, configuration files, or scripts that live outside the Dockerfile text, use the Git deployment path instead. This limitation is the deciding factor for many projects.
Git-based Docker Compose deployments
Choose this path when a repository contains a Compose file that describes the application as a group of services. Coolify reads the definition, builds services that have a build: entry, pulls services that have an image: entry, and applies the resulting stack with Docker Compose.
Compose is the source of truth
For services and runtime settings defined by Compose, the Compose file owns the configuration. Do not assume that every standard Coolify Application setting can override values declared there. Service names, networks, volumes, port mappings, health checks, environment references, and dependency wiring should be changed in the repository’s Compose definition when that file controls them.
Use Compose when topology matters
Compose is appropriate when an application includes a web process plus workers, a database, a queue, a proxy, or another companion container; when containers must share a user-defined network; or when persistent volumes and startup relationships belong in one versioned definition. A single-container project with no Compose-owned wiring is usually easier to operate as a regular Git Application.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →Existing Docker image deployments
A Docker Image application does not build source code in Coolify. It pulls an image from a registry and applies the saved runtime configuration. You can provide a tag such as ghcr.io/example/api:1.4.0 or a SHA-256 digest.
When this is the right boundary
Use an existing image when a CI or release system already handles compilation, testing, security checks, and image publication. Coolify then concentrates on runtime deployment: pulling the selected artifact, configuring the container, and replacing the running version.
Tags versus digests
A versioned tag communicates intent, but a tag can be moved to different image content later. A mutable tag such as latest can therefore produce a different deployment without changing the application configuration. A digest identifies immutable image content and is the safer choice when you need an exact, reproducible artifact. Keep the qualification with the value: a tag is a human-readable pointer, while a digest pins the content.
One-click Services
A Coolify Service launches software from a maintained Docker Compose template. The Services documentation describes a Service as a Compose stack on one connected server.
Choose a Service when the template fits
This path is useful when the software you want already exists in Coolify’s template library and you want a ready initial Compose configuration rather than designing the stack yourself. The template supplies the starting structure and expected service settings.
Choose an Application when you need ownership
Use an Application when you control the source code, Docker configuration, or image reference. Applications are the better boundary for a project whose build recipe, Compose file, or released image must be reviewed and changed by your team rather than inherited from a maintained template.
How to choose when more than one method works
Work through these questions in order:
- What artifact do you maintain? Select Git, a standalone Dockerfile, a Compose repository, or a published image according to the artifact that receives deliberate changes.
- Who owns image creation? If Coolify should build from source, use Git or the dashboard Dockerfile. If CI already builds and publishes, use an existing image.
- Is the runtime one container or a coordinated stack? Use a regular Application for a single process; use Compose when multiple services, networks, volumes, or dependencies are part of the design.
- Where should runtime configuration live? Keep Compose-owned settings in Compose. Keep application and image settings in the mechanism your team reviews and deploys.
- Do you need immutable releases? Prefer commit-addressable Git revisions or image digests over floating tags and untracked dashboard edits.
- Does a maintained template already match the software? If yes, a one-click Service can be the shortest route. If you need to customize the source, image, or Compose definition, use an Application.
What happens during a deployment
Regardless of the selected method, Coolify follows a recognizable sequence:
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
- A deployment is queued from a manual action, a Git event, or a deployment webhook/API request.
- Coolify resolves the source revision, Dockerfile, Compose definition, or image reference.
- Required images are built or pulled.
- Coolify applies environment values, volumes, networking, ports, and other runtime configuration owned by that deployment method.
- Docker containers are updated on the connected workload server.
- Deployment logs expose the selected revision, image operation, generated configuration, and container actions.
Use the logs to determine whether a failure occurred while resolving source, building an image, pulling from a registry, generating Compose configuration, or starting a container. Those are different failure classes and call for different fixes.
Common selection mistakes and fixes
Trying to copy repository files into a dashboard-only Dockerfile
If a non-Git Dockerfile needs files that are not present in its build context, the build cannot produce the intended image. Move the Dockerfile and required files into a Git repository and select the Git deployment method.
Expecting Application fields to override Compose
When Compose defines a service’s ports, volumes, networks, or environment wiring, edit the Compose file. Treating dashboard fields as a second source of truth leads to configuration that appears saved but is not authoritative for that service.
Best Value
Using Nixpacks or Railpack as if they were deployment inputs
First select Git as the source. Then choose Nixpacks or Railpack as the build strategy if automatic detection suits the project.
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteDeploying a floating image tag when rollback precision matters
Replace a mutable tag with a versioned tag policy or, preferably, a digest. Record the exact image reference associated with each release so a rollback points to known content.
Assuming Coolify provides compute
Coolify coordinates deployments, but Docker on your connected servers runs the workloads. Size, secure, monitor, and back up those servers independently of the control plane.
A practical operating model
For a source-owned application, keep the repository as the authoritative record, deploy selected commits, and use the build strategy that matches the repository’s contents. For a platform team with a mature CI pipeline, publish immutable images and let Coolify handle runtime rollout. For a multi-service product, keep the Compose file under version control and make deliberate changes there. For software that matches a maintained template, start with a Service and move to an Application only when you need ownership of the image, source, or Compose definition.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
