Preview builduse code BETA15 for 15% off your first purchase on the live site
Documentation

Guides & how-tos

Step-by-step walkthroughs for everything you can do on Cloud Craft.

Deploy your first app

Ship a web app or API from a Git repository in a couple of minutes.

  1. 1

    Open the New Resource wizard

    From the portal, go to Projects → New Project. Choose Application as the resource type.

  2. 2

    Name it

    Give the project a name and an optional description, then continue.

  3. 3

    Pick the repository

    Connect GitHub (one click) and select a repo + branch. Private repos work too — a read-only deploy key is added for you automatically. Or enter owner/repo manually.

  4. 4

    Choose the build pack & port

    Nixpacks auto-detects most stacks. Pick Dockerfile or Docker Compose if your repo includes them. Set the port your app listens on (default 3000).

  5. 5

    Pick a domain

    Choose a Temporary domain for an instantly-reachable demo (no DNS setup), or a Custom name.cloud-craft.net subdomain.

  6. 6

    Review & create

    Confirm the summary and create. Cloud Craft builds and deploys via CraftPanel — watch progress on the Logs tab. When it's live, the URL banner turns green.

  7. 7

    Already made it in CraftPanel?

    If a project was created directly in your CraftPanel folder, hit Sync on the Projects page to pull it into your dashboard — it appears as your project, fully manageable here.

Add a managed database

Provision PostgreSQL, MySQL, MariaDB, Redis or MongoDB — standalone, or attached to an app.

  1. 1

    Standalone database

    New Project → choose Database, then pick an engine. We provision it and give you a copyable connection string on the project's Databases tab.

  2. 2

    Attach to an app

    When creating an Application, pick a database in the final step — we provision it and inject the connection string (e.g. DATABASE_URL) into your app's environment automatically.

  3. 3

    Add one later

    Open any app project → Databases tab → Add Database. The connection string is injected and synced to your app.

  4. 4

    Lifecycle

    Start, stop, restart or delete a database from the Databases tab. Deleting the project also tears the database down.

Deploy a one-click service

Launch WordPress, Ghost, n8n, NocoDB, Plausible, Uptime Kuma, Directus or Metabase.

  1. 1

    Choose Service

    New Project → Service. Pick from the curated catalog of apps.

  2. 2

    Deploy

    Name it and deploy. Cloud Craft provisions the full stack (including any bundled database) via CraftPanel.

  3. 3

    Manage it

    The project page shows the service's URL and status, with Start / Stop / Restart controls. Open the URL to finish the app's own setup (e.g. the WordPress installer).

Custom domains & SSL

Use a temporary domain for demos, or your own subdomain with automatic SSL.

  1. 1

    Temporary domain

    Auto-generated and instantly reachable — it points straight at your server's IP, no DNS needed. Best for demos.

  2. 2

    Custom subdomain

    Pick name.cloud-craft.net. Cloud Craft creates the DNS record pointing at your server and CraftPanel issues a Let's Encrypt certificate automatically.

  3. 3

    Your own domain

    On a project's Domains tab, add your domain and create the shown DNS record. Once it verifies, SSL is issued automatically.

Environment variables

Configure secrets and config that sync with your running app.

  1. 1

    Edit in the dashboard

    Project → Env Vars. Add keys, mark secrets, and save — changes are pushed to CraftPanel and applied on the next deploy.

  2. 2

    Build-time vs runtime

    Tick "Build" on a variable that must be available while the app builds (e.g. VITE_*, NEXT_PUBLIC_*). Leave it off for runtime-only secrets like API keys and DB URLs.

  3. 3

    Two-way sync

    Variables added directly in CraftPanel (or injected by a database) show up here automatically.

  4. 4

    Expose your URL

    When creating an app, enable "Expose my app's public URL as an env var" to inject e.g. APP_URL — handy for OAuth callbacks and absolute links.

Scheduled tasks & storage

Run cron jobs and add persistent volumes.

  1. 1

    Scheduled tasks

    Project → Scheduled. Add a name, a command and a cron frequency (e.g. 0 3 * * *) to run jobs on a schedule.

  2. 2

    Persistent storage

    Project → Storage. Mount a named volume at a path so data survives redeploys.

Push-to-deploy with GitHub

Every push to your production branch can build and deploy automatically.

  1. 1

    Connect GitHub once

    Sign in with GitHub or connect your account in the portal. Cloud Craft requests only the access it needs to read your repo and add a deploy webhook.

  2. 2

    Enable auto-deploy

    On an app project, turn on auto-deploy. We install a webhook on your repository so each push to the configured branch triggers a fresh build.

  3. 3

    Watch it ship

    Open the Logs/Deployments tab to follow the build in real time. If a build fails you'll get an email, and the previous version keeps running until the new one is healthy.

  4. 4

    Manual deploys too

    Prefer to ship on demand? Hit Redeploy any time, or use Force rebuild to deploy without the build cache.

Scale & upgrade your plan

Start small and grow — from the entry-level Mini server up to a larger dedicated one.

  1. 1

    Start on Mini

    The entry-level Mini plan runs your app on its own small dedicated server — perfect for a first launch with one app.

  2. 2

    Move to a bigger server

    Upgrade to Starter, Pro or Agency from Billing. Higher tiers provision a larger dedicated Linode with more CPU, RAM and projects.

  3. 3

    Resize as you grow

    Changing between dedicated plans automatically resizes your server to the new specs (a brief reboot during migration) — no manual migration.

  4. 4

    Need something bigger?

    For specs beyond Agency, multiple servers or specialised hardware, request a Custom Plan and we'll put together a quote.

