DEV Community: Haskell Thurber

How I Built a Referral System That Pays Users in Telegram Stars (And Actually Drives Growth)

Haskell Thurber — Thu, 05 Mar 2026 09:18:40 +0000

Most referral systems are an afterthought. A "Share with friends" button buried in settings that nobody ever clicks. I wanted mine to be different — and the results surprised me.

The Problem With Traditional Referrals

I built WhisprMe, an anonymous messaging Telegram Mini App. The concept is simple: you share your personal link, people send you anonymous messages, you read and reply.

The traditional approach would be: build the app, add a referral page later, offer some discount. But here's the thing — the referral IS the product.

Users can't receive anonymous messages without sharing their link. Every single user becomes a distribution channel by default. There's no separate "invite friends" flow because sharing is the core action.

How the Referral Revenue Works

When User A shares their link and User B signs up through it:

User B signs up → A becomes B's referrer
User B buys premium (50 Telegram Stars) → A earns 15% (7 Stars)
User B buys anything else → A earns 15% of that too

The key insight: pay referrers in the same currency users spend. Telegram Stars are the native payment method, so referral earnings are also in Stars. No PayPal, no bank transfers, no minimum thresholds. It's frictionless.

The Database Schema

Here's how I track referrals in PostgreSQL:

-- Users table has referral fields
ALTER TABLE users ADD COLUMN referred_by BIGINT REFERENCES users(telegram_id);
ALTER TABLE users ADD COLUMN referral_earnings INTEGER DEFAULT 0;

-- Track the chain: who referred who
-- When user B purchases, find their referrer and credit 15%

The referral is captured at signup time from a deep link parameter:

// Bot handles /start with referral parameter
bot.command('start', async (ctx) => {
  const referralCode = ctx.message.text.split(' ')[1];
  if (referralCode) {
    const referrer = await db.query(
      'SELECT telegram_id FROM users WHERE telegram_id = $1',
      [referralCode]
    );
    if (referrer.rows.length > 0) {
      // Store the referral relationship
      await db.query(
        'UPDATE users SET referred_by = $1 WHERE telegram_id = $2',
        [referrer.rows[0].telegram_id, ctx.from.id]
      );
    }
  }
});

Payment Flow with Telegram Stars

When a referred user makes a purchase, the referrer's earnings update automatically:

bot.on('successful_payment', async (ctx) => {
  const payment = ctx.message.successful_payment;
  const amount = payment.total_amount; // in Stars
  const buyerId = ctx.from.id;

  // Find referrer
  const user = await db.query(
    'SELECT referred_by FROM users WHERE telegram_id = $1',
    [buyerId]
  );

  if (user.rows[0]?.referred_by) {
    const referralEarning = Math.floor(amount * 0.15);
    await db.query(
      'UPDATE users SET referral_earnings = referral_earnings + $1 WHERE telegram_id = $2',
      [referralEarning, user.rows[0].referred_by]
    );
  }
});

The beauty of Telegram Stars: createInvoiceLink() handles the entire payment flow. No Stripe webhooks, no payment provider configuration. One API call.

What I Learned About Viral Coefficients

After launching, here's what the data showed:

Average shares per user: ~3.2 (users share their link in stories, groups, DMs)
Conversion from link click to signup: ~18%
K-factor: ~0.58 (each user brings 0.58 new users on average)

A K-factor below 1.0 means the app doesn't grow purely virally. But combined with organic discovery and content marketing, it creates a compounding effect. Each new user from content marketing multiplies through referrals.

The Leaderboard Effect

One thing that massively boosted sharing: a public leaderboard showing top users by messages received. People compete to get more anonymous messages, which means more sharing, which means more signups.

// Leaderboard query
const topUsers = await db.query(`
  SELECT username, display_name, 
         (SELECT COUNT(*) FROM messages WHERE recipient_id = u.telegram_id) as msg_count
  FROM users u
  WHERE is_banned = false
  ORDER BY msg_count DESC
  LIMIT 20
`);

This gamification layer turned passive users into active promoters without any additional incentive.

Key Takeaways

Build referrals INTO the product, not alongside it. If sharing is optional, most users won't.
Pay in native currency. Telegram Stars → Star earnings. No friction.
15% is the sweet spot. High enough to motivate, sustainable enough to maintain margins.
Leaderboards drive sharing better than referral bonuses alone. Social proof > monetary incentive.
Track K-factor obsessively. Even sub-1.0 is valuable — it's a multiplier on every other growth channel.

