QUORUM

Group decisions without groupthink: everyone rates options privately, then all scores are revealed at once, and the group votes on what they can live with. Real-time rooms, no accounts.

Comment

Inspiration

Group decisions go wrong in a predictable way: someone shares an opinion first, everyone else anchors to it, and the loudest voice wins. Where to eat, which trip to take, which feature to build: group chats turn these into back-and-forth with hidden agendas. We wanted a room where everyone is honest first and the group talks second.

What it does

Quorum is a real-time decision room for small groups (2-12 people). No accounts, just a 6-character code.

  1. Lobby: the host creates a room and friends join with the code.
  2. Options: anyone adds options (up to 10), and AI can suggest a few more.
  3. Rating: everyone rates every option from 1 to 5, with an optional reason. Ratings are hidden from everyone else, and a progress tracker shows who has finished.
  4. Reveal: all ratings appear together in a matrix with mean and spread per option. The AI points out where the group disagrees and suggests a compromise.
  5. Voting: approval voting, where each person selects every option they can live with.
  6. Decided: the option with the most approvals wins, ties are shown openly, a summary is generated, and the result can be exported as Markdown.

How we built it

  • Frontend: Next.js 16 (React 19), TypeScript, Zustand, shadcn/ui and Tailwind, with Socket.IO client for real-time updates.
  • Backend: Node.js, Express and Socket.IO, with Zod validation on every input and an in-memory room store with a 4-hour idle expiry.
  • Privacy by architecture: every piece of state that leaves the server goes through a single function, viewFor(), which strips other people's ratings during the rating phase. Hiding is enforced on the server, not just in the interface, and our tests check the serialized JSON.
  • AI that never blocks: an OpenAI-compatible model suggests options, analyzes disagreements and writes the summary, with a 15-second timeout. If the AI is missing or slow, a deterministic fallback produces the verdicts and compromise in under 100 ms.
  • Reconnection without accounts: resume tokens (hashed with bcrypt on the server) let people rejoin a room after dropping off.
  • Monorepo: pnpm workspaces with a shared package for types and schemas, so frontend and backend can't drift apart. Docker is set up for deployment.

Challenges we ran into

  • Keeping ratings private for real. Hiding scores in the UI isn't enough, so we routed all outbound state through one function and tested it so no other participant's data can appear in a payload.
  • Making AI optional. We wanted the app to work when the model is slow or unavailable, so the fallback logic had to be good enough to stand on its own.
  • Reconnects and host changes. Real-time rooms need to survive dropped connections, so we added resume tokens and host promotion after a disconnect.

Accomplishments that we're proud of

  • A complete flow from lobby to decision, not just a prototype of one screen.
  • A privacy guarantee enforced at the data layer and covered by tests.
  • An app that still works fully when the AI isn't available.

What we learned

  • Private input before discussion changes the quality of a group conversation, and the reveal moment becomes the interesting part.
  • Approval voting is simpler for groups than ranking, and it shows what everyone can accept instead of what a majority prefers.
  • Treating AI as a helper with a safe fallback is more reliable than building the app around it.

What's next for QUORUM

  • Redis adapter so rooms can run on multiple server instances.
  • Comment threads per option and custom rating scales.
  • Room templates for recurring decisions, and export to PDF with charts.
  • An anonymous mode where names stay hidden even after the reveal.
  • Mobile apps and integrations with chat tools.

Built With

Share this project:

Updates

Submission history