Deploy Cal.com on Coolify — Your Own Scheduling Page, No Calendly Fees

Tested · v6.2.0-sh (calcom/cal.com:latest) · 2026-11-21Beginner · ~15 min hands-on · 6 min readLine B

This page contains affiliate links. If you buy through them we may earn a commission — it never affects our rankings or scores. How we make money

Watch on YouTube ↗ — if the player asks you to sign in, YouTube is flagging your network; the video itself is public and plays on YouTube directly.

On this page

Cal.com is the open-source alternative to Calendly: visitors open your page, pick a time, and the meeting is booked — no per-user subscription, and the data stays on your server. In this guide we deploy it onto the Coolify server from the previous tutorial, using Coolify's Docker Compose resource type, then attach a domain with a valid HTTPS certificate and make a real test booking. Everything below was tested end to end on 2026-11-21.

What you need

  • A server already running Coolify (see our Coolify install guide — this tutorial starts where that one ended, with Coolify up and a first app deployed).
  • A subdomain for the booking page (we used cal.deploysaga.com) with a DNS A record pointing at your server.
  • About 2 GB of free RAM for the two containers.

If you need a server, InterServer runs about $3 a month for the first slice (affiliate link — it helps keep these guides free). Any other small VPS works exactly the same way; Cal.com and Coolify are both free and open source either way.

Step 1 — Create a Docker Compose resource

In Coolify, open your project and click + New Resource, then choose Docker Compose and click Configure. Paste this Compose file into the editor:

services:
  db:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_USER: calcom
      POSTGRES_PASSWORD: "choose-a-strong-password"
      POSTGRES_DB: calcom
    volumes:
      - cal-db-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U calcom -d calcom"]
      interval: 5s
      timeout: 3s
      retries: 12
  calcom:
    image: calcom/cal.com:latest
    restart: unless-stopped
    depends_on:
      db:
        condition: service_healthy
    environment:
      DATABASE_URL: "postgresql://calcom:choose-a-strong-password@db:5432/calcom"
      DATABASE_DIRECT_URL: "postgresql://calcom:choose-a-strong-password@db:5432/calcom"
      NEXTAUTH_SECRET: "generate-me"
      CALENDSO_ENCRYPTION_KEY: "generate-me"
      NEXT_PUBLIC_WEBAPP_URL: "https://cal.example.com"
      NEXTAUTH_URL: "https://cal.example.com"
      CALCOM_TELEMETRY_DISABLED: "1"
      EMAIL_FROM: "noreply@example.com"
      EMAIL_SERVER_HOST: "smtp-relay.brevo.com"
      EMAIL_SERVER_PORT: "587"
volumes:
  cal-db-data:

Before you save, change four things:

  • The database password — the same value in three places: POSTGRES_PASSWORD and both DATABASE_URL strings.
  • The two secrets — generate each one, never invent them by hand:
openssl rand -base64 32
  • The public URL — NEXT_PUBLIC_WEBAPP_URL and NEXTAUTH_URL must be the exact address visitors will use, or sign-in breaks.
  • The domain inside the URLs — replace cal.example.com with your own subdomain everywhere.

Two details in this file do real work. The named volume cal-db-data keeps your bookings across redeploys, and the Postgres health check plus condition: service_healthy means the app container waits until the database actually accepts connections instead of crash-looping against an empty database. We use the prebuilt calcom/cal.com image; the official Cal.com Docker repository also ships a Compose file, but it builds the app from source, which is much slower.

Click Create Service. Back on the service page, rename the service to something recognizable (we used calcom) and press Enter or Save changes.

Step 2 — Attach the domain and deploy

Open the service's Domains page and click Add Domain. Coolify already knows which service application receives the domain, the protocol defaults to https, and it detected port 3000 on its own — that is the port the Cal.com container serves. Enter your domain (cal.deploysaga.com in our test) and Save.

Now click Deploy. Coolify pulls both images and starts the stack. One warning: the Cal.com image is large — the very first pull took about 11 minutes on our connection. After that first pull, a deploy finishes in about a minute, and both containers report healthy. At this point the site answers over HTTP and redirects to HTTPS, still with the proxy's self-signed certificate.

Step 3 — HTTPS

