Rallly vs Framadate vs Dudle: Best Self-Hosted Doodle Alternatives 2026

Organizing a team meeting across multiple time zones, planning a family reunion, or coordinating a volunteer event used to mean one thing: create a Doodle poll and hope nobody complains about the ads. In 2026, there is a better way. Self-hosted collaborative scheduling tools let you create polls, gather availability, and find the best time — without handing your group’s data to a third-party service.

This guide compares the three best open-source Doodle alternatives you can run on your own server: Rallly, Framadate, and Dudle. Each takes a different approach to the same problem, and each has its own strengths depending on your needs.

Why Self-Host Your Scheduling Polls

The case for running your own collaborative scheduling tool comes down to four factors:

Privacy: When you use Doodle or similar SaaS tools, every participant’s name, email, and availability choice is stored on a commercial server. For teams handling sensitive projects, this data exposure is unnecessary. Self-hosting keeps all scheduling data on your own infrastructure.

No ads, no upsells: Doodle’s free tier is filled with banner ads and constant prompts to upgrade. Self-hosted alternatives are completely free — no per-user licensing, no feature gates, no “pro” tier you need to unlock basic functionality.

Branding control: When you send a scheduling poll from your own domain, it looks professional. No Doodle branding, no “Powered by” footers. The poll matches your organization’s identity.

Longevity: Doodle has changed its pricing, features, and ownership multiple times. A self-hosted tool lives as long as your server runs. There is no corporate decision that can shut it down or change its terms of service.

For teams that already run self-hosted tools like Cal.com for booking or Nextcloud for file sharing, adding a collaborative scheduling poll completes the coordination stack.

Quick Comparison Table

Rallly: The Modern Full-Featured Choice

Rallly is the most actively developed and feature-rich self-hosted Doodle alternative. Written in TypeScript with Next.js, it offers a polished interface, user accounts with OAuth sign-in, calendar integration, and a clean REST API.

With over 5,000 GitHub stars and regular releases, Rallly is the clear leader in this space. It supports both “pick a date” polls (find the best meeting time) and “yes/no/maybe” polls (should we do this thing?), making it versatile for both scheduling and general decision-making.

Key Features

• User accounts with OAuth: Sign in with Google, Microsoft, or any OIDC provider. This means you can manage who creates polls and delete old ones.
• Calendar integration: Export polls to ICS format and subscribe via any calendar app.
• Real-time updates: When someone votes, the poll updates live without a page refresh.
• Secret polls: Create polls accessible only via a shareable link — no public listing.
• Custom branding: Set a custom domain and remove any default branding.
• Email notifications: Participants get notified when the poll creator makes changes.

Docker Compose Deployment

Rallly ships with an official docker-compose.yml that sets up both the application and PostgreSQL database:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

services:
  rallly_db:
    image: postgres:14
    restart: always
    volumes:
      - db-data:/var/lib/postgresql/data
    environment:
      - POSTGRES_PASSWORD=your_secure_password
      - POSTGRES_DB=rallly
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5

  rallly:
    image: lukevella/rallly:latest
    restart: always
    depends_on:
      rallly_db:
        condition: service_healthy
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgres://postgres:your_secure_password@rallly_db/rallly
      - SECRET_PASSWORD=your_session_secret_here
      - NEXTAUTH_URL=https://rallly.yourdomain.com
      - NOREPLY_EMAIL=noreply@yourdomain.com
      - SMTP_HOST=smtp.yourdomain.com
      - SMTP_PORT=587
      - SMTP_SECURE=true
      - SMTP_USER=smtp_username
      - SMTP_PASSWORD=smtp_password

volumes:
  db-data:

Save this as docker-compose.yml and run:

1

docker compose up -d

Rallly will be available at http://localhost:3000. For production, place it benginxa reverse proxy like Nginx or Caddy with TLS termination.

Configuration Options

Framadate: The Lightweight PHP Option

Framadate is the original open-source Doodle clone, developed by the French non-profit Framasoft as part of their “Dégooglisons Internet” (let’s de-Google the internet) campaign. It has been around since 2014 and remains a solid, no-frills option for simple scheduling polls.

While the main repository on Framagit is now in maintenance mode, the codebase is stable and widely deployed across Europe, particularly by organizations that value software freedom and data sovereignty.

Key Features

• Zero registration: Anyone can create a poll instantly — no accounts needed.
• Multiple poll types: Standard date/time polls, classic yes/no/maybe polls, and free-text custom options.
• Simple administration: Delete polls, export results as CSV, and set expiration dates.
• Lightweight: Runs on any shared hosting with PHP and MySQL/MariaDB. No Node.js build step, no PostgreSQL requirement.
• GDPR-friendly: No user tracking, no analytics, minimal data collection.

Docker Deployment

Framadate does not have an official Docker image, but you can run it using a community-maintained image with MariaDB:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

services:
  framadate_db:
    image: mariadb:10.11
    restart: always
    volumes:
      - mariadb-data:/var/lib/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=admin_password
      - MYSQL_DATABASE=framadate
      - MYSQL_USER=framadate
      - MYSQL_PASSWORD=framadate_password

  framadate:
    image: ghcr.io/lefilament/framadate:latest
    restart: always
    ports:
      - "8080:80"
    depends_on:
      - framadate_db
    environment:
      - MYSQL_HOST=framadate_db
      - MYSQL_PORT=3306
      - MYSQL_USER=framadate
      - MYSQL_PASSWORD=framadate_password
      - MYSQL_DATABASE=framadate

volumes:
  mariadb-data:

Alternatively, deploy Framadate on any standard LAMP stack. It requires PHP 7.4+ with the pdo_mysql and intl extensions enabled. The installation process involves downloading the source, setting file permissions, and running a web-based installer.

