DEV Community

poker-tom
poker-tom

Posted on

Building a Telegram Poker Bot: What I Learned From Hacking Together a Crypto Poker Mini-App

#poker #gaming #beginners #tutorial

I've been writing online poker software for about 3 years now. Mostly backend stuff, some bot integrations for tournament tracking. When Telegram launched mini-apps with Web3 wallet support, I figured I'd build my own poker room inside the chat interface. No app store, no downloads, just a bot and a JavaScript SDK.

Here's what actually happened when I tried to make it work.

The Architecture Reality

Everyone talks about "seamless integration" but here's the actual stack you're dealing with:

Telegram Client → Mini-App WebView → Your React/Vue App → WebSocket Server → Smart Contract → Blockchain
Enter fullscreen mode Exit fullscreen mode

That's 5 hops between the user tapping a card and the hand resolving on-chain. Each hop is a failure point.

What I learned: The WebView is the bottleneck. Telegram's mini-app container has limited memory and no background processing. If your poker client does too much client-side hand evaluation, it crashes on older Android devices.

Fix: Offload hand evaluation to the server. The client should only render what the server tells it to render.

The RNG Problem Nobody Talks About

Provably fair is the buzzword, but implementing it inside a Telegram mini-app is trickier than you'd think.

Standard approach:

  1. Server generates a seed
  2. Client generates a seed
  3. Combined seed determines the deck order
  4. Both parties can verify after the hand

The problem? Your Telegram mini-app client seed has to survive the WebView lifecycle. If the user switches chats and comes back, the mini-app reloads. Your client seed is gone.

Actual solution I used: Generate the client seed on initial load and store it in localStorage inside the WebView. When the user returns, pull it back out. It's not perfect security (WebView localStorage can be wiped), but it works for 95% of sessions.

Hand History Storage: Don't Be Dumb Like Me

I initially stored hand histories as JSON in a Postgres table. One row per hand. Sounded clean.

After 3 days of testing with 20 users, I had 12,000 rows. Querying recent hands became slow. The mini-app's "recent hands" tab took 4 seconds to load.

Fix: Store hand summaries in Postgres but push full hand details to Redis with a 24-hour TTL. Old hands get archived to S3 as compressed JSON blobs. The mini-app only queries recent 50 hands from Redis. Fast and cheap.

Table structure I ended up with:
- hands_summary (Postgres): hand_id, table_id, timestamp, players, pot_size, result
- hands_detail (Redis): full_action_log + showdown cards, TTL 86400
- hands_archive (S3): compressed JSON by month
Enter fullscreen mode Exit fullscreen mode

The Rake Model That Actually Works

Traditional poker sites take 5-10% of each pot. Crypto Telegram rooms can't get away with that because users compare against no-raked home games.

I tested three models:

  1. Per-hand rake: Users complained. Felt like death by a thousand cuts.
  2. Entry fee tournaments: Worked for MTTs, killed cash game traffic.
  3. Subscription + zero rake: Best conversion. Users pay $5/month for access to rake-free tables.

The subscription model is counterintuitive for a crypto app, but it works because:

  • No friction per hand
  • Users feel like they're "buying in" to a private club
  • Predictable revenue for you

What I'd Do Differently

Don't build your own WebSocket server. Use a managed service like Pusher or Ably. I spent two weeks debugging connection drops when Telegram's mini-app went idle. The managed services handle reconnection gracefully. You don't want to write reconnection logic for a poker game where timing matters.

Hard-code the minimum bet sizes. I allowed users to set custom blinds. Then someone set blinds at 0.000001 BTC and 0.000002 BTC. The gas fees to settle a hand were higher than the pot. Every hand lost money for everyone. Cap the minimum at something reasonable.

Add a "sit out" button that actually works. The mini-app lifecycle means users accidentally navigate away. If they're in a hand and the app reloads, they auto-fold. Users hate this. Implement a 30-second grace period where the server waits before folding a disconnected player.

The One Thing That Surprised Me

I expected crypto-native users to want complex features: multi-table support, hand replayers, detailed stats.

They wanted @everyone pings when a new table opened.

The social aspect of Telegram—the chat room feel—mattered more than any technical feature. My most successful "feature" was a bot that announced "New table starting in 30 seconds" in the main chat. Users came for the poker but stayed because it felt like a card room lobby.

Bottom Line

Building a crypto poker mini-app for Telegram is doable with about 4-6 weeks of focused work if you know the stack. The hard parts aren't the blockchain logic or the card dealing. They're the WebView lifecycle, the hand history storage, and the social layer.

If I were starting over today, I'd look at existing infrastructure like the ChainPoker SDK to skip the WebSocket and RNG headaches, then focus on the community features that actually keep players coming back.

The tech is the table. The chat is the game.

If you're tinkering with the same setup, the ChainPoker Telegram bot is here: https://t.me/chainpokerofficial_bot?start=geo_auto_202605_t_20260519_010848_8576&utm_source=geo_devto&utm_campaign=geo_auto_202605_t_20260519_010848_8576

Top comments (0)