Coolify und Claude Code: Ein Projekt auf dem eigenen VPS bereitstellen

Plattformbeschränkungen und Zahlungsbedingungen im Jahr 2026#

Ein typisches Szenario für Vibe-Coder im Jahr 2026: Du erstellst an einem Abend in Cursor oder Claude Code ein MVP, überträgst es in ein GitHub-Repository, öffnest vercel.com → verbindest das Repository → gelangst zum Abonnementbildschirm → gibst deine Karte ein → erhältst Transaction declined.

Das ist weder ein Fehler noch ein vorübergehender Ausfall.

Railway, Render, Heroku – überall dieselbe Geschichte. Heroku hat tatsächlich seinen kostenlosen Tarif 2022 für alle geschlossen, und im Februar 2026 wechselte das Projekt in den Wartungsmodus – keine neuen Funktionen und keine neuen Enterprise-Verträge. Für Nutzer mit einer nicht unterstützten Karte bedeutet das: „Die Tür ist zu; geh über einen Vermittler, der 20 % Provision verlangt.“

Du kannst mit virtuellen Visa-Karten in Kasachstan oder über Unternehmenszahlungsdienste bezahlen. Das bedeutet aber +20 % auf den Preis, +30 Minuten für jede Transaktion und das Risiko, dass dein Konto gesperrt wird, wenn der Zahlungsdienstleister eine Abweichung beim Land feststellt.

Das ursprüngliche Beispiel enthielt drei Versuche – mit Vercel Pro, Railway und Render.

Was ist Coolify und wie funktioniert eine selbst gehostete Plattform?#

Coolify ist ein Open-Source-Projekt auf Basis von Laravel + Docker, das jeden leeren VPS in eine Plattform für das Bereitstellen von Anwendungen verwandelt. Installiere Coolify einmal und erledige danach alles über die Weboberfläche: Verbinde GitHub, wähle ein Repository aus und klicke auf Deploy.

Die offizielle Dokumentation fasst es kurz und präzise zusammen:

Im Hintergrund besteht Coolify aus vier Teilen:

1. Weboberfläche mit Laravel 12 + Livewire 3 + Tailwind v4 — ein Dashboard zur Verwaltung deiner Anwendungen.
2. Docker + Docker Compose — jede Anwendung läuft in einem Container, getrennt von den anderen.
3. Reverse-Proxy (Traefik oder Caddy) — nimmt eingehenden HTTP/HTTPS-Verkehr entgegen und leitet ihn an Container weiter.
4. Let's-Encrypt-Integration — stellt automatisch SSL-Zertifikate für alle Domains aus und erneuert sie.

Wichtige Funktionen, durch die Coolify funktional mit Vercel vergleichbar ist:

Ein globales CDN ist das Einzige, was Coolify nicht standardmäßig mitbringt. Das ist die ehrliche Antwort. Wenn dein Projekt ein globales Publikum hat und du die Latenz für Nutzer in den USA und Europa verringern musst, schalte Cloudflare davor; für statische Inhalte ist es kostenlos.

Preis: Die selbst gehostete Version ist für immer kostenlos, ohne Beschränkung der Anzahl von Anwendungen, Servern oder Deployments. Coolify Cloud ist für $5/Monat für 2 Server + $3 für jeden weiteren verfügbar – die Server gehören aber weiterhin dir; Coolify Cloud hostet lediglich das Dashboard.

Die neueste Version ist v4.1.0 vom 18. Mai 2026. Zu den neuen Funktionen gehören das Buildpack Railpack in der Beta, Audit-Protokollierung, Konfigurationsunterschiede zwischen Deployments und ein nativer MCP-Endpunkt (schreibgeschützt). Quelle: GitHub-Releases.

Welchen VPS solltest du 2026 für Coolify nehmen?#

Die Mindestanforderungen von Coolify stammen direkt aus der offiziellen Dokumentation:

