Pocket Pairs, two players, real time
Personal project
· React, Supabase, Lovable
· Built and shipped May 2026
Pocket Pair is a trick-taking game I grew up playing. The version I like, 7-8, is built for two players, and no decent online version of it exists. So I built one: shareable room links, a 30-card deck, trump selection, live sync between two devices.
What I Built
A real-time two-player web app. One player creates a game and gets a shareable URL, the second player joins through it, and the room locks permanently at two. The server holds the authoritative game state: dealing, trump, legal moves, trick resolution, and scoring are all enforced server-side rather than trusted to either client. Realtime sync keeps both boards identical, and a heartbeat detects when someone drops.
That was a deliberate call. The client renders the game. It never decides it.
My Ideas:
The trump picker was choosing blind
The non-dealer picks trump, which is the single highest-leverage decision in the hand. I had them picking before their cards rendered. Technically the sequence was correct. Practically it turned a strategic choice into a coin flip. I moved the reveal ahead of the prompt and put the suit buttons directly beside the hand.
The table cleared before anyone could read it
The second card landed, the server resolved the trick, and the board advanced immediately. Correct, and completely illegible. You could not tell what had just happened to you. I added a hard five-second hold: both cards stay on the table, the winning card gets a gold border, and a banner names the winner before the board advances. I made the software slower on purpose. It was the best decision in the project.
The score was a string
Cumulative score and trick count were rendered as text. Players had to parse a sentence to answer a question they were asking constantly: am I ahead? I rebuilt it as a panel with per-player tiles, the running score in display type, live trick count, and a color-coded differential chip. Green ahead, red behind. Answerable at a glance.
What it taught me
Two things carried out of this and into everything else I work on.
The first is that correctness and comprehension are separate problems, and the second one is usually the one people actually feel. My rules engine was right the whole time. What was broken was that a person could not follow what the system had just done to them. I have run into the same gap in operational software, where a process is technically sound and still forces a human to do the reconciling.
The second is that deciding what the client is allowed to determine on its own is a product decision before it's an engineering one. Here it was cheating. Elsewhere it's an agent acting without review. Same question: what does this system get to decide alone, and where does a person have to be.