Rallly: Self-Hosted Meeting Scheduler (Doodle Alternative)

Scheduling a meeting with more than two people is one of those problems that should have been solved decades ago. Instead, we get an endless back-and-forth of "Does Tuesday work? No, how about Thursday? Actually, can we do next week?" messages that consume more time than the meeting itself.

Photo by KOBU Agency on Unsplash

Doodle solved this elegantly — create a poll with time options, share the link, everyone picks their availability, and you choose the time that works for the most people. Simple. But Doodle has gone the way of so many good tools: paywalls, feature creep, mandatory accounts, and aggressive upselling.

Rallly (yes, three L's) is the self-hosted answer. It is a clean, fast, open-source scheduling tool that does exactly what Doodle does — without the ads, tracking, or subscription fees. Participants do not need accounts. They click a link, mark their availability, and you are done.

What Makes Rallly Worth Self-Hosting

You might wonder why you would bother deploying your own scheduling tool when free options exist. Here are the reasons:

Privacy. Every time you create a Doodle poll, you are handing over participant names, email addresses, and scheduling patterns to a company that monetizes that data. With Rallly on your own server, none of that leaves your infrastructure.

No accounts required. Participants just need the poll link. No sign-up walls, no "continue with Google" popups. This dramatically increases response rates because you are removing friction.

Custom domain. Send scheduling links from schedule.yourdomain.com instead of rallly.co. Professional, branded, and under your control.

Reliability. No more "sorry, Doodle is down" moments. Your scheduling tool has the same uptime as your server.

Feature Overview

Deploying Rallly with Docker Compose

Rallly requires a PostgreSQL database and optionally an SMTP server for email notifications. Here is the complete setup:

# docker-compose.yml
version: "3.8"

services:
  rallly:
    image: lukevella/rallly:latest
    container_name: rallly
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      # Database
      DATABASE_URL: postgres://rallly:rallly_password@rallly-db:5432/rallly
      # Security
      SECRET_PASSWORD: your-secret-password-at-least-32-chars
      # URLs
      NEXT_PUBLIC_BASE_URL: https://schedule.yourdomain.com
      ALLOWED_EMAILS: "*"
      # SMTP (optional but recommended)
      SMTP_HOST: smtp.fastmail.com
      SMTP_PORT: 587
      SMTP_SECURE: "true"
      SMTP_USER: [email protected]
      SMTP_PWD: your-app-password
      SUPPORT_EMAIL: [email protected]
      NOREPLY_EMAIL: [email protected]
    depends_on:
      rallly-db:
        condition: service_healthy

  rallly-db:
    image: postgres:16-alpine
    container_name: rallly-db
    restart: unless-stopped
    environment:
      POSTGRES_USER: rallly
      POSTGRES_PASSWORD: rallly_password
      POSTGRES_DB: rallly
    volumes:
      - rallly_db:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U rallly"]
      interval: 5s
      timeout: 5s
      retries: 5

volumes:
  rallly_db:

Generate secure values for SECRET_PASSWORD:

openssl rand -base64 32

Start the stack:

docker compose up -d

Initial Setup

Navigate to your Rallly instance. The first thing you will notice is that there is no admin panel or complex configuration wizard. Rallly is intentionally simple.

You can start creating polls immediately. If you configured SMTP, you can also register an account to manage your polls from a dashboard and receive email notifications when participants respond.

Creating Your First Poll

The poll creation flow is straightforward:

1. Title: Give your event a name (e.g., "Q1 Planning Meeting")
2. Description: Optional context about the meeting
3. Location: Where the meeting will happen (physical address, Zoom link, etc.)
4. Dates: Click on calendar dates to add options. For each date, you can optionally add specific time slots
5. Settings: Set deadline, require participant email, or limit to specific email domains

Here is what makes Rallly's interface genuinely good:

• Calendar picker: Visual calendar where you click dates rather than typing them
• Time zones: Automatic detection with manual override. Participants see times in their own zone
• Drag to select: For time-range polls, drag across time blocks rather than clicking each one

Sharing the Poll

After creation, you get a shareable link. Send it via email, Slack, Teams, or carrier pigeon. Participants see the poll, enter their name, and check the boxes for dates/times that work for them.

No account. No sign-up. No "we'd love to show you this poll, but first create a free Doodle account" nonsense.

Email Configuration Deep Dive

Email notifications transform Rallly from useful to essential. Without email:

• You manually check if people have responded
• Participants do not get reminders
• You cannot send "final decision" notifications

With email configured, Rallly sends:

• New response notification: When someone fills out the poll
• Comment notifications: When participants leave comments
• Final decision: When you finalize the meeting time

SMTP Options

Any SMTP server works. Common self-hosted options:

# Fastmail
SMTP_HOST=smtp.fastmail.com
SMTP_PORT=587

# Gmail (app password required)
SMTP_HOST=smtp.gmail.com
SMTP_PORT=587

# Mailgun
SMTP_HOST=smtp.mailgun.org
SMTP_PORT=587

# Self-hosted (Stalwart, Postfix, etc.)
SMTP_HOST=mail.yourdomain.com
SMTP_PORT=587

If you do not want to set up SMTP, Rallly works perfectly fine without it — you just lose the notification features.

Reverse Proxy Setup

For production use, put Rallly behind a reverse proxy with HTTPS.

Caddy

schedule.yourdomain.com {
    reverse_proxy localhost:3000
}

Nginx

server {
    listen 443 ssl http2;
    server_name schedule.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/schedule.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/schedule.yourdomain.com/privkey.pem;

    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;
    }
}