Das Minimum von 2 GB RAM ist eine harte Untergrenze. Mit 1 GB kommt das Installationsprogramm bis Docker, läuft dann in einen OOM-Fehler (Out of Memory) und hängt sich auf. Spare nicht am RAM.

Preisquellen: Timeweb Cloud, FirstVDS und Selectel.

Wenn du mehr Leistung brauchst (eine 100-GB-Datenbank, mehrere Postgres-Instanzen), nimm Aeza Dedicated.

Was du NICHT nehmen solltest:

• Geteilter VPS mit 512 MB–1 GB RAM — nicht einmal für Coolify ausreichend. Das ist für statische Websites auf nginx gedacht, nicht für eine PaaS.

Möchtest du nicht nur das Deployment einrichten, sondern auch ein Setup, das Claude zuverlässig macht, aufbauen? Coolify ist ein Ausführungswerkzeug, aber ohne strukturierten Kontext (CLAUDE.md, ein Second Brain und Context Engineering) wird Claude bei langen Aufgaben weiterhin halluzinieren. Das vollständige Setup umfasst alle drei Komponenten: KI-Klon + Second Brain + Context Engineering – diese Kombination macht aus Claude „einem Assistenten, der halluziniert“ ein zuverlässiges Werkzeug.

Coolify in 5 Minuten installieren#

Schritt 1. Per SSH mit dem VPS verbinden.

Nachdem du einen VPS beim Anbieter erstellt hast, erhältst du die IP-Adresse und das Root-Passwort des Servers per E-Mail oder in der Systemsteuerung. Verbinde dich von deinem lokalen Rechner aus:

ssh root@1.2.3.4

Wenn der Anbieter dir statt eines Passworts einen SSH-Schlüssel gegeben hat, verbinde dich mit -i path/to/key. Im Folgenden gehe ich davon aus, dass du ein frisches Ubuntu 22.04 oder 24.04 LTS verwendest.

Schritt 2. Den Coolify-Installationsbefehl ausführen.

Ein Befehl aus der offiziellen Dokumentation:

curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash

Das Skript erledigt drei Dinge:

1. Prüft das System (Ubuntu LTS? Root? AMD64?)
2. Installiert Docker und Docker Compose, falls sie noch nicht installiert sind
3. Lädt die Coolify-Images (coolify/coolify, coolify/realtime, traefik) herunter und startet sie im Hintergrund über docker-compose

Das dauert 3–5 Minuten. Du siehst, wie apt-get-Protokolle durchlaufen, gefolgt von docker pull. Wenn Coolify v4.1.0 is now running angezeigt wird, gehe zu Schritt 3.

Schritt 3. Die Weboberfläche öffnen.

Öffne dies in deinem Browser:

http://1.2.3.4:8000

Coolify zeigt einen Einrichtungsassistenten an – ein Formular zum Erstellen des ersten Benutzers. Gib eine E-Mail-Adresse und ein Passwort ein und speichere sie. Dieser Benutzer erhält automatisch Administratorrechte; weitere Benutzer brauchst du vorerst nicht.

Nach dem Speichern gelangst du zu einem leeren Dashboard: links eine Seitenleiste mit Resources / Projects / Servers / Sources / Notifications / Settings und in der Mitte die Aufforderung „Add your first resource“.

Schritt 4. Ports in der Firewall des Anbieters öffnen (nicht in UFW).

Coolify läuft bereits, aber von außen ist nur Port 8000 (das Dashboard) erreichbar. Damit Nutzer deine Anwendungen erreichen können, musst du die Ports 80 (HTTP) und 443 (HTTPS) öffnen:

Ein wichtiger Stolperstein aus der offiziellen Dokumentation:

Das bedeutet: Selbst wenn du UFW aktivierst und alle Ports schließt, stellt Docker seine Container weiterhin über iptables bereit. UFW ist hier nutzlos. Die Lösung ist, Ports in der Systemsteuerung des Anbieters zu öffnen und zu schließen, nicht über UFW. Bei Timeweb / Selectel / Aeza findest du die entsprechende Einstellung im Bereich „Network → Firewall“ der Webkonsole.

