Rallly

Rallly is an open-source scheduling tool that makes coordinating group meetings effortless. Instead of endless email threads asking everyone for their availability, you create a poll with proposed time slots, share a single link, and let participants vote on when they can meet — no account required to respond.

Built on the T3 stack with Next.js, Prisma, tRPC, and TailwindCSS, Rallly runs on PostgreSQL and ships as a Docker image, making self-hosting straightforward for teams that need full data ownership. The application supports spaces for team organization, Google Calendar integration, video conferencing link management (Zoom, Google Meet, Microsoft Teams), and a multi-language interface covering more than ten languages through community translations on Crowdin.

Beyond the free self-hosted version, Rallly offers a hosted cloud tier at rallly.co with a Pro plan that unlocks additional team features like Spaces with centralized billing, member management, and persistent poll storage. Self-hosted instances operate without seat limits or subscription requirements, though cloud-only features like Quick Create are not available in self-hosted mode.

The project has been actively maintained since 2015, reached version 4 in 2025 with a major architectural overhaul, and maintains a consistent release cadence with multiple releases per month. It is sponsored by the Vercel Open Source Program and backed by a growing community on Discord.

What You Get

• No-account poll voting - Participants open the invite link and vote on available time slots without signing up, reducing friction to zero for occasional collaborators.
• Live availability grid - See all participant responses at a glance in a color-coded grid that updates in real time as new votes come in.
• Meeting finalization with notifications - Organizers pick the winning time slot and Rallly automatically emails all participants with the confirmed date and time.
• Google Calendar integration - Connect your Google Calendar to sync meeting times and create calendar events directly from finalized polls.
• Video conferencing links - Attach Zoom, Google Meet, Microsoft Teams, phone, or custom conferencing details to any poll so participants always have the join link.
• Spaces for team organization - Group polls under shared team spaces with member management, centralized billing, and role-based access control.
• Self-hosting with Docker - Deploy Rallly on your own infrastructure using Docker Compose with a single environment file for all configuration options.
• 10+ language support - Community-translated interface via Crowdin covering major world languages so global teams can use Rallly in their native language.
• Dynamic OG image generation - Every poll generates a branded social preview image server-side using custom fonts, making shared links look professional in any chat app.
• Event types and quick scheduling - Define reusable event templates so repeat meetings like weekly standups can be polled with one click.

Common Use Cases

• Remote team sprint planning - An engineering team spread across three time zones creates a Rallly poll each sprint to agree on a retrospective slot without a single scheduling email.
• Open source project contributor calls - A maintainer polls contributors who have never interacted before, collecting availability without asking anyone to register.
• University group project coordination - Students use Rallly to find a shared study slot across different class schedules, sharing the link in a group chat for quick votes.
• Nonprofit board meeting scheduling - A volunteer board with busy professionals polls quarterly meeting times weeks in advance, letting members respond at their own pace.
• Client workshop booking - A consultant shares a Rallly link instead of a Calendly booking page when multiple client stakeholders need to attend the same workshop.
• Community event planning - A local running club uses Rallly to pick weekend route dates, with members voting from a mobile browser without installing anything.

Under The Hood

Architecture Rallly uses a Turborepo monorepo with a clear separation between the main web application, shared packages for database access, email templates, UI components, billing, and internationalization. The Next.js app organizes features by domain — each feature folder owns its data access, mutations, server actions, validation schemas, and React components — producing a modular, layered structure where feature boundaries are explicit rather than enforced by framework convention. tRPC procedures serve as the type-safe API layer between client and server, with distinct procedure tiers (public, private, space-scoped, pro-only) enforced via middleware, so access control is co-located with the routes that need it. Prisma handles all PostgreSQL interactions through a generated, type-safe client, and the database package owns migrations so schema changes are versioned alongside application code.