The Tech Stack

For anyone curious about the full setup:

Backend: Node.js + Express + PostgreSQL
Frontend: React (Telegram Mini App)
Bot: Telegraf.js
Payments: Telegram Stars (no external providers)
Hosting: $5/mo VPS with nginx

The entire referral system was about 200 lines of code. The hardest part wasn't building it — it was designing a product where sharing is the natural first action.

If you're building a Telegram Mini App and want to see how this works in practice, check out WhisprMe. Send yourself an anonymous message — the referral link on your profile page is how the viral loop starts.

I Replaced Stripe With Telegram Stars — Here's What Happened to My Conversion Rate

Haskell Thurber — Tue, 03 Mar 2026 14:14:37 +0000

TL;DR

I built a Mini App inside Telegram and used Telegram Stars for micropayments instead of traditional payment providers. The result: zero payment friction, working micropayments at $0.02, and a payment integration that's embarrassingly simple.

The Problem With Traditional Micropayments

I needed to charge users $0.02–$0.50 for individual actions in my app. If you've ever tried this with Stripe, you know the pain:

Minimum transaction fees eat your margin on anything under $1
Checkout abandonment — every redirect, every form field costs you 30%+ of users
PCI compliance — even with Stripe Elements, there's overhead
Account creation — users need to sign up, verify email, enter card details

For a social app where the entire experience should feel instant, this friction kills engagement.

Enter Telegram Stars

Telegram introduced Stars — a built-in micropayment currency for Mini Apps and bots. 1 Star ≈ $0.02. Users buy Stars through Apple/Google in-app purchases or directly through Telegram.

Here's what makes it different:

1. Zero Checkout Friction

Users tap "Pay 1 ⭐" → confirmation dialog → done. No card entry, no redirect, no account creation. The payment happens inside the same chat/app they're already using.

Traditional: Open app → See paywall → Redirect to checkout → 
Enter email → Enter card → Confirm → Wait → Return to app
(7 steps, ~60% dropout)

Stars: See paywall → Tap "Pay 1⭐" → Confirm → Done
(3 steps, ~5% dropout)

2. Micropayments Actually Work

The minimum Stars payment is 1 Star ($0.02). Try charging $0.02 on Stripe — between the $0.30 fixed fee and 2.9% variable fee, you'd lose $0.28 per transaction.

With Stars, Telegram takes ~30% (similar to App Store), but there's no fixed fee. A 1-Star payment nets you ~$0.014. Small, but profitable.

3. The Integration Is Embarrassingly Simple

Here's the complete payment flow in Node.js with Telegraf:

// Step 1: Create an invoice link
const invoiceLink = await bot.telegram.createInvoiceLink({
  title: "'Unlock Message',"
  description: "'Read the full anonymous message',"
  payload: JSON.stringify({ userId: 42, messageId: 123 }),
  provider_token: '',  // Yes, empty string. That's it.
  currency: 'XTR',     // Stars currency code
  prices: [{ label: 'Unlock', amount: 1 }]  // 1 Star
});

// Step 2: Handle pre-checkout (validate the purchase)
bot.on('pre_checkout_query', async (ctx) => {
  await ctx.answerPreCheckoutQuery(true);
});

// Step 3: Handle successful payment
bot.on('successful_payment', async (ctx) => {
  const payload = JSON.parse(
    ctx.message.successful_payment.invoice_payload
  );
  await unlockMessage(payload.userId, payload.messageId);
  await ctx.reply('Message unlocked!');
});

That's it. Three events. No webhook signing secrets, no idempotency keys, no retry logic. Compare this to a Stripe integration guide that spans multiple pages.

4. Built-in Refunds

// Refund a Stars payment
await bot.telegram.refundStarPayment(
  userId,           // Telegram user ID
  paymentChargeId   // From successful_payment event
);

One function call. No disputes, no chargebacks, no evidence submission.

What I Built: WhisprMe

WhisprMe is an anonymous messaging app inside Telegram. You share a link, friends send you anonymous messages, and you unlock them with Stars.

Pricing tiers:

1 Star — Read full message (see 3-word preview for free)
5 Stars — Get a hint about the sender
15 Stars/week — Plus subscription (unlimited reads)