Schritt 5 (optional). Das Dashboard an deine Domain binden.

Um https://coolify.example.com statt http://1.2.3.4:8000 aufzurufen, erstelle einen DNS-A-Eintrag coolify.example.com → 1.2.3.4, gehe in Coolify zu Settings → Instance Settings → Instance Domain, gib deine Subdomain ein und speichere. Coolify fordert ein Let's-Encrypt-Zertifikat an und lädt das Dashboard eine Minute später über HTTPS neu.

Danach kannst du Port 8000 in der Firewall schließen – das Dashboard ist dann über HTTPS auf dem Standardport 443 erreichbar.

GitHub verbinden: App oder PAT?#

Gehe in Coolify zu Sources → + Add → GitHub App. Coolify zeigt einen dreiteiligen Assistenten an:

1. Name & description — benenne die Quelle (gib github-main ein) und füge optional eine Beschreibung hinzu.
2. Configure on GitHub — eine Schaltfläche, die dich zu GitHub.com führt und automatisch ein GitHub-App-Erstellungsformular mit den passenden Berechtigungen öffnet.
3. Confirm — klicke nach deiner Rückkehr von GitHub auf „Save“.

Im zweiten Schritt bittet GitHub dich, die von Coolify angeforderten Berechtigungen zu bestätigen:

Dies sind Mindestberechtigungen – die GitHub App kann deine privaten Schlüssel nicht sehen, nicht in main schreiben und nicht auf Repositories zugreifen, die du nicht ausdrücklich verbunden hast.

Aus der offiziellen Dokumentation:

Personal Access Token (PAT) ist die alte Methode; ich empfehle, es nicht zu verwenden. Nachteile:

• PAT gewährt globalen Zugriff auf alle deine Repositories (einschließlich privater)
• PR-Vorschauen funktionieren nicht – diese Funktion gibt es nur mit der GitHub App
• Das Token ist lange gültig (90 Tage, ein Jahr oder unbegrenzt) – wenn es nach außen gelangt, ist das problematisch

Verwende PAT nur, wenn du mit einem Organisations-Repository arbeitest, dessen Sicherheitsrichtlinie GitHub Apps verbietet und für das es keine Umgehung gibt.

Nach dem Speichern der Quelle in Coolify siehst du die GitHub App im Dashboard mit einer Liste verbundener Repositories. Wenn du eine neue Anwendung erstellst, kannst du eines davon mit einem Klick auswählen.

Ein Next.js-Projekt aus Claude Code in 6 Schritten bereitstellen#

Schritt 1. Beschreibe Claude Code das Projekt in einem leeren Ordner.

mkdir my-vibe-app
cd my-vibe-app
git init
claude

In der Sitzung:

Build a Next.js 14 app router project:
- a home page with a list of users
- /api/users endpoint returns an array from the database
- Postgres via Prisma
- Tailwind for styles
- .env.example with DATABASE_URL
- README.md with instructions for running the project

Claude erstellt die Dateistruktur, package.json, prisma/schema.prisma und .env.example. Bitte außerdem um Folgendes:

Create a Dockerfile for production builds and a .dockerignore.

Das ist optional – Coolify kann auch ohne Dockerfile mit Nixpacks bauen. Ein Dockerfile gibt dir jedoch Kontrolle über den Prozess und ist bei größeren Projekten schneller.

Schritt 2. Ein GitHub-Repository erstellen und dorthin pushen.

Du kannst das manuell über die GitHub-Oberfläche + git remote add origin ... erledigen, Claude Code kann es aber auch selbst tun:

/commit-push-pr Initial Next.js app generated with Claude Code