Traefik Labels

labels:
  - "traefik.enable=true"
  - "traefik.http.routers.rallly.rule=Host(`schedule.yourdomain.com`)"
  - "traefik.http.routers.rallly.tls.certresolver=letsencrypt"
  - "traefik.http.services.rallly.loadbalancer.server.port=3000"

Make sure NEXT_PUBLIC_BASE_URL in your environment matches the public URL exactly. Rallly uses this to generate poll links, and a mismatch means broken links.

Tips for Getting People to Actually Use It

Self-hosting a scheduling tool is only useful if people actually respond to your polls. Some practical advice:

Keep the URL clean. schedule.yourcompany.com looks legitimate. 192.168.1.50:3000 does not. People are trained to be suspicious of random URLs with port numbers.

Use descriptive poll titles. "Meeting" is useless. "Product Review - Week of Feb 17" tells people exactly what they are responding to.

Set deadlines. Enable the deadline feature so procrastinators know they have a cutoff. "Please respond by Thursday" in the description works too.

Send the link directly. Do not embed it in a paragraph of text. Send the URL on its own line so it is easy to click on any device.

Follow up once. If someone has not responded after 48 hours, a single "hey, could you fill this out?" message is fine. The low-friction design means most people respond quickly if they see the link.

Backup and Maintenance

Rallly's data lives entirely in PostgreSQL. Back up the database regularly:

#!/bin/bash
BACKUP_DIR="/backups/rallly"
mkdir -p "$BACKUP_DIR"

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

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

Updating Rallly

cd /opt/stacks/rallly
docker compose pull
docker compose up -d

Rallly handles database migrations automatically on startup, so updates are typically seamless.

Resource Usage

Rallly is remarkably efficient:

Total footprint is around 200-250 MB of RAM. You can comfortably run this on the smallest VPS alongside other services.

Alternatives Considered

If Rallly does not quite fit, here are other self-hosted scheduling options:

• Cal.com: Full-featured scheduling platform (like Calendly). Much heavier, more suited to appointment booking than group polls.
• Easy!Appointments: Appointment scheduling for businesses. Not designed for group availability polls.
• Framadate: Another Doodle alternative from Framasoft. Functional but the UI feels dated compared to Rallly.

Rallly wins for the specific use case of "I need to find a time that works for a group" because it is laser-focused on that problem without trying to be a full calendar or booking system.

Final Thoughts

Rallly solves a specific, common problem with zero unnecessary complexity. It is one of those self-hosted tools where the deployment time (five minutes) is shorter than the time you would spend arguing about meeting times without it.

The three-L spelling is quirky, but the software is solid. Active development, clean codebase, responsive maintainer, and a growing community. If you coordinate meetings with groups of people — whether for work, community events, or social gatherings — Rallly earns its place in your Docker stack.

Set it up, put it behind your reverse proxy, and start sending scheduling links instead of "when works for you?" messages. Your inbox will thank you.