How I Built a Telegram Channel Management Platform

deniskoblya — Sun, 15 Mar 2026 19:10:34 +0000

Last year, I got pretty fed up. I was juggling five different tools just to manage my Telegram channels. Imagine: scheduling posts in one app, checking analytics in another, and generating AI content in a third. It was a mess. So, I decided to do something about it. I built TGADM.IN – one single dashboard that handles absolutely everything.

Here’s what I learned along the way.

the problem

If you run a Telegram channel (or several), you know the struggle is real.

Scheduling posts often means dealing with clunky bots that have truly terrible user experiences.
Want analytics? Get ready to scrape data yourself or shell out cash for expensive third-party tools.
Creating content? That's a manual, repetitive grind.
And managing multiple channels from one central place? Forget about it. It just wasn't happening.

I wanted something like Buffer or Hootsuite, but specifically designed for Telegram. Nothing decent existed for the Ukrainian market, so I took matters into my own hands and built it.

tech stack

We kept the technology pretty focused:

The frontend uses React, TypeScript, and Vite. A fast, modern combo.
For the UI, we crafted custom components with Less, opting out of any large component libraries.
Supabase handles all the backend magic: authentication, the database, Edge Functions, and storage. It's truly a powerhouse.
For AI, we tapped into Gemini 2.5 Flash for content generation, which proved surprisingly good and affordable, and Perplexity for research.
The Telegram Bot API connects via webhooks.
Hosting? We went with Netlify for the frontend and Supabase for the backend.

No Next.js, no server-side rendering. This is a pure Single Page Application, with Supabase taking care of all server-side operations through its Edge Functions. My goal was zero server maintenance, and we achieved it.

architecture decisions that worked

1. supabase edge functions as api layer

This was a game-changer. Instead of building a separate backend from scratch, every single server-side operation runs as a Supabase Edge Function. Whether it's scheduling posts, processing webhooks, or syncing RSS feeds, these are all Deno-based functions deployed with one simple command. It's incredibly efficient.

// Edge Function: scheduled-posts-cron
// Runs every minute via pg_cron
Deno.serve(async (req) => {
  const now = new Date();
  const { data: posts } = await supabase
    .from('scheduled_posts')
    .select('*')
    .lte('scheduled_at', now.toISOString())
    .eq('status', 'pending');

  for (const post of posts) {
    await publishToTelegram(post);
  }
});

2. bot token stays on server

Users connect their channels by adding our bot as an administrator. Crucially, the bot token never leaves Supabase. All Telegram API calls happen securely within the Edge Functions. This means users don't have to create their own bots or worry about sharing sensitive tokens. It's a much safer approach.

3. real-time with supabase realtime

When a post finally publishes, the dashboard updates instantly. Seriously, there's no annoying polling. Supabase channels combined with PostgreSQL NOTIFY handles all of it, giving users immediate feedback.

supabase
  .channel('posts')
  .on('postgres_changes', {
    event: 'UPDATE',
    schema: 'public',
    table: 'scheduled_posts'
  }, (payload) => {
    // Update UI immediately
  })
  .subscribe();

the ai part

The content generation feature quickly became the most popular. Users simply type in a topic, pick a tone, and get a ready-to-post text, complete with all the right formatting. It's pretty neat.

Under the hood, it's quite straightforward:

User input gets turned into a structured prompt, enriched with the channel's context.
Gemini 2.5 Flash then generates the text. It's fast, cheap, and honestly, good enough for most needs.
The output is formatted as Telegram HTML (think bold, italic, links).
Finally, the user can edit it in a visual editor before scheduling.

The AI image generation uses a similar flow, just routing to different image models. It's nothing overly complex, but it saves people a solid 20-30 minutes per post. That's a huge win.

ad exchange: connecting channel owners

Here's a feature I absolutely didn't plan for, but users kept asking. They wanted an advertising marketplace. Channel owners wanted to sell ads, and advertisers wanted to buy them. So, we built a simple exchange. It now connects over 2,900 Ukrainian Telegram channels.

Each channel page clearly displays subscriber counts, engagement rates (ER), available ad formats with prices, and a detailed research description powered by Perplexity AI.

A quick technical aside: the channel data actually lives in a separate MySQL database, a remnant from an older parser project. Our Vite dev server proxies API calls to MySQL via a server plugin. In production, it's just a static JSON build.

seo for a saas blog

We recently launched a blog specifically targeting Ukrainian Telegram marketing keywords. Here are a few things that really worked for us:

We chose WordPress with a custom theme. It's simply faster to publish content for our non-technical team than trying to wrestle with a static site generator.
Every post automatically gets FAQ Schema, HowTo Schema, and BlogPosting markup through the_content filter. This programmatic SEO meta is a lifesaver.
We support three languages: Ukrainian (our primary focus), Russian, and English, all managed via Polylang. This means one article translates into three indexed URLs.
Our AI-generated Pixar-style covers are unique, eye-catching, and help maintain a consistent brand identity. We create them using Gemini image generation.

We managed to go from zero to 36 published posts (that's 12 articles multiplied by 3 languages) with full Schema.org markup in just four weeks. I'm pretty proud of that.

numbers after 3 months

170+ registered users in our first month after launch.
12 blog articles (36 with all the translations).
More than 2,900 channels listed in our ad exchange.
We even launched on Product Hunt just this week!

what i'd do differently

Looking back, a few things come to mind:

I'd start with the blog much earlier. SEO is a marathon, not a sprint. We launched the product first and the blog two months later. Those efforts should have been simultaneous.
We should have used Edge Functions from day one. We initially started with client-side Telegram API calls, which was a bad idea because it exposed tokens. Migrating everything to Edge Functions ended up taking a whole week.
I would skip the custom visual editor. Building a rich text editor specifically for Telegram formatting became a massive time sink. We absolutely should have used TipTap or ProseMirror right from the beginning. Live and learn!

try it

If you manage Telegram channels, seriously, give TGADM.IN a try. We have a free plan available, and you don't even need a credit card to sign up.

We also share a lot about Telegram marketing on our blog (it's mostly in Ukrainian, but English versions are available too).

Building something for Telegram? I'm happy to answer any questions in the comments below!

DEV Community: deniskoblya