Oder sage einfach: „Committe alles und pushe es in ein neues Repository my-vibe-app in meinem Konto.“ Claude verwendet die gh-CLI, um ein privates (oder öffentliches) Repository zu erstellen und den ersten Push auszuführen. Quelle: offizieller Claude-Code-Befehl.

Schritt 3. Eine Anwendung in Coolify erstellen.

Klicke im Coolify-Dashboard auf + New → Application. Ein Formular wird geöffnet:

1. Source — wähle github-main (die GitHub App, die du im vorherigen H2 verbunden hast)
2. Repository — wähle my-vibe-app aus der Liste
3. Branch — main
4. Build Pack — Coolify erkennt es automatisch. Wenn ein Dockerfile vorhanden ist, wird dockerfile verwendet. Andernfalls kommt nixpacks zum Einsatz. Du kannst diese Auswahl manuell überschreiben.
5. Domain — übernimm vorerst den vorgeschlagenen temporären Wert; er wird später durch deine eigene Domain ersetzt
6. Port — standardmäßig 3000 für Next.js

Speichern.

Schritt 4. Umgebungsvariablen hinzufügen.

Öffne in der erstellten Anwendung die Registerkarte Environment Variables. Füge die Variablen einzeln hinzu:

DATABASE_URL=postgresql://user:pass@db-host:5432/mydb
NODE_ENV=production
ANTHROPIC_API_KEY=sk-ant-...

Wenn du keine Datenbank hast, erstelle direkt in Coolify eine: + New → Database → PostgreSQL. Coolify startet in 30 Sekunden einen Postgres-Container und stellt eine interne DATABASE_URL im Format postgresql://postgres:pass@postgres-xyz:5432/postgres bereit – trage sie in deiner Anwendung ein.

Alle Variablen sind in der Coolify-Datenbank verschlüsselt und werden nicht in Build-Protokollen angezeigt.

Schritt 5. Auf Deploy klicken.

Oben rechts befindet sich eine blaue Deploy-Schaltfläche. Live-Protokolle erscheinen in der Registerkarte Logs:

[stage: clone]   Cloning '<repository-url-from-github>'
[stage: build]   Detected Next.js, using Nixpacks
[stage: build]   Installing Node 20, npm 10
[stage: build]   npm install (245s)
[stage: build]   npm run build (87s)
[stage: deploy]  Creating container my-vibe-app-xyz
[stage: deploy]  Container started, health check passed
[stage: proxy]   Traefik routing configured for <TEMPORARY_DOMAIN>
[stage: ssl]     Let's Encrypt cert issued for <TEMPORARY_DOMAIN>

Der erste Build dauert 3–5 Minuten (das Node-Basis-Image wird geladen und Abhängigkeiten werden installiert). Nachfolgende Builds dauern dank Docker-Layer-Caching 60–90 Sekunden.

Kopiere beim Status Running die im Coolify-Feld Domains angezeigte Anwendungs-URL und öffne genau diese im Browser. Verwende sie unten als <app-url-from-coolify>; die Winkelklammern kennzeichnen einen Platzhalter, keine echte Adresse. Deine Startseite sollte erscheinen, HTTPS ist bereits eingerichtet. Coolify nutzt einen kostenlosen Wildcard-DNS-Dienst für temporäre Domains, damit du die Website sofort ohne eigene DNS-Konfiguration öffnen kannst.

Schritt 6. Prüfen, ob alles funktioniert.

Öffne die zuvor kopierte Anwendungs-URL mit angehängtem /api/users, etwa <app-url-from-coolify>/api/users, ohne doppelten Schrägstrich. Das ist der in Schritt 1 erstellte JSON-Endpunkt; die Stamm-URL ist die Startseite. Bei einem 500-Fehler findest du den Stacktrace in der Registerkarte Logs. Das häufigste Problem bei einem ersten Deployment ist, dass DATABASE_URL auf eine nicht vorhandene Datenbank verweist. Behebe es, indem du eine PostgreSQL-Instanz in Coolify erstellst (siehe Schritt 4 oben) und DATABASE_URL ersetzt.

