Run Coolify

You like the platform-as-a-service experience: git push and it deploys, preview environments per branch, one-click databases and services, TLS handled for you. You'd just rather not pay per seat, per build, and per gigabyte of bandwidth for it — especially if you run a lot of small apps.

Coolify gives you that experience on a server you own. It's an open-source, self-hostable PaaS: connect a git repo and it builds and deploys, spins up preview environments, manages the databases your apps need, and handles HTTPS. You run it on one virtual machine and pay one flat VM bill, no matter how many apps and team members you put on it. That's a strong fit for agencies and developers juggling many projects.

This recipe hands the setup to your AI assistant. With the American Cloud MCP server connected, your assistant can size a server, show you the cost, create the VM with the right ports open, install Coolify over SSH, and point a domain at the dashboard — all from prompts you paste in. After that, your day-to-day deploys live in Coolify's own UI.

Why Claude Code for this

Any MCP client can create the infrastructure. But installing Coolify also means running its installer on the server over SSH. Claude Code combines the American Cloud tools with your terminal, so a single session can provision the VM and install Coolify on it without you switching tools. That's the setup this recipe assumes. Cursor and the other clients work too — you'll just run the SSH step yourself when the assistant tells you to.

Before you start

• A domain you control, with the ability to point its DNS at American Cloud (for a tidy dashboard URL with HTTPS — optional, but recommended).
• The MCP server connected to your assistant with a read-write key and --allow-writes.
• A few minutes after the VM boots — Coolify's installer pulls Docker and its own containers, so the first run isn't instant.

Coolify's own installation requirements call for a fresh Linux server with root or sudo SSH access; a plain Ubuntu VM is exactly that.

The one prompt that does it

Open Claude Code and paste this, filling in the domain placeholder. Read the cost estimate it shows you before approving anything.

I want to self-host Coolify on American Cloud so I have my own deploy platform.
Plan it out first, then walk through it step by step:
 
1. List the available regions and Ubuntu images, and the VM packages.
   Recommend a size that comfortably runs Coolify plus a few small apps.
   Coolify's docs suggest at least 2 CPU and 2 GB of RAM for a single server;
   give it some headroom.
2. Check whether I already have an SSH key registered. If not, create one
   for me and tell me where the private key is.
3. Show me a monthly cost estimate for the VM before creating anything.
   Wait for me to confirm.
4. Create an Ubuntu VM with that SSH key, on an isolated network, and open
   inbound ports 22, 80, 443, and Coolify's dashboard port 8000. Wait until
   it's fully running and has a public IP.
5. Over SSH, run Coolify's official install script as root. Wait for it to
   finish pulling Docker and bringing up the Coolify containers.
6. Add a DNS A record pointing coolify.{your-domain.com} at the VM's public IP.
 
Then tell me the dashboard URL to open so I can finish onboarding in Coolify
itself.

What your assistant will do

Grounded in real MCP tools, here's the sequence:

