PRODUCT DESIGN & ENGINEERING
Less process. More poker.
A free, collaborative planning poker application that makes agile estimation simpler and more enjoyable.
Pointless Poker
Next.js · TypeScript · PostgreSQL · Supabase Realtime

A small tool for a shared decision
Planning poker should help a team talk about uncertainty. Accounts, onboarding, and administrative setup can get in the way of that conversation. Pointless Poker keeps the experience focused: a room, a shared deck, and a moment to reveal what everyone thinks.
It’s free to use, with no account required. A shareable room link brings participants into the same estimation session, while friendly characters give each person a recognizable place at the table.
The experience
Create a room, share its invitation link, and choose an estimation deck. Participants select their cards privately. The host reveals the estimates together, giving the team a starting point to discuss differences before moving to another round.
Fibonacci, modified Fibonacci, T-shirt, linear, powers-of-two, and custom decks accommodate different estimation conventions. Observers can follow a session without voting.
Product decisions
Start with a room, not an account
Guest participation keeps setup short. The application still needs an identity boundary: a random server-generated guest credential is stored in an HttpOnly cookie, with only its hash persisted in PostgreSQL. Account-free participation does not mean trusting a participant ID supplied by the browser.
Private means private at the data boundary
Before reveal, a participant can retrieve their own estimate, but not anyone else’s card value. The database snapshot projects other participants’ voting status without exposing their unrevealed estimates. Privacy is enforced before the response reaches the interface.
Offer choices where teams differ
Multiple decks support different estimation habits. Custom deck values are validated at both the API and database boundary. Changing a deck clears the current estimates and rotates the round request identifier, so delayed votes cannot restore values from the previous deck.
Engineering the shared state
The application uses Next.js App Router and TypeScript, with server endpoints mediating application operations. PostgreSQL holds the authoritative room, membership, round, and vote state. Supabase provides the database connection and real-time signals.
Serialize the decisions that must agree
Room mutations lock the room row before checking membership, host privileges, round identity, and phase. This orders simultaneous votes, reveals, and round changes at the database boundary. A unique constraint enforces one vote per participant per round.
Signal changes; fetch authorized state
Real-time broadcasts carry an empty invalidation signal rather than room rows or votes. A client receiving a signal refetches its protected snapshot. Cosmetic presence runs separately and never authorizes an action or controls reveal eligibility.
Snapshot versions reject stale responses. Fifteen-second fallback polling, reconnect handling, and focus refresh help repair state when a broadcast is missed.
Trade-offs made explicit
Consistency costs a round trip. Refetching a protected snapshot after an invalidation requires another request. It keeps authorization and vote projection in one place rather than distributing sensitive state through a public channel.
Invitation links are capabilities. Anyone with a room link may join. These rooms serve lightweight team estimation; they are not access-controlled organizations. This keeps joining simple while defining a clear access boundary.
A temporary disconnect is not a transfer of ownership. Closing the browser preserves the host’s role. Explicitly leaving transfers it. A permanently abandoned host requires a fresh room, trading automatic takeover for predictable host recovery.
What the implementation demonstrates
A deliberately narrow product can still require careful engineering. Here, the visible experience stays simple while the implementation accounts for concurrent actions, unrevealed data, stale requests, and interrupted connections.
The source includes domain tests, PostgreSQL integration tests through PGlite, and multi-context browser scenarios. This case study describes the inspected implementation; it does not claim adoption figures, measured performance, or production reliability results.