15 Minuten, gerechnet ab dem Zeitpunkt, an dem du den VPS bestellst. Im ursprünglichen Beispiel dauerte dieser Ablauf auf einem frischen Server 12–18 Minuten.

Eine eigene Domain und HTTPS konfigurieren#

Schritt 1. Im Kontrollpanel deines Registrars einen DNS-A-Eintrag erstellen.

Die ursprünglichen Beispiele verwenden Domains bei Reg.ru, Beget oder Timeweb. Der Ablauf ist derselbe:

Speichere den Eintrag, öffne eine Konsole und prüfe:

dig app.example.com +short
# Sollte 1.2.3.4 zurückgeben

Wenn keine oder eine andere IP-Adresse zurückgegeben wird, ist die DNS-Propagation noch nicht abgeschlossen. Warte 5–30 Minuten.

Schritt 2. Deine Domain in Coolify eintragen.

Öffne in der Anwendung die Registerkarte Configuration → General. Ersetze im Feld Domains die aus Coolify kopierte temporäre Anwendungs-URL durch https://app.example.com mit deiner eigenen eingerichteten Domain. Aktiviere Automatic HTTPS (ist normalerweise standardmäßig aktiviert).

Speichere und klicke auf Redeploy.

Schritt 3. Auf das Let's-Encrypt-Zertifikat warten.

In den Build-Protokollen wird Folgendes angezeigt:

[stage: ssl]  Requesting Let's Encrypt cert for app.example.com
[stage: ssl]  HTTP challenge sent to /.well-known/acme-challenge/xxx
[stage: ssl]  Validation passed, cert issued
[stage: ssl]  Cert installed, HTTPS enabled

In 2–3 Minuten ist deine Website unter https://app.example.com mit einem grünen Schloss in der Adressleiste erreichbar.

Was bei Let's Encrypt schiefgehen kann (die drei häufigsten Probleme aus der offiziellen Anleitung zur Fehlerbehebung):

1. Port 80 ist in der Firewall geschlossen. Let's Encrypt validiert mit einer HTTP-Challenge – dabei wird eine Anfrage an http://app.example.com/.well-known/acme-challenge/xxx gesendet. Ohne Port 80 ist keine erfolgreiche Validierung möglich. Öffne ihn in der Firewall des Anbieters.
2. Der Cloudflare-Proxy ist aktiviert (orange Wolke). Er fängt die Let's-Encrypt-Anfrage ab und gibt seine eigene Platzhalterseite zurück – die Validierung schlägt fehl. Wechsle zu „DNS only“ (graue Wolke) oder richte über die Cloudflare-API eine DNS-01-Challenge ein.
3. Die DNS-Propagation ist noch nicht abgeschlossen. Wenn du den A-Eintrag vor 30 Sekunden erstellt und sofort auf Redeploy geklickt hast, kann Let's Encrypt deine Domain noch nicht sehen. Warte 5–30 Minuten, bis die DNS-Propagation auf den Servern abgeschlossen ist.

Let's-Encrypt-Ratenlimit: 5 fehlgeschlagene Versuche pro Stunde für eine Domain, mit einer Wiederherstellung von 1 Versuch alle 12 Minuten. Wenn du das Limit erreichst, klicke nicht zehnmal hintereinander auf Redeploy; prüfe die Protokolle, behebe das Problem und versuche es in 12 Minuten erneut.

Claude Code MCP einrichten: Coolify verbinden und verwalten#

Das Model Context Protocol (MCP) ist ein Standard von Anthropic, über den Claude Code mit externen Systemen kommunizieren kann (weitere Informationen findest du in der Anleitung zu MCP-Servern). Verbinde einen MCP-Server, und Claude erhält eine Reihe von Tools, die es aufrufen kann. Es gibt drei vorgefertigte Server für Coolify sowie eine native Option.