Troubleshoot a deployment

What to check when a deploy fails or your site doesn't load.

  1. 1

    Read the build logs

    Open the project's Deployments/Logs tab. Most failures are a missing build/start command or dependency — the log shows the exact error.

  2. 2

    Check your commands

    Confirm the build command, start command and port match how your app actually runs. For monorepos, set the base directory; for static sites, set the publish directory.

  3. 3

    Redeploy or force rebuild

    Many transient failures clear with a Redeploy. Use Force rebuild to bypass a stale build cache.

  4. 4

    Roll back a bad deploy

    On the Deployments tab, pick a previous successful build and Roll back — it pins that commit and redeploys, so a broken release never leaves you stranded. Hit Deploy latest to return to HEAD.

  5. 5

    Configure a health check

    On the Resources tab, set a health-check path (e.g. /health) and port so CraftPanel only routes traffic once your app reports healthy — and the previous version keeps serving until it does.

  6. 6

    Site not loading after a deploy?

    Use the Fix proxy action on your server (it re-applies your domains and regenerates routing). This now also runs automatically when a deploy finishes.

  7. 7

    Still stuck?

    Open a support ticket from the portal — paste the failing log lines and we'll help within your plan's SLA.

Secure your account

Protect your account with two-factor authentication and strong recovery.

  1. 1

    Enable 2FA

    Settings → Security. Scan the QR code with an authenticator app (e.g. Authy, 1Password, Google Authenticator) and confirm a code to turn on time-based 2FA.

  2. 2

    Sign in with a code

    After your password, you'll be prompted for the 6-digit code from your app. Keep your device handy.

  3. 3

    Forgot your password?

    Use the "Forgot password?" link on the sign-in page to get a reset link by email — it's valid for one hour.

  4. 4

    Strong passwords

    Use a unique password of at least 8 characters. Accounts lock briefly after repeated failed attempts to blunt guessing.

Go-live checklists by app type

A quick checklist to get each kind of app online without surprises.

Node.js / Express API

A Node web app or API from a Git repo.

  • Connect your GitHub repo and pick the branch.
  • Build pack: leave on Nixpacks — it auto-detects Node, runs your build script, and boots with your start script.
  • Make sure your server listens on process.env.PORT (not a hard-coded port) and host 0.0.0.0.
  • Set the port in settings to match (default 3000).
  • Add secrets/API keys on the Environment tab.
  • Attach a database if you need one — DATABASE_URL is injected automatically.
  • Pick a domain (temporary for testing, or a custom name.cloud-craft.net), then deploy and watch the Logs tab.

Static site (React / Vite / HTML)

A pre-built front-end with no server process.

  • Connect your repo and branch.
  • Nixpacks detects the static build; confirm the build command (e.g. npm run build) and that it outputs to dist/ or build/.
  • Bake any build-time env vars (e.g. VITE_*) before deploying — they're compiled in, not read at runtime.
  • No port needed — CraftPanel serves the built files directly.
  • Pick a domain; SSL is issued automatically.
  • Deploy, then open the URL to confirm the site loads.

Next.js (SSR)

A server-rendered Next.js app.

  • Connect your repo and branch.
  • Nixpacks detects Next.js — it runs next build and starts with next start.
  • Keep the port at 3000 (Next's default) unless you changed it.
  • Remember NEXT_PUBLIC_* vars are build-time; server-only secrets are runtime env vars.
  • Attach a database if needed — DATABASE_URL is injected.
  • Pick a domain, deploy, and watch the build in the Logs tab.

Python (FastAPI / Django / Flask)

A Python web service or API.

  • Connect your repo (with requirements.txt or pyproject.toml) and branch.
  • Set the start command to bind 0.0.0.0 and $PORT — e.g. uvicorn app:app --host 0.0.0.0 --port $PORT (FastAPI) or gunicorn for Django/Flask.
  • Set the port in settings to match your start command.
  • Add env vars / SECRET_KEY. For Django, set ALLOWED_HOSTS to your domain.
  • Run DB migrations via a release/scheduled task if your framework needs them.
  • Attach a database — DATABASE_URL is injected — then pick a domain and deploy.

Docker / Dockerfile

Anything with a Dockerfile or Compose file.

  • Connect a repo that contains a Dockerfile (or docker-compose.yml).
  • Build pack: choose Dockerfile or Docker Compose — Cloud Craft builds your image as-is.
  • EXPOSE the port in your Dockerfile and set the same port in settings.
  • Add env vars and any build args on the Environment tab.
  • If the container writes data, add a volume on the Storage tab so it survives redeploys.
  • Pick a domain and deploy.

One-click service (WordPress, Ghost…)

A packaged app from the catalog — no repo needed.

  • New Project → Service, then pick the app (WordPress, Ghost, n8n, Metabase, …).
  • Name it and deploy — the full stack, including any bundled database, is provisioned for you.
  • Open the service URL and finish the app's own installer (admin user, site title).
  • Point a custom domain at it; SSL is issued automatically.
  • Handle updates/backups from the app's own admin area.

Full-stack (frontend + backend + DB)

Multiple resources working together.

  • Deploy the database first (or attach it when you create the backend) and note its DATABASE_URL.
  • Deploy the backend: attach the database (DATABASE_URL injected), set its port and secrets, and give it a domain like api.yourname.cloud-craft.net.
  • Deploy the frontend: set the backend's URL as an env var (e.g. VITE_API_URL) so it knows where the API lives.
  • Enable CORS on the backend for your frontend's domain.
  • Confirm each resource is green, then test the whole flow end to end.