Cal.com on VPS: installation, configuration, and maintenance

Installing Cal.com on a VPS gives you full control over your meeting scheduling tool, ensuring data privacy, configuration flexibility, and cost optimization. For deploying Cal.com, a VPS with a minimum of 2 vCPU, 4 GB RAM, and a 50 GB NVMe disk is optimal, providing stable operation for a small team and scalability for growing needs.

What is Cal.com and why choose Cal.com VPS?

Cal.com is a powerful, open-source meeting scheduling solution that serves as a direct alternative to popular proprietary services like Calendly. It allows users to create individual booking pages, manage availability, synchronize calendars, and automate the appointment scheduling process. The project is actively developing and offers a wide range of features, from simple one-time meetings to complex workflows with teams and request routing.

Choosing a Cal.com self-hosted solution on your own Virtual Private Server (VPS) unlocks a number of significant advantages, especially for companies concerned with data privacy, customization, and long-term savings.

Key Features of Cal.com and Self-Hosting Benefits

• Flexible Scheduling: creation of various event types (1-on-1, group, one-off, calls), configuration of duration, buffer time, minimum notice.
• Integrations: support for multiple video conferencing platforms (Zoom, Google Meet, Microsoft Teams), calendar services (Google Calendar, Outlook Calendar, Apple Calendar), as well as CRM systems and automation tools via API and webhooks.
• Team Collaboration: ability to set up collective calendars, route meetings between team members, manage group availability.
• Customization: full adaptation of booking page appearance to corporate branding, use of a custom domain.
• Open Source: transparency, security audit capability, active developer community.

Deploying Cal.com on a VPS from Valebyte.com gives you the following key advantages:

1. Full Data Control: All information about your meetings and users is stored on your server, not with a third-party provider. This is critically important for compliance with GDPR, HIPAA, and other regulations. You decide where and how your data is stored.
2. Long-term Savings: While the initial investment in a VPS and setup time might be higher than with cloud SaaS, in the long run, for growing teams and intensive use, Cal.com on a server often proves significantly cheaper. You pay only for server resources, not per user or per meeting.
3. Maximum Performance and Reliability: By choosing a VPS with guaranteed resources (CPU, RAM, NVMe disk) from Valebyte.com, you ensure stable and fast operation of your Cal.com without sharing resources with other "noisy" clients on shared hosting.
4. Unlimited Customization: You can modify the source code, add your own features, and integrate Cal.com with your internal infrastructure without the limitations imposed by cloud platforms.
5. Independence: You are not tied to the pricing policies or functional restrictions of third-party services. You manage updates and configuration yourself.

System Requirements for Cal.com Self-Hosted: Which VPS to Choose?

For a successful Cal.com installation on a VPS, its system requirements must be considered. Cal.com is a modern web application built on Next.js and actively uses a PostgreSQL database. Deployment via Docker and Docker Compose significantly simplifies the process but requires sufficient resources.

Minimum and Recommended VPS Specifications

The choice of VPS configuration depends on the anticipated load. Below are recommendations for different usage scenarios:

Minimum Requirements (for testing or a very small team of up to 5 users):

• Processor (vCPU): 2 cores. Cal.com can be quite resource-intensive during build times and with heavy API requests.
• RAM: 2 GB. This is the absolute minimum for Cal.com and PostgreSQL Docker containers. With less memory, OOM errors and unstable operation are possible.
• Disk Space: 25 GB NVMe SSD. NVMe disks are critically important for database performance and fast application response.
• Operating System: Ubuntu 22.04 LTS or Debian 11/12. These distributions are well-supported by Docker and have up-to-date packages.
• Network Bandwidth: 100 Mbps. This is sufficient for typical use.

Recommended Requirements (for small to medium businesses, up to 50 active users):

• Processor (vCPU): 4 cores. Will ensure smooth operation even during peak loads and background tasks.
• RAM: 4-8 GB. Will comfortably accommodate all Docker containers, the database, and cache.
• Disk Space: 50-100 GB NVMe SSD. Sufficient for the operating system, Docker images, database, and logs for an extended period.
• Operating System: Ubuntu 22.04 LTS or Debian 12.
• Network Bandwidth: 1 Gbps. For a better user experience and fast page loading.

Requirements for Large Business/Production (50+ active users, high load):

• Processor (vCPU): 6-8+ cores. For handling a large number of concurrent requests.
• RAM: 8-16+ GB. For database caching and ensuring high performance.
• Disk Space: 100-200+ GB NVMe SSD. Accounting for database and log growth.
• Operating System: Ubuntu 22.04 LTS or Debian 12.
• Network Bandwidth: 1 Gbps and higher.