1
2
3
4
5
6

# Manual installation on a LAMP server
cd /var/www/html
git clone https://framagit.org/framasoft/framadate/framadate.git
cd framadate
composer install --no-dev
chown -R www-data:www-data /var/www/html/framadate

Access the installer at http://yourserver/framadate/install.php and follow the setup wizard.

Dudle: The Minimal No-JavaScript Option

Dudle takes the opposite approach from Rallly. Written in Ruby, it requires zero JavaScript on the client side, stores everything in a single SQLite file, and runs on minimal hardware — a Raspberry Pi is more than sufficient.

Dudle is ideal for organizations with strict security policies that restrict JavaScript execution, or for administrators who want the simplest possible deployment with zero external dependencies.

Key Features

• No JavaScript required: Works entirely with server-rendered HTML forms. Accessible from any browser, including text-based ones.
• Single-file deployment: The entire application plus data lives in one directory with a SQLite database. No separate database server needed.
• Custom poll types: Beyond standard scheduling, you can create any poll with custom options (restaurant voting, feature prioritization, etc.).
• Password protection: Optionally password-protect individual polls.
• Lightweight footprint: Runs comfortably on 256 MB of RAM.

Docker Deployment

Dudle can be containerized using a simple Dockerfile:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

FROM ruby:3.2-slim

RUN apt-get update && apt-get install -y \
    sqlite3 libsqlite3-dev build-essential \
    && rm -rf /var/lib/apt/lists/*

RUN gem install bundler

WORKDIR /app
RUN git clone https://github.com/kellerben/dudle.git .

RUN bundle install

EXPOSE 3000
CMD ["ruby", "dudle.rb"]

Or use a docker-compose.yml with a pre-built image:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

services:
  dudle:
    image: ghcr.io/kellerben/dudle:latest
    restart: always
    ports:
      - "3000:3000"
    volumes:
      - dudle-data:/app/data

volumes:
  dudle-data:

The SQLite database file will be persisted in the dudle-data volume. No database server configuration is needed.

Choosing the Right Tool

The decision between these three tools comes down to your priorities:

Choose Rallly if:

• You want the most polished, modern interface
• You need user accounts with OAuth authentication
• You want calendar integration (ICS export)
• You need email notifications for poll participants
• Your server can handle a Node.js + PostgreSQL stack

Choose Framadate if:

• You want the simplest possible deployment on existing PHP hosting
• You don’t need user accounts — anonymous polls are fine
• You want a proven, stable tool that has been running in production since 2014
• You prefer MariaDB/MySQL over PostgreSQL
• You want the lightest resource footprint among the PHP options

Choose Dudle if:

• You have strict requirements against client-side JavaScript
• You want the absolute simplest deployment (single SQLite file)
• You are running on minimal hardware (Raspberry Pi, low-end VPS)
• You need maximum accessibility (text browsers, screen readers)
• You want MIT-licensed software (Rallly and Framadate are AGPL)

Deployment Architecture

For a production deployment, the recommended architecture for Rallly (the most complex of the three) looks like this:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

                    ┌─────────────────┐
  Internet ────────►│  Nginx / Caddy  │
  (HTTPS)           │  (TLS + proxy)  │
                    └────────┬────────┘
                             │
                    ┌────────▼────────┐
                    │    Rallly       │
                    │  (Next.js app)  │
                    │   Port 3000     │
                    └────────┬────────┘
                             │
                    ┌────────▼────────┐
                    │   PostgreSQL    │
                    │   Port 5432     │
                    │  (persistent)   │
                    └─────────────────┘

For Framadate, replace PostgreSQL with MariaDB and the Next.js container with a PHP-FPM + Apache container. For Dudle, the database layer disappears entirely — SQLite handles persistence within the application container.

FAQ

Can I migrate my polls from Doodle to a self-hosted tool?

Unfortunately, Doodle does not provide an export feature for polls. However, if you have the poll data (dates, options, votes), you can manually recreate it in Rallly or Framadate. For organizations planning a permanent migration, start by creating new polls on your self-hosted instance going forward rather than trying to migrate historical data.

Do these tools support recurring or template polls?

Rallly does not currently support recurring polls out of the box, but you can duplicate existing polls to quickly recreate similar scheduling requests. Framadate and Dudle are single-use poll tools — each poll is created from scratch. For recurring scheduling needs, consider pairing these with a tool like Cal.com which handles recurring booking pages.

Can I customize the look and feel of these tools?

Rallly supports custom branding through environment variables and theme customization in the source code. Framadate has built-in theme support — you can swap CSS files or create custom templates. Dudle uses basic HTML/CSS that is straightforward to modify. All three are open source, so you have full control over the appearance if you are willing to modify the codebase.

What happens if I forget to delete old polls?

Rallly allows poll creators to delete their own polls, and administrators can clean up the database. Framadate supports setting expiration dates on polls — they are automatically deleted after a configurable period. Dudle stores polls in the SQLite file indefinitely; you will need to manually remove old poll directories. For production use, set up a cron job to clean up expired polls.

Are these tools suitable for enterprise use?

Rallly is the most enterprise-ready option with OAuth authentication, OIDC support, and API endpoints. It can integrate with existing corporate identity providers like Active Directory or Okta. Framadate is suitable for internal team use but lacks authentication features. Dudle is best for small teams or informal use cases. For larger organizations that need scheduling at scale, Cal.com or Easy!Appointments may be more appropriate.

Can I run multiple self-hosted scheduling tools on the same server?

Yes. Each tool uses different ports and can be deployed alongside others. A common setup is Rallly for team scheduling polls on port 3000, with Cal.com for personal booking pages on port 3001, both behind a reverse proxy routing by domain or path. Just ensure each tool has its own database instance or at least separate database names.