Tech Stack The application runs on Next.js 16 with React 19, deployed behind a Node 24 runtime. tRPC v11 provides end-to-end type safety between React Query hooks on the client and server-side resolvers, eliminating REST boilerplate without sacrificing type inference. PostgreSQL is accessed through Prisma v7 with a pg adapter, and Zod v4 validates all input at the API boundary. Hono powers lightweight API routes for integrations and scheduled housekeeping tasks with rate limiting via Upstash Redis. Authentication is handled by better-auth with OAuth and email magic links, Stripe manages billing through webhooks, and the AI SDK with OpenAI integration powers upcoming AI-assisted features. TailwindCSS v4 and Radix UI primitives form the design system, with Biome handling linting and formatting across the entire monorepo.

Code Quality The test suite covers the application at multiple layers: Playwright end-to-end tests exercise critical user flows including poll creation, voting, commenting, guest-to-user migration, i18n switching, and housekeeping; Vitest unit tests cover utility functions, date/time logic, and ICS generation with explicit edge-case assertions. Type safety is enforced comprehensively — Zod schemas validate all external input, TypeScript strict mode is on everywhere, and tRPC eliminates any unsafe client-server contract. Biome enforces consistent formatting and linting with pre-commit hooks via Husky and lint-staged. Error handling uses structured loggers from a shared logger package and safe-action wrappers with typed server action results. The codebase is relatively sparse on inline comments but compensates with self-describing naming, small focused functions, and domain co-location that makes intent clear from file structure.

What Makes It Unique Rallly’s most technically interesting decision is collapsing the guest participation model — anyone can vote on a poll via a URL-encoded token without server-side session state, while still receiving email confirmation and an editable submission link. This is implemented by embedding participant tokens directly in URLs rather than session cookies, letting tRPC procedures resolve participant identity from the request without authentication middleware. The dynamic OG image route uses Next.js ImageResponse with bundled Inter fonts read from disk at startup, producing per-poll social cards without any external image service. The housekeeping system uses a Hono cron endpoint protected by a shared secret that runs tiered cleanup logic, deleting only polls from non-subscribed spaces where all options are in the past — the subscription tier check is done inside the cleanup query so no poll is accidentally purged from a paid space. Conferencing support is modeled as a Zod discriminated union over five provider variants, making it easy to add new conferencing types without touching existing code paths.

Self-Hosting

Rallly is released under the GNU Affero General Public License v3.0 (AGPLv3). In plain terms this means you can freely run, modify, and distribute Rallly, but any modified version you deploy as a network service must also be made available under the same AGPLv3 terms. For internal use within your organization — running Rallly for your own employees without offering it to the public — this copyleft obligation does not impose any code-sharing requirement. Commercial use is permitted. The license is well-suited for teams that want to self-host a trusted open-source tool, but developers who want to embed Rallly’s core into a proprietary SaaS product would need to negotiate a separate commercial license with the author.

Running Rallly yourself requires a PostgreSQL database, an SMTP relay for outgoing notifications, and a container runtime for the official Docker image. The configuration surface is manageable — a single .env file covers database credentials, email settings, authentication providers, and optional integrations like Google OAuth, Stripe, and S3-compatible storage. The application has no built-in clustering or horizontal scaling configuration, so production deployments that need redundancy must handle load balancing and database connection pooling at the infrastructure layer. Database migrations are managed by Prisma and must be run manually on each upgrade, so you need a migration step in your deployment pipeline. The project upgrades frequently — several releases per month — so staying current requires attention, though the changelog is detailed and breaking changes are documented.

Compared to the hosted tier at rallly.co, self-hosters give up access to Quick Create (a cloud-only feature), the SaaS team’s infrastructure management, and any future cloud-exclusive capabilities. The Pro plan on the cloud version adds unlimited poll retention, Spaces with centralized billing, and advanced team management. On a self-hosted instance, those features are unlocked for everyone without a subscription, but you bear the operational responsibility for backups, uptime, and security patching. There is no official support SLA for self-hosters; community support is available on Discord.