Additional Components:

• Database: PostgreSQL 14+ (recommended). Cal.com officially supports PostgreSQL.
• Docker: Latest version of Docker Engine and Docker Compose.
• Reverse Proxy: Nginx or Caddy for handling HTTPS traffic and routing requests.
• Domain Name: Required for accessing Cal.com via HTTPS.

Valebyte.com offers various VPS plans that are ideally suited for deploying Cal.com on a server, ensuring high performance thanks to NVMe disks and stable vCPUs. You can review them on our website and choose the optimal plan for your needs.

Preparing Your VPS for Cal.com Installation via Docker

Before proceeding with Cal.com installation, you need to prepare your VPS. This section covers the basic steps for operating system setup, Docker installation, and ensuring basic security.

OS Update and Docker & Docker Compose Installation

Connect to your VPS via SSH. For most Linux distributions (Ubuntu, Debian), the process will be similar.

1. Update the system:

sudo apt update
sudo apt upgrade -y

2. Install necessary packages:

sudo apt install -y apt-transport-https ca-certificates curl gnupg lsb-release

3. Install Docker Engine:

Add Docker's official GPG key:

sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

Add the Docker repository:

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Update the package list and install Docker Engine:

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

4. Verify Docker installation:

sudo docker run hello-world

You should see the message "Hello from Docker!".

5. Add user to the Docker group (optional, but recommended):

To run Docker without sudo, add your user to the docker group:

sudo usermod -aG docker $USER
newgrp docker

After executing newgrp docker or reconnecting via SSH, you will be able to use docker commands without sudo.

Firewall Configuration (UFW)

Configuring the firewall (UFW) is a critically important step to protect your server. Open only the ports necessary for Cal.com to function and for server management.

sudo apt install ufw -y

# Allow SSH (usually port 22)
sudo ufw allow OpenSSH

# Allow HTTP (port 80) and HTTPS (port 443) for the web server (reverse proxy)
sudo ufw allow http
sudo ufw allow https

# Enable UFW
sudo ufw enable

Confirm activation by pressing 'y'. Check UFW status:

sudo ufw status verbose

You should see that SSH, HTTP, and HTTPS are allowed.

Now your VPS is ready for Cal.com Docker installation.

Step-by-Step Cal.com Docker Installation with Docker Compose

Deploying Cal.com using Docker Compose significantly simplifies the process, as all dependencies (application, database) are packaged into containers. This method is preferred for Cal.com self-hosted.

Cloning the Repository and Configuring Environment Variables

1. Create a directory for Cal.com and navigate into it:

mkdir ~/calcom
cd ~/calcom

2. Clone the official Cal.com repository:

git clone https://github.com/calcom/cal.com.git .

If you don't have git, install it: sudo apt install git -y.

3. Create an environment variables file:

cp .env.example .env

Open the .env file for editing:

nano .env

In this file, you will need to configure several key parameters:

• DATABASE_URL: This is the connection string to your PostgreSQL database. Since we will be using Docker Compose, Cal.com and PostgreSQL will be on the same Docker network.
• NEXT_PUBLIC_WEB_URL: The URL at which your Cal.com will be accessible (e.g., https://calendar.yourdomain.com).
• CALCOM_TELEMETRY_DISABLED: Set to 1 if you want to disable sending anonymous telemetry.
• NEXTAUTH_SECRET: A secret key for NextAuth. Generate a complex string, for example, using openssl rand -base64 32.

Example of a portion of the .env file (other parameters can be left as default or configured as needed):

# General
NEXT_PUBLIC_WEB_URL="https://calendar.yourdomain.com"
NEXT_PUBLIC_APP_URL="https://calendar.yourdomain.com"
NEXTAUTH_URL="https://calendar.yourdomain.com"
CALCOM_TELEMETRY_DISABLED=1

# Database
DATABASE_URL="postgresql://calcom:calcom_password@db:5432/calcom_db?schema=public"

# NextAuth Secret (IMPORTANT! Replace with a generated key)
NEXTAUTH_SECRET="your_very_complex_secret_key"

# Email (Configure SMTP for sending emails, otherwise Cal.com will not be able to send notifications)
EMAIL_FROM="Cal.com <[email protected]>"
EMAIL_SERVER_HOST="smtp.yourmailprovider.com"
EMAIL_SERVER_PORT=587
EMAIL_SERVER_USER="your_smtp_user"
EMAIL_SERVER_PASSWORD="your_smtp_password"
EMAIL_SERVER_SECURE=false # Use true for SSL/TLS (usually port 465)

Important: Replace calendar.yourdomain.com with your actual domain, and generate strong passwords and secret keys. For DATABASE_URL, use the database service name from docker-compose.yml (default is db).

Configuring Docker Compose and Launching Cal.com

1. Edit docker-compose.yml (if necessary):

By default, Cal.com already comes with a working docker-compose.yml file that includes services for the application, PostgreSQL database, and Redis. Check its contents:

nano docker-compose.yml

Ensure that the ports for Cal.com (default 3000) do not conflict with other applications on your server. If you are using a reverse proxy (which is recommended), Cal.com should not be directly accessible from outside.

Example docker-compose.yml (ensure it matches the current Cal.com version):

version: "3.8"

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    image: calcom/cal.com:latest
    container_name: calcom_app
    restart: always
    env_file:
      - .env
    ports:
      - "3000:3000" # Cal.com port, which will be used by the reverse proxy
    depends_on:
      - db
      - redis
    networks:
      - calcom_network

  db:
    image: postgres:14-alpine
    container_name: calcom_db
    restart: always
    environment:
      POSTGRES_USER: calcom
      POSTGRES_PASSWORD: calcom_password # Use the same password as in DATABASE_URL
      POSTGRES_DB: calcom_db
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - calcom_network

  redis:
    image: redis:6-alpine
    container_name: calcom_redis
    restart: always
    volumes:
      - redis_data:/data
    networks:
      - calcom_network

volumes:
  db_data:
  redis_data:

networks:
  calcom_network:
    driver: bridge

Important: Ensure that POSTGRES_USER, POSTGRES_PASSWORD, and POSTGRES_DB in docker-compose.yml match the values in DATABASE_URL from your .env file.

2. Run database migrations:

Before the first application launch, you need to perform database migrations. This will create the necessary tables and structure.

docker compose run --rm app yarn db-push
docker compose run --rm app yarn db-seed

The db-push command creates the database schema, and db-seed populates it with initial data.

3. Launch Cal.com with Docker Compose:

docker compose up -d

This command will build images (if not already downloaded), create, and start all services in the background (-d). The initial startup process may take some time as Docker downloads necessary images and builds the application.

4. Check container status:

docker compose ps

All services (app, db, redis) should be in the running status.

Now Cal.com Docker is running on your VPS. It is listening on port 3000 (or another port specified in docker-compose.yml), but is not yet accessible from outside. The next step is to configure a reverse proxy for access via a domain name with HTTPS.

If you are interested in deploying other useful tools on Docker, such as databases or CRMs, take a look at our article on installing NocoDB on a VPS or Baserow on a VPS, which also use Docker containers.

Configuring Reverse Proxy and HTTPS for Cal.com on the Server (Nginx and Caddy)

For secure and convenient access to your Cal.com on the server, a reverse proxy is necessary. It will handle incoming HTTP/HTTPS requests, forward them to the Cal.com Docker container, and ensure traffic encryption using SSL/TLS (HTTPS). We will cover two popular options: Nginx with Certbot and Caddy.

Before you begin, ensure that your domain (e.g., calendar.yourdomain.com) points to your VPS's IP address in your DNS settings.

Option 1: Nginx with Certbot for HTTPS

Nginx is a powerful and widely used web server that is excellent for acting as a reverse proxy. Certbot from Let's Encrypt will provide free SSL certificates.

1. Install Nginx:

sudo apt update
sudo apt install nginx -y
sudo ufw allow 'Nginx Full' # Allow HTTP and HTTPS through Nginx
sudo ufw delete allow 'Nginx HTTP' # If only HTTP was allowed previously
sudo ufw delete allow 'HTTP' # If only HTTP was allowed previously
sudo ufw delete allow 'HTTPS' # If only HTTPS was allowed previously
sudo systemctl start nginx
sudo systemctl enable nginx

2. Create an Nginx configuration file for Cal.com:

sudo nano /etc/nginx/sites-available/calcom.conf

Add the following configuration, replacing calendar.yourdomain.com with your domain:

server {
    listen 80;
    server_name calendar.yourdomain.com;

    location / {
        proxy_pass http://127.0.0.1:3000; # The port Cal.com listens on inside Docker
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_read_timeout 900;
        proxy_connect_timeout 900;
        proxy_send_timeout 900;
    }
}

Save and close the file (Ctrl+X, Y, Enter).

3. Activate the configuration and check syntax:

sudo ln -s /etc/nginx/sites-available/calcom.conf /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

Now your Cal.com should be accessible via HTTP (port 80) through your domain. However, we need HTTPS.

4. Install Certbot and obtain an SSL certificate:

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d calendar.yourdomain.com

Certbot will ask a few questions: your email, agreement to terms of service, and possibly offer to redirect HTTP traffic to HTTPS (it's recommended to choose 2: Redirect).

After successful execution, Certbot will automatically update your calcom.conf file in Nginx, adding HTTPS settings and redirection. Check your domain in a browser — Cal.com should be accessible via HTTPS.

5. Verify automatic certificate renewal:

sudo systemctl status certbot.timer
sudo certbot renew --dry-run

The Certbot timer should be active, and the --dry-run command should successfully simulate renewal.

Option 2: Caddy for Automatic HTTPS

Caddy is a modern web server that automatically manages Let's Encrypt SSL certificates, making its setup significantly simpler than Nginx+Certbot.

1. Install Caddy:

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt install caddy -y

sudo ufw allow http
sudo ufw allow https
sudo systemctl start caddy
sudo systemctl enable caddy

2. Create a Caddyfile configuration file:

sudo nano /etc/caddy/Caddyfile

Replace the existing content with the following configuration, changing calendar.yourdomain.com to your domain:

calendar.yourdomain.com {
    reverse_proxy 127.0.0.1:3000 # The port Cal.com listens on inside Docker
}

Save and close the file.

3. Validate and apply Caddy configuration:

sudo caddy validate --config /etc/caddy/Caddyfile
sudo systemctl reload caddy

Caddy will automatically obtain and configure an SSL certificate for your domain. Check your domain in a browser; Cal.com should be accessible via HTTPS.

Caddy significantly simplifies HTTPS setup, especially if you don't want to delve deep into the details of Nginx and Certbot configuration. For other applications requiring a reverse proxy, such as Activepieces on VPS or Windmill on VPS, the approaches with Nginx or Caddy will be similar.

Maintaining Cal.com on VPS: Backups and Updates

Regular maintenance is key to the stable and secure operation of Cal.com on a VPS. This includes creating data backups and timely updates of the application and operating system.

Backup Strategies: Cal.com Data Backups

Cal.com data is stored in a PostgreSQL database and Docker volumes. It is necessary to regularly back up these components.

1. PostgreSQL Database Backup:

The most important component to back up is the database. You can dump the database directly from the PostgreSQL Docker container.

# Create a directory for backups
mkdir -p ~/calcom_backups

# Perform database backup
docker compose exec db pg_dump -U calcom calcom_db > ~/calcom_backups/calcom_db_$(date +%Y%m%d%H%M%S).sql

Replace calcom and calcom_db with your actual values from .env and docker-compose.yml if they differ.

2. Docker Volume Backup:

In addition to the database, Cal.com may use Docker volumes for Redis and other data. While Redis data can usually be restored if the database is intact, backing it up doesn't hurt. It's also important to save the .env file.

# Make a copy of the .env file
cp ~/calcom/.env ~/calcom_backups/calcom_env_$(date +%Y%m%d%H%M%S).env

# You can also archive the entire Cal.com directory (optional, if you've made code changes)
tar -czvf ~/calcom_backups/calcom_app_$(date +%Y%m%d%H%M%S).tar.gz ~/calcom

3. Automate Backups with Cron:

Create a script for automatic backup:

nano ~/backup_calcom.sh

Add the following to it:

#!/bin/bash
BACKUP_DIR="/home/$USER/calcom_backups"
TIMESTAMP=$(date +%Y%m%d%H%M%S)
DB_USER="calcom"
DB_NAME="calcom_db"
CALCOM_DIR="/home/$USER/calcom" # Path to your Cal.com directory

mkdir -p $BACKUP_DIR

# Database backup
docker compose -f $CALCOM_DIR/docker-compose.yml exec db pg_dump -U $DB_USER $DB_NAME > $BACKUP_DIR/calcom_db_$TIMESTAMP.sql

# Copy .env file
cp $CALCOM_DIR/.env $BACKUP_DIR/calcom_env_$TIMESTAMP.env

# Delete old backups (e.g., older than 7 days)
find $BACKUP_DIR -type f -name "calcom_db_*.sql" -mtime +7 -delete
find $BACKUP_DIR -type f -name "calcom_env_*.env" -mtime +7 -delete

echo "Cal.com backup completed at $TIMESTAMP"

Make the script executable:

chmod +x ~/backup_calcom.sh

Add it to Cron for daily execution (e.g., at 2:00 AM):

crontab -e

Add the line:

0 2 * * * /home/$USER/backup_calcom.sh >> /var/log/calcom_backup.log 2>&1

4. Store Backups Off-Server:

It is critically important to store backups on a separate storage location, distinct from your VPS. This could be cloud storage (S3-compatible), another server, or a local computer. Tools like Restic can help automate this process. For simple file management on the server and their transfer, you might consider Filebrowser on VPS.

Cal.com and System Update Process

Regular updates provide access to new features, bug fixes, and security improvements.

1. Operating System Update:

This is a basic but important step.

sudo apt update
sudo apt upgrade -y
sudo apt autoremove -y
sudo reboot # If a kernel update is required

2. Cal.com Docker Update:

The process for updating Cal.com deployed via Docker Compose is relatively simple:

# Navigate to the Cal.com directory
cd ~/calcom

# Stop current containers
docker compose down

# Get the latest changes from the Cal.com repository
git pull

# Update dependencies (if there are changes in package.json)
# docker compose run --rm app yarn install

# Run database migrations (this is very important after an update!)
docker compose run --rm app yarn db-push
docker compose run --rm app yarn db-seed # If there is new data to populate

# Rebuild and start containers with new images
docker compose up -d --build

Always check the official Cal.com documentation before updating, as there may be specific instructions for major versions.

3. Docker Engine Update:

Periodically update Docker Engine, following instructions similar to those during installation, or simply via sudo apt upgrade docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y after updating Docker repositories.

4. Reverse Proxy Update (Nginx/Caddy):

Updates along with system packages: sudo apt upgrade nginx -y or sudo apt upgrade caddy -y.

Adhering to these backup and update recommendations will ensure the longevity and security of your Cal.com self-hosted solution.

Optimal VPS Configuration for Cal.com Under Real-World Load

Choosing the right VPS configuration for Cal.com on a VPS is crucial for ensuring stable performance and minimizing costs. Valebyte.com offers flexible plans that can be adapted to various Cal.com usage scenarios.

VPS Configuration Comparison Table for Different Cal.com Scenarios

Below is a table with recommendations for VPS configuration for different levels of Cal.com load. These recommendations are based on experience with Docker applications and considering Cal.com's requirements.

Usage Scenario	vCPU	RAM (GB)	Disk (NVMe SSD)	Bandwidth	Estimated Valebyte.com Cost*	Notes
Personal / Testing (1-3 users)	2 cores	2 GB	25 GB	500 Mbps	From $5/month	For personal use, experiments. Limited performance with concurrent requests.
Small Team / Startup (3-15 users)	2-4 cores	4 GB	50 GB	1 Gbps	From $10-15/month	Ideal for small teams. Good balance between price and performance.
Medium Business / Growing Team (15-50 users)	4-6 cores	8 GB	100 GB	1 Gbps	From $20-30/month	Ensures stability under medium load, sufficient for most companies.
Large Business / High Load (50+ users)	6-8+ cores	16+ GB	200+ GB	1 Gbps	From $40-60+/month	For large organizations requiring high availability and performance. Database scaling to a separate server is possible.

*Estimated prices are for example only and may differ from actual Valebyte.com rates. Always check the provider's website for current information.

Recommendations for Choosing a VPS for Cal.com

When choosing a VPS for your Cal.com installation, consider the following factors:

1. Disk Type: Always choose NVMe SSD. This significantly speeds up PostgreSQL database operations, which directly impacts Cal.com's response time. Valebyte.com offers NVMe disks by default on all its VPS.
2. Server Location: Choose a data center that is geographically close to your primary audience. This minimizes latency and improves user experience.
3. Scalability: Ensure that your VPS provider (e.g., Valebyte.com) offers easy scaling of resources (CPU, RAM, disk) as your needs grow. This will help avoid migrations and downtime.
4. Operating System: Stick to stable LTS versions of Ubuntu (22.04) or Debian (11/12). They are well-supported by the community and have up-to-date packages for Docker.
5. Monitoring: Set up basic monitoring for your VPS (CPU, RAM, disk usage, network traffic). This will help you anticipate performance issues and scale resources in a timely manner.
6. Backup: Ensure you have a reliable backup strategy, as described in the previous section. Consider using automated solutions for backups to external storage.
7. Network Bandwidth: 1 Gbps is standard for modern VPS and ensures fast page loading and stable operation for most scenarios.

The right VPS choice is an investment in the stability and efficiency of your meeting scheduling with Cal.com self-hosted.

Conclusion

Deploying Cal.com on a VPS is a strategic decision for companies and individual users seeking full data control, customization, and long-term savings. By following the step-by-step instructions for Cal.com installation via Docker Compose, configuring a reverse proxy with HTTPS, and implementing a robust backup and update strategy, you can create a reliable and scalable platform for meeting scheduling. Choosing an optimal VPS configuration from Valebyte.com with NVMe disks and sufficient RAM guarantees high performance for your Cal.com on the server, ensuring uninterrupted operation for any team.