On a normal public VPS, you are already done — Traefik fetches a Let's Encrypt certificate automatically once your domain resolves to a public IP.

Our test server sits on a private network address, which Let's Encrypt cannot validate over HTTP, so — exactly as in the Coolify guide — we issue the certificate through the DNS challenge and hand it to the proxy as a file:

sudo certbot certonly --manual --preferred-challenges dns \
  -d cal.deploysaga.com --agree-tos -m admin@deploysaga.com --no-eff-email
sudo cp /etc/letsencrypt/live/cal.deploysaga.com/fullchain.pem /data/coolify/proxy/certs/cal.crt
sudo cp /etc/letsencrypt/live/cal.deploysaga.com/privkey.pem /data/coolify/proxy/certs/cal.key
sudo chmod 644 /data/coolify/proxy/certs/cal.crt /data/coolify/proxy/certs/cal.key

Then add the second certificate to the proxy's dynamic config (the file from the Coolify guide, extended with the cal pair):

tls:
  certificates:
    - certFile: /traefik/certs/app.crt
      keyFile: /traefik/certs/app.key
    - certFile: /traefik/certs/cal.crt
      keyFile: /traefik/certs/cal.key

Traefik hot-loads it within seconds. Verify:

curl -s -o /dev/null -w "%{http_code}\n" https://cal.deploysaga.com
# 307 — the app's redirect to its setup wizard / sign-in

The browser now shows a valid padlock, issued by Let's Encrypt. A manually issued certificate is not auto-renewed; repeat the certbot command before it expires (90 days).

Step 4 — Run the setup wizard

Open your new domain. Cal.com greets you with a three-step setup wizard:

  1. Administrator user — username, full name, email, password. Watch the password rules: at least 15 characters, mixed case, and a number. Shorter passwords are rejected here even though they work fine in most other tools.
  2. Choose a license — the free AGPLv3 option is already selected. Click Skip step.
  3. Enable apps — leave the defaults and click Finish.

That is the whole setup: you are signed in immediately. There is no email verification round-trip and no activation wait — the wizard works even before you configure real mail settings.

Step 5 — Personal onboarding and your public page

The user onboarding takes a minute: pick For personal use (Free), confirm your name and username, add a one-line bio, and Skip for now on the calendar connection (you can connect Google or Outlook calendars later, and bookings work without it).

Cal.com seeds three event types for you:

  • 30 min meeting — /yourname/30min
  • 15 min meeting — /yourname/15min
  • Secret meeting — hidden from your public page

Your public page is already live at https://cal.example.com/yourname: your name, your bio, and the two visible event types, ready to share.

Step 6 — Make a test booking

Prove it works before you share the link. Open your public page, click 15 min meeting, pick a weekday, and choose a time slot (we took Monday, 10:00 AM). Enter a name and email and click Confirm. Cal.com answers with "This meeting is scheduled", including the meeting details and a Cal Video link in the confirmation. The booking also shows up in the organizer's Bookings list.

Gotchas worth knowing

  • Email needs real SMTP credentials. The Compose file above ships with a placeholder mail host so the app starts cleanly. Bookings succeed without it, but confirmation emails are only actually delivered once you set a working EMAIL_SERVER_HOST plus username/password (any SMTP provider works — the example uses Brevo's relay host). Add EMAIL_SERVER_USER and EMAIL_SERVER_PASSWORD next to the other environment lines and redeploy.
  • The admin console asks for more. You may see a banner saying an admin needs a 15+ character password and 2FA enabled to gain full admin access. The main app is unaffected; set a longer password and enable 2FA under Settings when you are ready.
  • The public URL is baked into the app's behavior. If you move to a different domain later, update NEXT_PUBLIC_WEBAPP_URL and NEXTAUTH_URL and redeploy — links and redirects keep pointing at the old address until you do.
  • First pull is slow, later deploys are fast. Budget time for the initial image pull; after that, redeploys take about a minute.

Where to go next

Your scheduling page is live on your own server: your domain, your data, no per-user fees. In the next guide in this series we stay on the same machine and build a self-hosted VPN gateway with wg-easy — WireGuard you can manage from a web panel.

DeploySaga deskEvery step run hands-on from a clean install — no vendor screenshots, no copied docs.