Launching Poker Challenges: Sharpen Your Poker Math in Ninety-Second Races

Today I’m launching Poker Challenges, a browser-first poker trainer built around one simple promise: sharpen your math in ninety-second races.

Pick a topic, hit start and you’re solving equity, pot-odds, ICM and push/fold spots against the clock, racing live opponents or deterministic “ghosts” and climbing a skill rating with every correct answer. No install, no solver licence, no setup. Just open a tab and play.

The Problem

Serious poker study tooling is powerful but painful. GTO solvers are desktop-bound, expensive and built for post-session analysis, not reps. Trainers tend to be clunky or paywalled to the hilt. And almost none of it is fun: there’s no equivalent of Lichess Puzzle Racer, the addictive, ranked, ninety-second loop that turned chess tactics into something you do on a coffee break.

Poker math is perfect for that loop. Equity, pot odds and push/fold ranges are exactly the kind of fast, repeatable judgements that improve with volume. Poker Challenges takes the Puzzle Racer ethos and applies it to poker: instant, browser-first, ranked and enjoyable to grind.

Marketecture

Poker Challenges runs almost entirely on Cloudflare’s edge. A single Worker serves the app, runs the puzzle engines, coordinates real-time races and enforces billing, with the heavy poker math compiled to WebAssembly from Rust.

Figure 1. A single Cloudflare Worker serves the SPA, runs the puzzle engines, coordinates Durable Object races and enforces billing; the heavy poker math is compiled to WebAssembly from Rust.

The pieces, and why each one is there:

• Static SPA (Vite + React + TypeScript). Served straight from the Worker’s [assets] binding, so the same edge that runs the API also ships the front end. Routes cover Home, Puzzle, Race, Learn, Leaderboard, Profile and Pricing.
• Cloudflare Worker (itty-router). One entry point. Requests pass through middleware (session cookie → anon-id → route dispatch) before hitting the auth, billing, puzzle, solo, race and ratings routes. Living at the edge keeps round-trips short no matter where the player is.
• Puzzle engines. Equity, pot-odds, hand-reading, ICM, range-reading and push/fold (with a cache for the small, enumerable push/fold tree), plus the per-type scoring that grades each answer.
• Racer on Durable Objects. Each race is a Durable Object (race-do, queue-do, race-state), which gives every participant a single authoritative, consistent view of the puzzle stream and scoreboard. The same machinery replays deterministic “ghost” opponents, so a solo race is reproducible.
• pokerlib (Rust → WASM) is the hot path. The evaluator, equity calculator, range logic, solver and ICM model are written in Rust and vendored in as WebAssembly. Monte-Carlo equity and push/fold solving are CPU-bound; WASM gets them fast enough to run inline in the Worker.
• Storage (D1 · KV · Durable Objects). D1 (edge SQLite) holds users, sessions, subscriptions, ratings, the puzzle pool and race history; KV handles hot lookups; Durable Objects hold live race state. A webhook_events table backs idempotent billing (more on that below).
• Rating. A Glicko rating updates after every puzzle, with combo multipliers up to ×4 for streaks, so the leaderboard reflects skill rather than time played.
• External services. Stripe for billing (with async webhook verification) and OAuth for email-verified sign-in. Anonymous players get an anon-id immediately and can sign in later to keep their progress.

The simple subscription strategy

The architecture above is deliberately rich. The business model is deliberately not. The whole strategy fits in one sentence: one free thing, one paid thing, one price.

• Free forever. The ninety-second Puzzle Racer is the front door: free, playable anonymously and shareable, so a good score is a reason to challenge a friend. The free tier is the marketing.
• The paid tier. The deeper, self-paced Puzzle Trainer and the MDX lessons sit behind a single server-checked entitlement: one gate, not a matrix of tiers, seats or usage meters.
• $15 a month, 14-day free trial. A single recurring price, card up front. The trial earns commitment without a sales funnel; if the racer hooked you, the trainer is the obvious next step.

The gate lives on the server. A require-entitlement middleware in the Worker checks the player’s subscription on every protected request, so the front end never decides who’s paid and the paywall can’t be bypassed by poking at the client.

Figure 2. The paywall is enforced server-side: the Worker checks entitlement against D1 on every protected request, so the client can never unlock the Trainer on its own.

The plumbing is intentionally boring: Stripe Checkout to start a subscription, the Stripe Customer Portal to manage or cancel it and webhooks to keep our copy of the subscription in sync. Webhooks are verified and de-duplicated against a webhook_events table, so a retried event can’t double-apply. That’s the entire billing surface.

Keeping it simple has a payoff. Every tier, add-on and usage meter is something to build, price, explain, test and support. With one product and one price there is almost nothing to reason about: the free racer does the acquisition, the trial does the convincing and a single server-side check does the enforcing. It is the least machinery that still earns revenue, which means more time goes into the poker training.

Try it, and what’s next

Poker Challenges is live now at pokerchallenges.com. The Puzzle Racer is free; jump into a ninety-second race and see where your math stands. If you want to go deeper, the Trainer’s 14-day trial is one click away.

The roadmap leans into the loop: more puzzle types, richer lessons and sharper leaderboards. The foundation is built to grow without getting complicated: edge Workers, Durable Object races, a Rust/WASM core and one simple subscription.

If you build at the edge, train at poker or just like a lean SaaS, I’d love your feedback.