Option 1. forsonny/Coolify-MCP-Server-for-Claude-Code — grundlegend.

Was es kann:

• Anwendungen: erstellen, starten, stoppen, neu starten
• Dienste: auflisten, erstellen, starten/stoppen/neu starten
• Deployments: laufende anzeigen, per UUID abrufen
• Teams & Mitglieder: auflisten, Informationen abrufen
• SSH-Schlüssel: auflisten, erstellen
• Umgebungsvariablen: vollständiges CRUD für Anwendungen und Dienste
• Server-Insights: Domains pro Server, Zustand, Version

Installation:

git clone '<OFFICIAL_URL>'
cd Coolify-MCP-Server-for-Claude-Code
npm install
npm run build
# In .env:
#   COOLIFY_BASE_URL=https://coolify.example.com
#   COOLIFY_API_TOKEN=[from Coolify Settings → API Tokens]
npm run setup  # automatically configures Claude Code

Danach kannst du in Claude Code Folgendes schreiben:

Show the status of the my-vibe-app application in Coolify and the 3 latest deployments.

Claude gibt eine Tabelle zurück.

Option 2. dazeb/coolify-mcp-enhanced — erweitert (empfohlen).

Erweiterungen gegenüber der Grundausstattung:

• PostgreSQL / Redis / MinIO mit einem Klick über KI bereitstellen — bitte „Postgres für mich einrichten“, und das System erstellt einen Container und gibt DATABASE_URL zurück
• Echtzeitüberwachung + Ressourcennutzung — CPU/RAM jeder Anwendung in Echtzeit
• Massenaktualisierungen der Env-Konfiguration — 20 Variablen mit einem Befehl aktualisieren
• Docker-Compose-Unterstützung — Anwendungen mit mehreren Diensten bereitstellen

Konfiguration für Claude Code (.mcp.json im Projektstamm):

{
  "mcpServers": {
    "coolify-enhanced": {
      "command": "node",
      "args": ["/path/to/coolify-mcp-enhanced/dist/index.js"],
      "env": {
        "COOLIFY_ACCESS_TOKEN": "your-token-here",
        "COOLIFY_BASE_URL": "https://coolify.example.com"
      }
    }
  }
}

Option 3. ajmcclary/Coolify-Manager — ein Claude-Skill auf Grundlage der CLI.

Es handelt sich nicht um einen MCP-Server, sondern um einen Claude-Code-Skill, der die offizielle Coolify-CLI umschließt. Er umfasst:

• Zustandsdiagnose für Dienste und Container
• Diagnose von SSL-Zertifikaten
• Unterstützung mehrerer Instanzen (wenn du mehrere Coolify-Server hast)
• Anleitungen zur Fehlerbehebung

Installation: Lade den Skill herunter und lege ihn in ~/.claude/skills/coolify-manager/ ab. Claude Code erkennt ihn und bietet ihn für passende Aufgaben an.

Option 4 (neu im Mai 2026). Nativer MCP in Coolify v4.1.0.

Im Changelog zu v4.1.0 vom 18. Mai 2026 heißt es:

Instanzweite MCP-Unterstützung mit schreibgeschützten Tools für Coolify-Ressourcen und API/UI hinzugefügt.

Coolify bietet jetzt einen eigenen MCP-Endpunkt – du kannst Claude Code direkt verbinden, ohne Server von Drittanbietern. Vorerst ist dieser schreibgeschützt (Anwendungslisten, Status, Konfigurationen); Änderungen sind nicht möglich. Für die meisten Aufgaben wie „Erzähl mir etwas über die Infrastruktur“ reicht das aber aus.

Verbinde ihn über .mcp.json:

{
  "mcpServers": {
    "coolify-native": {
      "url": "https://coolify.example.com/api/v1/mcp",
      "headers": {
        "Authorization": "Bearer <your-api-token>"
      }
    }
  }
}

