Migrating from Coolify

Coolify deploys apps on servers you run yourself. Fjordrun runs the servers for you, in Nuremberg, Germany, and bills the CPU and memory your services actually use. The building blocks are similar: applications, databases, environment variables and domains.

Concept map

Coolify	Fjordrun
Project	Project
Environment	Environment
Application (Git repository)	Service from a GitHub repository
Application (Docker image)	Service from a Docker image
Nixpacks / Dockerfile build pack	Fjordrun builder: a repository Dockerfile always wins; otherwise Node.js framework detection, or Nixpacks for other languages
Static build pack	Detected automatically for static sites (served by nginx)
Docker Compose application	One service per Compose service (see below)
Base directory	Root directory
Ports exposes	Port of the service
Health check	Healthcheck path
Scheduled tasks	A cron service with a schedule
Environment variables	Service variables (raw editor accepts KEY=value lines) and shared variables
Persistent storage	Volumes (one per service)
Databases (PostgreSQL, MySQL, Redis, MongoDB)	Database templates
One-click services	Templates where one exists (for example n8n, Umami, MinIO); otherwise a Docker image service
Your servers	Fjordrun's servers; there is nothing to patch or monitor

Steps

1. Create a project on Fjordrun and add a service from the same GitHub repository and branch. Set the root directory if you used a base directory in Coolify.
2. Variables: open the application's environment variables in Coolify, switch to the developer view and copy them. Paste them into Fjordrun's raw editor. Replace database hostnames with references, for example DATABASE_URL=${{Postgres.DATABASE_URL}}.
3. Port and healthcheck: set the port your app listens on (or listen on $PORT) and the healthcheck path.
4. Databases and storage: create databases from templates, attach volumes, and move the data (below).
5. Deploy, test on the generated *.fjordrun.app domain, then move your custom domain.

Images you build yourself must include linux/arm64: during the beta Fjordrun's servers are arm64 machines. Images that Fjordrun builds from your repository need no change.

Docker Compose applications

Fjordrun does not deploy Compose files directly. Create one service per Compose service in the same project and environment:

• build: entries become services from your repository (set the root directory, or the Dockerfile path).
• image: entries become Docker image services, or templates for common databases.
• environment: becomes service variables. Replace hostnames of other Compose services with their private hostnames, <service>.<environment>.internal, or with references such as http://${{api.FJORDRUN_PRIVATE_DOMAIN}}:8080. See Private networking.
• volumes: becomes one volume per service, at the same mount path.
• ports: becomes the service's port plus a domain for public services; internal services need no domain.

Databases

Dump from Coolify on the server (or through a public port, if you enabled one):

docker exec <postgres-container> pg_dump -U <user> --format=custom --no-owner --no-acl <database> > coolify.dump

Fjordrun databases are private, so restore from a container inside the project, as described in Railway → Databases. For MySQL use mysqldump / mysql, for MongoDB mongodump / mongorestore. Stop writes to the old database before the final dump.

Domains

Add the custom domain in Fjordrun and create the TXT verification record. When the new deployment works, replace the A record that points at your Coolify server with a CNAME to edge.fjordrun.app. HTTPS is issued automatically. See Domains and HTTPS.

What changes

• You no longer run, update or back up the servers, the reverse proxy or Coolify itself.
• You pay for what services use instead of for whole servers: €12 per vCPU-month and €6 per GB-month (excl. VAT), with plans from €0 (Trial), €5 (Hobby) and €20 (Pro) that include the same amount of usage. See Usage-based pricing.
• During the beta there is one region (nbg1) and no shell access to servers or containers.