1. Survey the options. It calls list_regions, list_images (filtered to Ubuntu), and list_vm_packages to find a region near you, a current Ubuntu LTS image, and a compute tier sized for Coolify. The marketplace guide notes that 2 vCPU / 2 GB memory / 50 GB disk is a sensible starting point for a single-server install; the assistant picks a tier at or above that.
2. Sort out the SSH key. It calls list_ssh_keys to see what's already registered. If nothing fits, create_ssh_key generates a new pair — the private key is returned once and never stored, so your assistant saves it locally (for example to ~/.ssh/) and sets the right permissions. It needs this key both to register on the VM and to SSH in to run the installer.
3. Price it first. It calls get_cost_estimate_vm with the exact region, package, size, and image, and shows you the hourly and monthly numbers before creating anything. Nothing is billed yet. This is one flat VM cost — Coolify doesn't add per-app or per-seat charges on top.
4. Create the server. On your go-ahead, create_vm provisions the Ubuntu VM. The same call carries networkAccess.inboundPorts to open inbound ports 22 (SSH), 80 (HTTP), 443 (HTTPS), and 8000 (Coolify's dashboard) on the network's public IP, and keypairs to install your SSH key. Opening a port through networkAccess sets up the firewall rule and the port forwarding together, so the ports are actually reachable — not just allowed. The VM provisions asynchronously, so the assistant polls get_vm until its status reaches STARTED and it has a public IP.
5. Install Coolify over SSH. Now in the terminal, the assistant SSHes in with your key and runs Coolify's official install script as root. The script installs Docker if it's missing and brings up Coolify's own containers. Coolify — not American Cloud — manages everything from here: the apps you deploy, the databases those apps need, build pipelines, and TLS for your app domains.
6. Point a domain at the dashboard. It calls list_dns_zones to see if your domain is already hosted. If not, create_dns_zone adds it (you'll then update your registrar's nameservers to American Cloud's, which the assistant can show you). Then create_dns_record adds an A record for coolify.\{your-domain.com\} pointing at the VM's public IP.

When it's done, the assistant hands you the dashboard URL. The first time you open it you'll register your Coolify admin account and run Coolify's short onboarding — pick This Machine as the server when prompted, since Coolify is running on the VM you just created. From there you connect git repos and start deploying.

Prefer the dashboard? Use the marketplace image

If you'd rather not run an installer at all, American Cloud's marketplace ships a one-click Coolify image you create from the console — same result, no SSH. The step-by-step is in Deploying a Coolify instance. Use whichever path you prefer; the MCP path in this recipe is the one your AI assistant can drive end to end.

After setup: deploys in Coolify, infrastructure with your assistant

Once Coolify is up, your everyday work happens inside Coolify: add a project, connect a repository, and push to deploy. Preview environments, environment variables, the databases your apps depend on, and per-app TLS are all Coolify features now.

Your assistant and the MCP server stay useful for the layer underneath — the server Coolify runs on:

• Scale the VM as you add apps. More projects means more memory and CPU. The assistant can resize in place with scale_vm, no rebuild.
• Snapshot before you upgrade Coolify. Take a backup of the VM before a Coolify version bump so you can roll back if something misbehaves — see Backups and snapshots with your AI assistant.
• DNS for each new app. When you add an app on its own domain, ask the assistant to add the DNS record pointing it at the same VM; Coolify routes the request to the right app.

Follow-up: "Coolify says it's low on resources"

When Coolify warns it's running out of headroom, you don't have to guess at a new size:

Coolify says it's low on resources. Check the VM's CPU and memory usage over
the last 24 hours, tell me how close it's running to its limits, and if it's
tight, recommend a larger size and scale it up. Show me the new monthly cost
before you make the change.

The assistant calls get_vm_metrics to read the last day of CPU, memory, network, and disk usage, reasons about how much headroom is left, and — with your go-ahead — uses scale_vm to raise the vCPU and memory. It can show the updated cost with get_cost_estimate_vm first so there are no surprises.

Troubleshooting

The dashboard doesn't load on port 8000. Ask your assistant to "list the firewall rules on the VM's public IP and confirm port 8000 is open." It can check with list_firewall_rules. Note that a firewall rule by itself does not make a port reachable — the traffic also needs a path to the VM. The create_vm step opens 8000 the right way (firewall and port forwarding together). If you ever add a port afterward, open it with both create_firewall_rule and create_port_forwarding_rule (or map the IP straight to the VM with enable_static_nat); a lone firewall rule will look open but stay unreachable.

The Coolify install is still finishing. The installer pulls Docker and several containers on first run, so the dashboard isn't reachable until it completes. Ask the assistant to "SSH in and check whether Coolify's containers are up yet" before assuming something's wrong.

The dashboard subdomain doesn't resolve yet. DNS changes take time to propagate — from a few minutes to a couple of hours, depending on your registrar and the record's TTL. Ask your assistant to "check what coolify.{your-domain.com} currently resolves to and tell me when it points at the VM's IP." In the meantime you can reach the dashboard at the VM's public IP on port 8000.

SSH connection refused. Confirm port 22 is open (the same list_firewall_rules check) and that the private key from the create_ssh_key step is the one your assistant is using. If the key was lost, your assistant can reset access with reset_vm_password or open a browser console session with create_vm_console.

Next steps

• Run apps with Docker Compose — if you'd rather drive Compose directly instead of through a PaaS layer
• Backups and snapshots with your AI assistant — snapshot the VM before Coolify upgrades, and restore if needed
• Write an AGENTS.md for your project — teach your assistant your deploy conventions
• Things to try with the MCP server — more prompt ideas across compute, networking, and DNS