Warte auf den vollständigen Schreibzugriff im nativen MCP in v4.2 oder v4.3 – das Coolify-Team hat ihn bis Ende 2026 zugesagt.

5 Stolperfallen beim ersten Deployment – und wie du sie vermeidest#

Stolperfalle 1: Weniger als 2 GB RAM – die Installation schlägt mit OOM fehl.

Symptom: curl install.sh erreicht docker pull coolify/coolify, bleibt bei 70 % hängen und der Prozess wird mit Killed (signal 9) beendet. Die Protokolle von dmesg | tail zeigen Out of memory: Killed process.

Lösung:

# Eine 4-GB-Swapdatei erstellen, um das Problem vorübergehend zu beheben
sudo fallocate -l 4G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

Langfristig solltest du auf 4 GB RAM aufrüsten. Coolify funktioniert mit Swap, aber Builds großer Next.js-Projekte können fehlschlagen.

Stolperfalle 2: UFW ist aktiviert, aber Docker öffnet weiterhin Ports.

Symptom: Du hast UFW aktiviert und alle Ports außer 22 geschlossen, aber deine Anwendung ist weiterhin über einen beliebigen Port (zum Beispiel 3000) aus dem Internet erreichbar.

Der Grund laut offizieller Dokumentation:

Lösung: Verwende die Firewall in der Systemsteuerung deines Anbieters, nicht UFW. Bei Timeweb / Selectel / Aeza gibt es einen Bereich „Firewall“ oder „Network → Firewall“, in dem du Regeln auf Ebene des virtuellen Netzwerks festlegst – sie greifen, bevor Pakete Docker erreichen.

Eine Alternative ist ufw-docker, ein Skript, das UFW für die Kompatibilität mit Docker anpasst. Das ist jedoch komplizierter, als im Kontrollpanel zu klicken.

Stolperfalle 3: Der Cloudflare-Proxy (orange Wolke) verhindert Let's Encrypt.

Symptom: Nach Redeploy zeigen die Protokolle Let's Encrypt validation failed - challenge returned 403.

Grund: Cloudflare leitet die HTTP-Anfrage von Let's Encrypt über seinen Proxy und gibt seine eigene Seite statt deiner Challenge-Datei zurück.

Lösung – wähle eine von zwei Optionen:

1. Zu „DNS only“ wechseln (die graue Wolke in Cloudflare). Nachteil: Du verlierst das Cloudflare-CDN und den Schutz.
2. Eine DNS-01-Challenge über die Cloudflare-API konfigurieren. Gehe in Coolify zu Settings → SSL Configuration, wähle den Cloudflare-Anbieter und gib ein API-Token mit den Berechtigungen Zone:Read und DNS:Edit ein. Let's Encrypt validiert dann über einen TXT-Eintrag statt über HTTP.

Die zweite Option ist schwieriger einzurichten, erhält aber den Cloudflare-Proxy.

Stolperfalle 4: PAT statt GitHub App – PR-Vorschauen funktionieren nicht.

Symptom: Du hast GitHub über ein Personal Access Token verbunden; alles funktioniert, aber für PRs werden keine Preview-Deployments erstellt. Du hast einen PR auf GitHub geöffnet, aber in Coolify ist nichts erschienen.

Grund: PR-Vorschauen sind eine exklusive Funktion der GitHub App. PAT erhält über einen Webhook keine pull_request-Ereignisse.

Lösung: Verbinde GitHub erneut über die App. Sources → Add → GitHub App → Assistent abschließen. Du kannst die alte PAT-Quelle löschen.

Stolperfalle 5: „Coolify == Vercel“ stimmt nicht ganz.

Was Coolify nicht standardmäßig kann:

Wenn dein Projekt ein stark frequentiertes SaaS mit globalem Publikum und Latenzanforderungen von < 100 ms weltweit ist, ist Coolify nicht geeignet; wähle Vercel Enterprise. Wenn du als Vibe-Coder ein MVP mit 100–1.000 Nutzern pro Tag testest, deckt Coolify alles ab.