Revenue streams (all Stars):

Message unlocks
Sender hints
Plus/Pro subscriptions
Virtual gifts (Hearts, Fire, Crowns)
Referral commissions (15-25% of referred users' purchases)

The referral system uses Telegram's native Affiliate Program API, so payments to referrers happen automatically.

The Stack

The entire backend is ~2000 lines of JavaScript:

Runtime: Node.js + Express
Database: PostgreSQL (raw SQL, 6 tables)
Bot framework: Telegraf.js
Frontend: React (served as Telegram Mini App)
Process manager: PM2 cluster mode
Hosting: Single $5/month VPS

No Redis. No message queue. No microservices. The entire thing runs on one server and handles everything I need.

Key Lessons

Auth is free

Telegram Mini Apps provide initData — a signed payload with user info. Verify the HMAC signature server-side, and you have authenticated users without building any auth system.

Distribution is built in

Users share links inside Telegram chats. The sharing IS the product — you can't get anonymous messages without sharing your link. This creates a natural viral loop without any marketing spend.

Monetization ceiling exists

Stars are great for micropayments but limited for high-ticket items. The maximum single payment is 10,000 Stars (~$200). If your product needs $500+ transactions, Stars won't work.

Telegram takes 30%

Same as Apple/Google. After Telegram's cut, 1 Star nets you ~$0.014. Plan your pricing accordingly.

Who Should Use Stars?

Stars work best for:

Social apps with micropayments ($0.02–$5 range)
Content unlocking / paywalls
Digital goods and virtual items
Subscription-based services
Tipping and donations

Stars don't work for:

Physical goods (use Stripe/PayPal payment bots instead)
High-ticket B2B ($200+ per transaction)
Apps outside Telegram ecosystem

Try It

If you're curious how Stars feel as a user:

Open @WhisprMe_bot in Telegram
Get your anonymous link and share it
When someone writes you, try unlocking for 1 Star

The whole experience takes about 30 seconds, and you'll see why frictionless micropayments change everything.

Building a Telegram Mini App? I'd love to hear about your Stars integration experience in the comments.

5 Things That Surprised Me Building a Telegram Mini App (Real Production Lessons)

Haskell Thurber — Tue, 03 Mar 2026 10:32:26 +0000

I recently built and launched WhisprMe — an anonymous messaging app that runs entirely inside Telegram as a Mini App. No app store, no downloads, just a link.

Here are 5 things that genuinely surprised me during development and after launch.

1. Telegram Stars Payments Are Absurdly Simple

I expected payments to be the hardest part. Credit card integrations, Stripe webhooks, PCI compliance nightmares…

Nope. Telegram Stars took about 30 lines of backend code:

// Create invoice
const link = await bot.telegram.createInvoiceLink({
  title: 'Unlock Anonymous Message',
  description: 'See who sent you this message',
  payload: JSON.stringify({ userId, messageId }),
  currency: 'XTR',
  prices: [{ label: 'Unlock', amount: 1 }]
});

// Handle pre-checkout
bot.on('pre_checkout_query', (ctx) => {
  ctx.answerPreCheckoutQuery(true);
});

// Handle successful payment
bot.on('message', (ctx) => {
  if (ctx.message.successful_payment) {
    const { userId, messageId } = JSON.parse(
      ctx.message.successful_payment.invoice_payload
    );
    // Unlock the message in DB
  }
});

That's it. Users tap "Pay 1 ⭐", confirm, done. No credit card forms. The conversion rate is significantly higher than traditional payment flows because there's zero friction.

2. Haptic Feedback Changes Everything

Adding this one line transformed how the app feels:

window.Telegram.WebApp.HapticFeedback.notificationOccurred('success');

I added haptic feedback on:

Message sent ✅
Message unlocked 🔓
Achievement earned 🏆
Button taps

Users never mentioned it explicitly, but engagement metrics went up after I added it. The app just feels native — like it belongs on the phone, not in a browser.

3. `initData` Is Your Auth Layer (But Validate It Server-Side!)

Telegram sends initData with every Mini App launch. It contains the user's ID, first name, username, etc. — cryptographically signed.

// Server-side validation
const crypto = require('crypto');

function validateInitData(initData, botToken) {
  const params = new URLSearchParams(initData);
  const hash = params.get('hash');
  params.delete('hash');

  const dataCheckString = [...params.entries()]
    .sort(([a], [b]) => a.localeCompare(b))
    .map(([k, v]) => `${k}=${v}`)
    .join('\n');

  const secretKey = crypto
    .createHmac('sha256', 'WebAppData')
    .update(botToken)
    .digest();

  const calculatedHash = crypto
    .createHmac('sha256', secretKey)
    .update(dataCheckString)
    .digest('hex');

  return calculatedHash === hash;
}

The surprise: I initially skipped server-side validation during development. Big mistake. Anyone can send fake initData from a browser console. Always validate the HMAC signature.

4. The Cold Start Problem Is Real

Building the app took 2 weeks. Getting the first 10 users took longer.

What worked:

Shareable links — each user gets whisprme.app/u/username that they can share on Instagram Stories, Telegram bio, etc.
Gamification — leaderboards and achievements gave people a reason to come back
Referral system — invite friends, get bonus messages

What didn't work:

Posting on Reddit (got auto-moderated everywhere)
Cold DMs (felt spammy, stopped after 2)

The social virality loop is key: someone receives an anonymous message → they're curious → they share their own link → their friends send messages → repeat.

5. A $5/month VPS Handles More Than You Think

My entire stack runs on a single Hetzner VPS:

Node.js/Express backend with PM2 cluster mode
PostgreSQL database
React frontend (static build served by Express)
Nginx reverse proxy with SSL

Total cost: ~$5/month. For the first 1000 users, this is more than enough. I was tempted to over-engineer with Kubernetes, Redis, separate microservices... but a monolith on a VPS just works.

# My entire deployment:
pm2 restart all

That's the whole CI/CD. 🤷

The Stack

For anyone curious:

Backend: Node.js, Express, Telegraf (bot framework)
Database: PostgreSQL with raw SQL (no ORM)
Frontend: React with vanilla CSS
Payments: Telegram Stars
Hosting: Hetzner VPS, PM2, Nginx
i18n: Custom solution supporting English + Russian

Try It

If you want to see a real-world Telegram Mini App in action:

👉 Open WhisprMe in Telegram

Share your link with friends, receive anonymous messages, and see the Stars payment flow in action. I'd love your technical feedback!

What's your experience with Telegram Mini Apps? Have you built one? What surprised you? Let me know in the comments!

How to Accept Payments in a Telegram Mini App Using Stars (Step-by-Step Guide)

Haskell Thurber — Tue, 03 Mar 2026 06:25:08 +0000

Telegram Stars are a built-in payment system for Mini Apps — no Stripe, no App Store fees, no payment gateway needed. Users pay with Stars they already have in Telegram, and you get paid directly.

In this tutorial, I'll show you exactly how to implement Stars payments in a Node.js + Express backend, based on what I built for WhisprMe — an anonymous messaging Mini App.

What Are Telegram Stars?

Stars are Telegram's in-app currency. Users buy them inside Telegram and spend them in Mini Apps and bots. As a developer, you:

Create an invoice via the Bot API
Handle the pre-checkout query
Confirm the payment
Deliver the digital good

There are zero platform fees for the first withdrawal (Telegram takes a cut on subsequent ones). The entire flow happens inside Telegram — no redirects, no card forms.

Prerequisites

A Telegram Bot (create one via @BotFather)
Node.js 18+
The telegraf package (or node-telegram-bot-api)
A Telegram Mini App connected to your bot

Step 1: Create the Invoice Endpoint

Your frontend calls this endpoint to get a payment link:

// routes.js
const { Telegraf } = require('telegraf');
const bot = new Telegraf(process.env.BOT_TOKEN);

app.post('/api/create-invoice', async (req, res) => {
  const { telegramId, itemType, amount } = req.body;

  try {
    const invoiceLink = await bot.telegram.createInvoiceLink({
      title: 'Premium Feature',
      description: 'Unlock premium features in WhisprMe',
      payload: JSON.stringify({ 
        userId: telegramId, 
        type: itemType 
      }),
      provider_token: '',  // Empty for Stars!
      currency: 'XTR',     // XTR = Telegram Stars
      prices: [{ 
        label: 'Premium', 
        amount: amount  // in Stars (1 Star = 1 unit)
      }]
    });

    res.json({ invoiceLink });
  } catch (err) {
    console.error('Invoice error:', err);
    res.status(500).json({ error: 'Failed to create invoice' });
  }
});

Key points:

provider_token must be an empty string for Stars
currency must be 'XTR'
amount is in whole Stars (no decimals)
The payload is your custom data — you'll get it back after payment

Step 2: Handle Pre-Checkout Query

Before Telegram charges the user, it sends a pre-checkout query. You must answer within 10 seconds:

// bot.js
bot.on('pre_checkout_query', async (ctx) => {
  try {
    const payload = JSON.parse(ctx.preCheckoutQuery.invoice_payload);

    // Validate the purchase
    // - Does the user exist?
    // - Is the item still available?
    // - Is the price correct?

    await ctx.answerPreCheckoutQuery(true);
  } catch (err) {
    await ctx.answerPreCheckoutQuery(false, 
      'Something went wrong. Please try again.'
    );
  }
});

Critical: If you don't respond to pre_checkout_query within 10 seconds, the payment fails silently. Make your validation fast!

Step 3: Handle Successful Payment

After the user pays, Telegram sends a successful_payment message:

bot.on('message', async (ctx) => {
  if (!ctx.message.successful_payment) return;

  const payment = ctx.message.successful_payment;
  const payload = JSON.parse(payment.invoice_payload);
  const stars = payment.total_amount;

  // Record the transaction
  await db.query(
    \`INSERT INTO transactions 
     (user_id, type, stars_amount, telegram_payment_id) 
     VALUES ($1, $2, $3, $4)\`,
    [payload.userId, payload.type, stars, 
     payment.telegram_payment_charge_id]
  );

  // Deliver the digital good
  if (payload.type === 'premium') {
    await db.query(
      'UPDATE users SET subscription_tier = $1 WHERE telegram_id = $2',
      ['premium', payload.userId]
    );
  }

  // Notify the user
  await ctx.reply(
    \`Payment successful! You paid ${stars} Stars.\`
  );
});

Step 4: Open the Invoice from Your Mini App

In your React frontend, use the Telegram WebApp SDK:

// React component
const handlePurchase = async (itemType, amount) => {
  const response = await fetch('/api/create-invoice', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ 
      telegramId: window.Telegram.WebApp.initDataUnsafe.user.id,
      itemType,
      amount
    })
  });

  const { invoiceLink } = await response.json();

  // This opens Telegram's native payment UI
  window.Telegram.WebApp.openInvoice(invoiceLink, (status) => {
    if (status === 'paid') {
      // Refresh UI, show success
      showNotification('Payment successful!');
      window.Telegram.WebApp.HapticFeedback.notificationOccurred('success');
    }
  });
};

The Complete Payment Flow

Here's what happens when a user clicks "Buy":

Frontend calls /api/create-invoice
Backend creates an invoice link via Bot API
Frontend opens it with WebApp.openInvoice()
Telegram shows native payment UI
User confirms payment with Stars
Telegram sends pre_checkout_query → your bot answers true
Telegram sends successful_payment → you deliver the good
Frontend callback fires with status === 'paid'

The entire flow takes about 2 seconds. No redirects, no card forms, no 3D Secure.

Real-World Tips from Building WhisprMe

After processing real payments in WhisprMe, here's what I learned:

1. Always validate in pre_checkout_query. Don't just auto-approve. Check that the item exists and the price hasn't changed.

2. Use the payload wisely. Encode everything you need to fulfill the order — user ID, item type, quantity. You'll thank yourself during debugging.

3. Idempotency matters. Store telegram_payment_charge_id and check for duplicates. Telegram can sometimes send duplicate successful_payment events.

4. Stars pricing psychology. We found that 15 Stars works better than 10 or 20 for premium features. It feels "affordable but not cheap."

5. Haptic feedback. That HapticFeedback.notificationOccurred('success') after payment makes a huge difference in user experience.

Setting Up in Production

Make sure your webhook is properly configured for payment events:

// index.js
const express = require('express');
const app = express();

// Important: set webhook with allowed_updates
await bot.telegram.setWebhook(
  'https://yourdomain.com/bot-webhook',
  { allowed_updates: ['message', 'pre_checkout_query'] }
);

app.use('/bot-webhook', 
  express.json(), 
  (req, res) => bot.handleUpdate(req.body, res)
);

Conclusion

Telegram Stars make payments ridiculously simple compared to traditional payment gateways. No KYC for users, no payment forms, instant delivery — it's the kind of payment UX we've always wanted.

If you're building a Telegram Mini App, Stars should be your default monetization strategy. The conversion rates are significantly higher than traditional payment methods because users don't leave the app.

Try it yourself: @WhisprMe_bot — send anonymous messages, unlock premium features with Stars.

What payment challenges have you faced with Telegram Mini Apps? Drop a comment below!

I Built an Anonymous Feedback App for Telegram — Here's What I Learned

Haskell Thurber — Mon, 02 Mar 2026 09:17:17 +0000

I Built an Anonymous Feedback App for Telegram — Here's What I Learned

Remember Sarahah? The app that went viral in 2017, hitting #1 in 30+ countries with zero marketing budget? The concept was dead simple: share a link, get anonymous messages from friends.

I built something similar — but inside Telegram as a Mini App, with native monetization through Telegram Stars. Here's the full story.

🎯 The Idea

WhisprMe (@WhisprMe_bot) is an anonymous feedback service built as a Telegram Mini App. You get a unique link, share it with friends, and they write anonymous messages to you.

The hook? You can see a 3-word preview of each message, but the full text is blurred. Want to read it? Pay 15 Stars (~$0.26) or invite a friend.

The tagline: "Find out what people really think about you"

🏗️ Tech Stack

Layer	Technology
Backend	Node.js + Express
Database	PostgreSQL (raw SQL, no ORM)
Frontend	React (Create React App)
Bot	Telegraf.js
Process Manager	PM2 (cluster mode)
Web Server	nginx
Payments	Telegram Stars API

🔥 The Viral Mechanics

The killer feature is that sharing is mandatory, not optional. Want feedback? You HAVE to share your link. This is the same mechanic that made Sarahah explode.

Card Templates

Users can choose from 10 different sharing card styles:

🤔 "What do you think about me?"
💬 "Tell me anonymously what you're afraid to say in person"
👀 "Would you date me? Be honest"
🔥 "Rate me 1-10 and tell me why"
❤️ "Give me an anonymous compliment"

Each card generates a unique deep link (t.me/WhisprMe_bot?start=msg_username_hash).

The Blurred Message Hook

When you receive a message, you see the first 3 words + blurred text. It's psychologically impossible to ignore — you NEED to know what someone thinks about you.

Friend Portrait

After 5+ messages, you get an AI-generated "Anonymous Portrait" — a beautiful infographic showing how people see you: top words used, emotional profile, sentiment analysis. This is screenshot-worthy content that users share organically.

💰 Monetization with Telegram Stars

This is where it gets interesting. Telegram Stars are the native payment system for Mini Apps. No Stripe, no App Store commission, direct micropayments.

Action	Price
Read a hidden message	15 Stars
Reveal sender's city	25 Stars
Reveal sender's contact	49 Stars
Plus subscription (monthly)	99 Stars
Pro subscription (monthly)	299 Stars
Virtual gifts (Heart, Fire, Crown)	30-200 Stars

The Referral System

Invite 1 friend → +5 free messages
Invite 3 friends → unlimited for 7 days
Friend signs up → +50 Stars bonus

Plus, Telegram's native Affiliate Program gives referrers 15% of all payments from referred users. Bloggers get 25%.

🛠️ Technical Deep Dive

Authentication

Telegram Mini Apps pass initData with a cryptographic signature. I validate it server-side:

function validateTelegramWebAppData(initData) {
  const secret = crypto.createHmac('sha256', 'WebAppData')
    .update(BOT_TOKEN).digest();
  const checkString = Object.entries(parsed)
    .sort(([a], [b]) => a.localeCompare(b))
    .map(([k, v]) => `${k}=${v}`).join('\n');
  const hash = crypto.createHmac('sha256', secret)
    .update(checkString).digest('hex');
  return hash === parsed.hash;
}

Stars Payment Flow

Frontend calls POST /api/payments/create-invoice
Backend creates invoice via Telegram Bot API
Telegram shows native payment dialog
pre_checkout_query → validate → successful_payment
Backend unlocks content

Anti-Abuse

Rate limit: max 3 messages/day from one sender to one recipient
Global IP-based hourly rate limit
basicToxicityCheck() filters toxic content before saving
Blurred preview shows only first 3 words

Database Design

Pure PostgreSQL with raw SQL queries. No ORM overhead. The schema is straightforward:

users — profiles with unique_slug for URLs
messages — with preview (first 3 words), is_unlocked
transactions — Stars payment history
referrals, achievements, mood_words

Cluster Mode

PM2 cluster mode with multiple workers. Since PostgreSQL handles concurrency natively, no shared state issues.

📊 Features

📨 Inbox — Receive anonymous messages with blur effect
📤 Share — 10 card template styles for sharing
🎭 Portrait — AI sentiment analysis from messages
🏆 Leaderboard — Weekly/monthly popularity ranking
👤 Profile — Subscription management, referral stats
🎁 Gifts — Send anonymous virtual gifts with messages
😀 Reactions — Anonymous emoji reactions

🚀 Key Learnings

1. The viral loop IS the product

Don't add a "Share" button as an afterthought. Make sharing the core mechanic. If users can't use your product without sharing, congratulations — you've built a viral loop.

2. Telegram Stars remove friction

Traditional payments require credit cards, KYC, App Store approval. Stars are one tap. Users already have them. Conversion is dramatically higher.

3. Blurred content = irresistible curiosity

The preview-then-paywall approach works incredibly well for anonymous messages. People can't resist knowing what someone thinks about them.

4. Mini Apps are an untapped market

Telegram has 900M+ MAU. The Mini App ecosystem is still early. There's much less competition than the App Store or Play Store.

5. Referral programs that pay Stars actually work

When users earn actual currency (Stars → TON → real money), they're genuinely motivated to invite friends.

🔗 Try It

Bot: @WhisprMe_bot
Web: whisprme.app

Share your link, get anonymous messages, discover what people really think about you.

Built by a solo developer in ~3 weeks. Happy to answer questions in the comments!

DEV Community: Haskell Thurber

How I Built a Referral System That Pays Users in Telegram Stars (And Actually Drives Growth)

The Problem With Traditional Referrals

How the Referral Revenue Works

The Database Schema

Payment Flow with Telegram Stars

What I Learned About Viral Coefficients

The Leaderboard Effect

Key Takeaways

The Tech Stack

I Replaced Stripe With Telegram Stars — Here's What Happened to My Conversion Rate

TL;DR

The Problem With Traditional Micropayments

Enter Telegram Stars

1. Zero Checkout Friction

2. Micropayments Actually Work

3. The Integration Is Embarrassingly Simple

4. Built-in Refunds

What I Built: WhisprMe

The Stack

Key Lessons

Auth is free

Distribution is built in

Monetization ceiling exists

Telegram takes 30%

Who Should Use Stars?

Try It

5 Things That Surprised Me Building a Telegram Mini App (Real Production Lessons)

1. Telegram Stars Payments Are Absurdly Simple

2. Haptic Feedback Changes Everything

3. initData Is Your Auth Layer (But Validate It Server-Side!)

4. The Cold Start Problem Is Real

5. A $5/month VPS Handles More Than You Think

The Stack

Try It

How to Accept Payments in a Telegram Mini App Using Stars (Step-by-Step Guide)

What Are Telegram Stars?

Prerequisites

Step 1: Create the Invoice Endpoint

Step 2: Handle Pre-Checkout Query

Step 3: Handle Successful Payment

Step 4: Open the Invoice from Your Mini App

The Complete Payment Flow

Real-World Tips from Building WhisprMe

Setting Up in Production

Conclusion

I Built an Anonymous Feedback App for Telegram — Here's What I Learned

I Built an Anonymous Feedback App for Telegram — Here's What I Learned

🎯 The Idea

🏗️ Tech Stack

🔥 The Viral Mechanics

Card Templates

The Blurred Message Hook

Friend Portrait

💰 Monetization with Telegram Stars

The Referral System

🛠️ Technical Deep Dive

Authentication

Stars Payment Flow

Anti-Abuse

Database Design

Cluster Mode

📊 Features

🚀 Key Learnings

1. The viral loop IS the product

2. Telegram Stars remove friction

3. Blurred content = irresistible curiosity

4. Mini Apps are an untapped market

5. Referral programs that pay Stars actually work

🔗 Try It

3. `initData` Is Your Auth Layer (But Validate It Server-Side!)