Rallly is an open-source scheduling and collaboration tool built to simplify the process of organizing group meetings and events. It allows users to create poll-based scheduling forms where participants can indicate their availability, helping teams and friends find optimal times without the clutter of back-and-forth emails. Designed with modern web technologies like Next.js, tRPC, Prisma, and TailwindCSS, Rallly offers a clean, responsive interface that works across devices. It’s ideal for small teams, community organizers, educators, and anyone who frequently coordinates schedules across multiple people. The tool is self-hostable, giving users full control over their data and customization options.
What You Get
- Poll-based scheduling - Create customizable event polls where participants select available time slots; Rallly automatically aggregates responses to identify the best times.
- Multi-participant collaboration - Share poll links via email or messaging apps; participants can respond without needing an account, making it accessible for external collaborators.
- Self-hosting support - Deploy Rallly on your own infrastructure using Docker and PostgreSQL, with full configuration options documented for environment variables and database setup.
- Internationalization (i18n) - Fully translated interface with Crowdin integration, supporting multiple languages out-of-the-box for global teams.
- T3 Stack architecture - Built with the full T3 stack (Next.js, tRPC, Prisma, TailwindCSS) for type-safe APIs, scalable data modeling, and modern UI components.
- Real-time updates - Participants see updated availability in real time as others respond, reducing duplication and confusion.
Common Use Cases
- Building a team meeting scheduler - A remote engineering team uses Rallly to coordinate weekly standups across time zones, letting members pick slots that fit their schedules without organizing email threads.
- Organizing community events - A local book club uses Rallly to schedule monthly meetups, sending poll links to 20+ members who respond via mobile without creating accounts.
- Problem: Scheduling chaos → Solution: One poll - You’re planning a birthday party with 15 friends; instead of sending 15 individual messages, you create one Rallly poll that shows available dates and times in real time.
- Team onboarding with asynchronous coordination - New hires are invited to schedule their orientation via a Rallly poll, reducing administrative overhead for HR teams.
Under The Hood
Rallly is an open-source collaborative scheduling platform designed with a focus on transparency, self-hosting, and developer-friendly extensibility. It leverages modern web technologies to deliver a robust solution for organizing group events and meetings.
Architecture
Rallly follows a monorepo structure that enables centralized management and modular development across multiple applications and shared packages.
- The system is organized into distinct modules with clear separation between frontend, backend, and shared utilities
- Service-oriented design is evident in how features like calendar integration and authentication are encapsulated into dedicated services
- Component-based architecture promotes reuse and maintainability across different parts of the application
- Layered approach ensures separation of concerns between UI, API, and data access logic
Tech Stack
Built with TypeScript and React 19, Rallly utilizes modern web frameworks and tooling to support its diverse set of applications.
- The platform is powered by Next.js for the web and landing pages, with a strong emphasis on React 19 features and patterns
- A rich ecosystem of UI libraries including lucide-react, radix-ui, and react-hook-form is integrated throughout the codebase
- pnpm and turbo are used for monorepo management and build orchestration, supporting fast development workflows
- Comprehensive testing is implemented using Playwright for E2E and Vitest for unit and component tests
Code Quality
Rallly maintains a solid codebase with consistent practices in testing, error handling, and component design.
- A structured approach to testing is evident with end-to-end and unit tests covering key functionality
- Error handling follows predictable patterns using try/catch blocks and centralized exception management
- Code consistency is maintained through shared components, configuration files, and naming conventions
- Despite some duplicated logic and incomplete test coverage in core areas, the overall structure supports maintainability
What Makes It Unique
Rallly stands out in the collaborative scheduling space through its open-source ethos and flexible deployment model.
- The platform emphasizes self-hosting capabilities, allowing users to run the application without relying on third-party services
- Modular monorepo architecture enables extensibility and deployment flexibility across different environments
- A strong focus on developer experience is reflected in the cohesive tooling and component design patterns
- Transparency in development practices and open contribution model differentiate it from proprietary scheduling tools