Aus einer ehrlichen Analyse zum Self-Hosting:

Die 15 Minuten im Titel dieser Anleitung beziehen sich auf den unkomplizierten Ablauf beim ersten Deployment eines einzelnen Projekts. Eine vollständige Infrastruktureinrichtung mit Überwachung, Backups und Warnmeldungen dauert ein oder zwei Abende. Sei ehrlich zu dir selbst.

Wie viel sparst du in einem Jahr im Vergleich zu Vercel?#

Die folgenden Vercel-Werte sind Szenarioschätzungen des Artikels vom Mai 2026, keine aktuellen Angebote. Sie zeigen nur eine Vergleichsseite. Selbst betriebenes Coolify hat keine Lizenzgebühr, doch VPS, Backups, Speicher, Traffic und Betrieb verursachen Kosten. Hole ein zu den obigen Anforderungen passendes Angebot ein. Ein numerischer VPS-Preis fehlt in diesen Szenarien; eine feste Ersparnis wäre unbelegt.

C sei die gesamte monatliche Infrastrukturrechnung für VPS, Backupspeicher, Zusatztraffic, Monitoring und gegebenenfalls ein bezahltes Dashboard. Zähle jeden Posten einmal. r sei dein Stundenpreis für Betriebsarbeit, durchgängig in derselben Währung. Die Zeitschätzung des Artikels lautet anfangs 5–10 Stunden plus monatlich 1–2 Stunden: 17–34 Stunden im ersten Jahr, danach 12–24 Stunden pro Jahr.

Nutze je Szenario ein eigenes C, wenn andere Servergrößen nötig sind. Verteile für den Monatsvergleich die Einrichtung über zwölf Monate: Das erste Jahr entspricht monatlich C + (17–34)r/12, spätere Jahre insgesamt 12C + (12–24)r. Ergänze auch auf Vercels Seite vergleichbare Betriebskosten. Ein negativer Ersparniswert bedeutet teureren Eigenbetrieb mit deinen Eingaben. Rechne nicht nochmals das volle Ingenieursgehalt hinzu, wenn r es bereits enthält.

Setze vor dem Wechsel C aus einem echten Anbieterangebot samt Backupplan ein, wähle r und vergleiche einen Monat tatsächliche Nutzung. Ohne diese Werte liefert der Artikel ein Kostenmodell, keine Dollarersparnis.

Der größte Vorteil ist nicht das Geld. Wenn du zu Coolify wechselst, verschwindet die Kategorie „abhängig von der Zahlungspolitik eines anderen“. Virtuelle Vermittlerkarten mit 20 % Provision sind nicht mehr nötig.

Coolify ist kein günstigeres Vercel. Es gehört zu einer anderen Produktkategorie: Du besitzt die Infrastruktur, übernimmst die Verantwortung dafür und übernimmst ihre Komplexität. Ob du Geld sparst, ergibt erst der Vergleich mit deinen tatsächlichen Infrastruktur- und Arbeitskosten.

Wenn das Bereitstellen eines Prototyps deine erste Aufgabe nach der Generierung in Claude Code ist, gehört die Verwaltung der Umgebung (env, Secrets, geplante Aufgaben, Backups) zum Context Engineering. Ohne eine Struktur dafür, „wo alles liegt“, verliert Claude den Überblick, und du verlierst bei jeder Änderung Zeit. Das vollständige Setup umfasst: KI-Klon (Skills und Subagents, abgestimmt auf deine Methodik) + Second Brain (die Wissensdatenbank des Projekts) + Context Engineering (Plan Mode, /compact, Ausführungsumgebung). Das sind die 3 Säulen, ohne die KI halluziniert.

Der vollständige Kontext-Workflow: KI-Klon + Second Brain + Context Engineering.

Weitere Materialien findest du auf Ailoot.