How to Self-Host Rallly in 2026: Complete Setup Guide

What Rallly Is

Rallly (5K+ GitHub stars) is an open source meeting scheduling tool — the same concept as Doodle polls. Send a link, participants vote on time slots that work for them, and you see which option has the most availability.

Why self-host instead of using Doodle?

• Doodle's free tier is ad-supported and data is processed by Doodle
• Doodle's premium plan costs $6.95/user/month ($83/user/year)
• Self-hosted Rallly runs on ~$4/month hardware with no per-user costs
• Your meeting data stays on your server

What Rallly includes:

• Create scheduling polls with multiple date/time options
• No account required for participants (they just open the link and vote)
• Comments on polls for coordination
• Email notifications when participants respond
• Admin panel for managing polls
• Works without JavaScript (progressive enhancement)

Rallly vs Cal.com: Different use cases. Rallly is for group scheduling ("which time works for everyone?"). Cal.com is for individual booking ("book a time on my calendar"). Teams often need both.

Server Requirements

Rallly is lightweight:

• 1 CPU core
• 1GB RAM (2GB recommended)
• 5GB storage
• x86-64 architecture (Rallly's self-hosted image dropped arm64 support — check the current release for ARM status)

Recommended Servers (Hetzner)

Use Case	Server	Monthly
Small team	CAX11 (4GB ARM)	$4 — check ARM support
Reliable option	CX22 (4GB x86)	$5
Shared server (alongside other tools)	CPX21	$6.50

Note on ARM: Rallly's official self-hosted image may have ARM limitations. Check the current release notes before deploying on ARM hardware like the CAX series.

Step 1: Prepare Your Server

# Update system
sudo apt update && sudo apt upgrade -y

# Install Docker
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER
newgrp docker

# Verify
docker --version
docker compose version

Step 2: Clone the Self-Hosted Repository

Rallly maintains a dedicated repository for self-hosted deployments:

git clone https://github.com/lukevella/rallly-selfhosted.git
cd rallly-selfhosted

This repository contains the docker-compose.yml and config.env template already configured for self-hosting.

Step 3: Configure Environment Variables

cp config.env.example config.env
nano config.env

Essential variables to configure:

# Your instance's public URL (no trailing slash)
NEXT_PUBLIC_BASE_URL=https://rallly.yourdomain.com

# Generate a secret key (must be 32+ characters)
# Run: openssl rand -base64 32
SECRET_PASSWORD=your-generated-32-character-secret-key

# Support email shown to users for help requests
SUPPORT_EMAIL=admin@yourdomain.com

# SMTP configuration (required for email notifications and invites)
SMTP_HOST=smtp.yourprovider.com
SMTP_PORT=587
SMTP_SECURE=false
SMTP_USER=your@email.com
SMTP_PWD=yourpassword
SMTP_TLS_ENABLED=true

# From address for outgoing emails
SMTP_FROM=rallly@yourdomain.com

Generate a Secret Key

openssl rand -base64 32
# Copy the output to SECRET_PASSWORD

SMTP Options

Rallly requires email to:

• Send poll invitations
• Notify poll creators when participants respond
• Send magic link logins (no password required)

Free SMTP options:

• Brevo (Sendinblue): 300 emails/day free
• Mailgun: 1,000 emails/month free (first 3 months)
• AWS SES: $0.10/1,000 emails (very cheap at scale)
• Gmail SMTP: Works for low volume (configure App Password)

For Gmail SMTP:

SMTP_HOST=smtp.gmail.com
SMTP_PORT=587
SMTP_SECURE=false
SMTP_USER=your@gmail.com
SMTP_PWD=your-app-password-here
SMTP_TLS_ENABLED=true

Create a Gmail App Password at: myaccount.google.com → Security → 2-Step Verification → App passwords.

Step 4: Review Docker Compose Configuration

The repository's docker-compose.yml includes:

services:
  rallly:
    image: lukevella/rallly:latest
    ports:
      - "3000:3000"
    env_file: config.env
    depends_on:
      postgres:
        condition: service_healthy
    restart: unless-stopped

  postgres:
    image: postgres:15-alpine
    env_file: config.env
    volumes:
      - db-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U rallly"]
      interval: 5s
      timeout: 5s
      retries: 5
    restart: unless-stopped

volumes:
  db-data:

For most deployments, no modification is needed. The config.env file provides all configuration.

For production (after setting up HTTPS), change the port binding to localhost-only:

ports:
  - "127.0.0.1:3000:3000"

This prevents direct access to port 3000 from external IPs — traffic goes through the HTTPS reverse proxy instead.

Step 5: Start Rallly

docker compose up -d

Monitor startup:

docker compose logs -f rallly

Rallly is ready when you see logs indicating the Next.js server has started. This typically takes 15-30 seconds.

Access at http://your-server-ip:3000

Step 6: Verify It Works

Navigate to your Rallly instance:

1. Click Create a poll
2. Enter a meeting name and description
3. Add date/time options
4. Click Continue
5. Enter your name and email (or skip name)
6. Share the link

Test the participant experience by opening the poll link in a private browser window and voting.

Step 7: Set Up HTTPS

HTTPS is required for:

• Browser features like clipboard API
• Security for login magic links
• Professional appearance for participants

Option A: Caddy (Simplest)

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl
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

/etc/caddy/Caddyfile:

rallly.yourdomain.com {
    reverse_proxy localhost:3000
}

sudo systemctl restart caddy

Option B: Nginx + Let's Encrypt

sudo apt install -y nginx certbot python3-certbot-nginx

Create /etc/nginx/sites-available/rallly:

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

    location / {
        proxy_pass http://localhost:3000;
        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_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

sudo ln -s /etc/nginx/sites-available/rallly /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx
sudo certbot --nginx -d rallly.yourdomain.com

Update Configuration After HTTPS

Update config.env:

NEXT_PUBLIC_BASE_URL=https://rallly.yourdomain.com

Update docker-compose.yml port binding:

ports:
  - "127.0.0.1:3000:3000"

Restart:

docker compose up -d

Step 8: User Accounts and Admin

Creating Accounts

Rallly uses magic link authentication — users enter their email and receive a login link. No passwords needed.

For users, the workflow is:

1. Visit your Rallly instance
2. Click Sign in
3. Enter email → receive magic link → click to log in

Admin Access

Rallly doesn't have a traditional admin panel — all management is through the web interface. Your instance at the configured URL is the full interface.

To restrict who can create polls:

• Set ALLOWED_EMAILS in config.env to a comma-separated list of allowed email domains or addresses

ALLOWED_EMAILS=@yourdomain.com,partner@otherdomain.com

This limits poll creation to your team while keeping participant voting open to anyone with the link.

Step 9: Backup

Rallly's data lives in the PostgreSQL container.

Manual Backup

docker exec rallly-selfhosted-postgres-1 pg_dump -U rallly rallly | gzip > rallly-backup-$(date +%Y%m%d).sql.gz

Automated Daily Backup

# Create backup script
cat > /opt/rallly-backup.sh << 'EOF'
#!/bin/bash
BACKUP_DIR="/opt/backups/rallly"
mkdir -p "$BACKUP_DIR"
cd /opt/rallly-selfhosted

docker compose exec -T postgres pg_dump -U rallly rallly | gzip > "$BACKUP_DIR/rallly-$(date +%Y%m%d).sql.gz"

# Keep last 14 days
find "$BACKUP_DIR" -name "rallly-*.sql.gz" -mtime +14 -delete
EOF

chmod +x /opt/rallly-backup.sh

# Add to crontab (runs at 2 AM daily)
(crontab -l 2>/dev/null; echo "0 2 * * * /opt/rallly-backup.sh") | crontab -

Restore from Backup

gunzip -c rallly-backup-20260101.sql.gz | docker exec -i rallly-selfhosted-postgres-1 psql -U rallly rallly

Step 10: Updating Rallly

cd rallly-selfhosted
docker compose pull
docker compose up -d

Check release notes at github.com/lukevella/rallly/releases before major updates.

Integrating Rallly into Your Workflow

Share Polls Via Slack or Teams

When creating a poll, Rallly generates a shareable link. Copy this into your team's Slack/Teams channel:

Hey team — please vote for the time that works for you:
https://rallly.yourdomain.com/p/abc123xyz

We'll lock in the final time on Friday.

Participants click, vote without creating an account, and you see results in real-time.

Embedding in Your Website

Rallly polls can be linked from any internal portal or company website — no embedding code required. Share the poll URL and participants use it directly.

Using Alongside Cal.com

Common team setup:

• Rallly for group scheduling (team meetings, recurring syncs)
• Cal.com for individual booking (1:1s, customer calls)

Both run on the same server with different subdomains:

• rallly.yourdomain.com — group polls
• cal.yourdomain.com — individual booking pages

Cost Comparison

Doodle Premium (Annual, 5 Users)

Plan	Monthly	Annual
Free (ads)	$0	$0
Premium	$6.95/user	$417

Rallly Self-Hosted

Component	Monthly	Annual
Hetzner CX22 (4GB)	$5	$60
Domain/SSL	~$1	~$12
Total	$6	$72

Self-hosted Rallly: $72/year for unlimited users, unlimited polls. Doodle Premium (5 users): $417/year.

Savings: $345/year — and no per-user pricing that scales against you as your team grows.

Find More Scheduling Tools

Browse all Doodle and Calendly alternatives on OSSAlt — compare Rallly, Cal.com, and every other open source scheduling platform with deployment guides.