DEV Community: Alex

Add a CRM, Live Chat and Analytics to a Telegram Bot You Already Wrote

Alex — Sun, 30 Aug 2026 12:44:40 +0000

Originally published on the FlowCastle blog.

Writing bot code is fun. Then the bot gets real users, and the questions change: who is actually talking to it? Which conversations end in a sale? Can support take over a chat when the bot gets stuck? Can we message everyone who dropped off before paying?

None of that is bot logic, and none of it belongs in your handlers. It's the layer around a bot — and every tool that offers it wants your bot token and wants to host the bot for you, which means throwing away the code you wrote.

This article shows the third option: keep your grammY, Telegraf, aiogram or python-telegram-bot bot exactly where it is, and add that layer with an open-source middleware. By the end you'll have a contact record for every user, goals showing up in funnels, a /human command that hands the chat to a person, and — optionally — flows your teammates build visually that run through your bot process. The full example bot is linked at the end; it exists for all four frameworks.

What you'll add, and what stays yours

Stays in your code	Added by FlowCastle
Your framework, handlers, database, hosting	Contact CRM with traits, tags and history
Your Telegram bot token — FlowCastle never receives it	Live Chat: a person replies in the same Telegram chat, through your bot
Polling or webhooks, exactly as today	Broadcasts and drip sequences, sent through your bot
Anything you'd rather keep in source control	Goals, funnels, conversion analytics
	A read-only map of the conversations your code already handles

The SDK is MIT-licensed, lives on GitHub, has zero runtime dependencies on Node and uses only the standard library on Python. The hosted part is the FlowCastle dashboard, which has a free plan with no card required.

Step 1: Create the SDK key

In the FlowCastle dashboard, open your application and click Add bot. Pick Code SDK.

Notice what it doesn't ask for: a Telegram token. Give the connection a name and create it. You get an fc_sdk_… key, and the install instructions for your library.

Switch the picker and the instructions follow — here's the same screen for aiogram:

Put the key next to your existing BOT_TOKEN as FLOWCASTLE_API_KEY. Treat it like a secret — it's how your bot authenticates with FlowCastle.

Step 2: Add the middleware (three lines)

grammY:

import { Bot, Context } from 'grammy';
import { flowcastle, FlowCastleFlavor } from '@flowcastle/grammy';

type BotContext = FlowCastleFlavor<Context>;
const bot = new Bot<BotContext>(process.env.BOT_TOKEN!);

const fc = flowcastle<BotContext>({
  apiKey: process.env.FLOWCASTLE_API_KEY!,
  privacy: {},                 // commands and button taps are shared, free text is not
  runtime: { enabled: true },  // lets visually built flows run through this bot (Step 6)
});
bot.use(fc);                   // before your handlers, so it sees every update

// ...your existing handlers, unchanged...

await fc.ready();
bot.start();

aiogram 3:

from flowcastle import FlowCastleCore, FlowCastleOptions
from flowcastle.adapters.aiogram import AiogramAdapter

core = FlowCastleCore(FlowCastleOptions(api_key=os.environ["FLOWCASTLE_API_KEY"], privacy={}, runtime_enabled=True))
adapter = AiogramAdapter(core)

await adapter.ready()
adapter.install(dp)          # outer middleware; handlers get `flowcastle` in their data
await dp.start_polling(bot)

Telegraf and python-telegram-bot are the same shape; the README has all four.

Two things about that snippet worth knowing before you run it.

privacy: {} is a choice you're making explicitly. With it, the SDK sends commands and callback identifiers but strips free text before anything leaves your process. Contacts get a Telegram user id and nothing else unless you allow specific profile fields (contactFields: ['username', 'languageCode']). If your FlowCastle flows need to read what users type — say, for AI answers — set messageContent: 'full' and, if you want, a transformText callback that redacts emails or card numbers locally. A callback that throws or times out drops the field rather than sending it unredacted.

Your handlers never wait on FlowCastle. After local filtering, the event goes into a bounded in-memory queue (500 events, oldest dropped under pressure) and your handler runs immediately. Delivery is batched every three seconds with one background retry. If FlowCastle is unreachable, your bot loses some analytics, not its users.

Run the bot and send it /start. Back in the dashboard, the bot's SDK tab flips to Connected, and the person who sent /start is now a contact.

That's the whole integration. Everything below is about using it.

Step 3: Turn your handlers into a CRM

The middleware puts a small API on the context — ctx.flowcastle in Node, the flowcastle argument (aiogram) or context.flowcastle (python-telegram-bot) in Python. Three calls do most of the work.

identify sets traits on the contact. In the example bot, /start records the display name, and a three-question /qualify command — plain inline keyboards, all in code — saves the answers as traits when it completes:

const lead = { leadNeed: 'website_lead_bot', leadBudget: '500_2k', leadTimeline: 'this_month' };
ctx.flowcastle.identify(lead);

goal records something that matters to the business. The example fires one from a demo button and one when qualification completes:

ctx.flowcastle.goal('lead_qualified', lead);

Goal keys are yours to name — subscription_started, order_paid, whatever your funnel is made of. Add a numeric value prop and revenue shows up in analytics.

Here's what the contact looks like after one run through /qualify — the traits your code sent, next to the tags and status FlowCastle keeps:

And on the Goals tab, the two goals the handlers fired:

Nothing in the bot changed except two lines inside a handler that already existed. Your database is still the source of truth for whatever it was the source of truth for; this is the view your growth and support people were asking you to build.

Step 4: Hand a chat to a human

requestLiveAgent is the third call. The example bot wires it to /human:

bot.command('human', async (ctx) => {
  ctx.flowcastle.requestLiveAgent({ note: 'User asked to talk to a human.' });
  await ctx.reply('Connecting you with a teammate — they will reply right here. 💬');
});

bot.on('message:text', async (ctx) => {
  if (ctx.flowcastle.isLiveAgentActive) return;   // a person has this chat; don't echo over them
  await ctx.reply(`Echo: ${ctx.message.text}`);
});

The conversation opens in FlowCastle's Live Chat. When a teammate replies there, the reply is delivered through your bot process — the SDK pulls it as a job and sends it with your bot's own connection. FlowCastle can only ask your process to run a short allowlist of Bot API methods (sendMessage, sendPhoto, answerCallbackQuery and the like); token, webhook and polling methods are refused no matter what the server sends.

The whole handoff is visible on the contact's activity trail — the user's messages, the live-agent request, the bot's acknowledgement, and the agent's reply delivered back through your bot:

isLiveAgentActive is a local, optimistic hint — a 30-minute window opened by the request and refreshed by delivered agent replies — so your auto-replies step back while a person is engaged. (It's Node-only for now; the Python SDK doesn't expose it yet.)

Step 5: See the bot your code already is

This one surprises people. From the sanitized traffic — which commands lead to which replies, which buttons get pressed — FlowCastle reconstructs the conversations your code handles and lists them on the Automation canvas next to your other flows, one map per entry point, each labeled Observed. For the example bot that's four: /start, /qualify, /human and the plain-message fallback. Open /qualify, hit Auto-arrange, and the journey you wrote in code is laid out as a flow: three questions, nine option buttons, the closing message.

These maps aren't a source of truth — your repository is — and you can delete one at any time and let it rebuild from fresh activity. What it's for: the teammate who can't read your handlers can now see what the bot does, and every step on the map is connected to the analytics below. "Where do people drop off in /qualify?" stops being a question only you can answer.

Step 6 (optional): Let teammates build alongside your code

Because runtime: { enabled: true } is on, the same Automation workspace can hold flows built in the visual editor — onboarding, a follow-up sequence, a support FAQ — and they execute through your bot process. The rules are simple:

An update that matches a deployed FlowCastle trigger (say, a /faq command your code doesn't handle) is answered by the flow and doesn't reach your handlers, so nobody replies twice.
Everything unmatched falls through to your code exactly as before.
Your code can start a flow explicitly. The example does this when /qualify completes, passing the answers as inputs:

await ctx.flowcastle.runFlow('lead-follow-up', { inputs: lead });

Only flows you've marked callable from SDK in the dashboard can be started this way. A marketer can then change the follow-up copy, add a step, or A/B the timing — and none of it is a deploy of your bot.

What you get on the dashboard side

Goals, contacts, broadcasts and the observed map all feed one analytics view: subscriber growth, which broadcasts moved which goals, revenue if you send a value.

Broadcasts and drip sequences are built in the dashboard and sent through your bot — segmented by the traits and goals your handlers set, so "everyone with leadBudget = 2k_plus who never reached order_paid" is a filter, not a script.

Where to go next

The example bot, in all four frameworks: examples/ in the SDK repo — /start → identify, a goal button, code-owned /qualify, /human handoff, optional follow-up flow. Copy the folder for your framework and replace the handlers with yours.
Using an AI coding agent? Point it at the agent setup guide — one file with the install order per framework, every option, a verification checklist and troubleshooting. Claude Code, Cursor and Codex wire it in without you reading the docs.
The privacy and performance contract in full: the README.
Questions: the FlowCastle bot developers community on Telegram.

Start free at dashboard.flowcastle.ai — no card — and the SDK on GitHub is MIT.

Build an AI Support Bot for Telegram

Alex — Thu, 30 Jul 2026 20:31:46 +0000

Originally published on the FlowCastle blog.

An AI support bot fails in two common ways. The first version is only a button tree with an AI label on top. It can route a few obvious questions, but it breaks as soon as a customer writes in their own words. The second version is worse: a raw language model connected to your inbox. It sounds confident, invents answers, and keeps talking when it should bring in a human.

The practical version sits between those two extremes. It answers routine questions from your own knowledge base, recognizes the requests you already know how to handle, and passes the conversation to a person when confidence is low or the customer asks for help.

In this walkthrough, you will build that version for Telegram in FlowCastle. The ready-made AI FAQ + Human Handoff template is linked at the end, so you can start from the same structure instead of building from a blank canvas.

What you will build

The finished support flow has five parts:

a short welcome message
an AI agent connected to your knowledge base
three explicit intents for common requests
a human handoff path for exceptions
a weekly improvement loop based on real conversations

The example is for a small ecommerce support bot. It can answer questions about delivery, returns, warranty, and order status. It also knows when to move the customer to a human operator.

Step 1: Start with a clear support promise

Begin with a welcome message before the AI agent. Do not open with a long explanation of what AI can do. Tell the customer what happens next.

Use this copy:

Hi. I can answer questions about orders, delivery, returns, and warranty. If I cannot help, I will connect you with a person.

That last sentence matters. It reduces the risk of a customer feeling trapped in automation. The bot is allowed to help, but it is not pretending to replace support.

Connect this welcome message to the AI agent step.

Step 2: Attach the knowledge base

Create a knowledge base for the agent and upload the documents the bot is allowed to use. For this example, start with four short files:

shipping-policy.md
returns-and-refunds.md
warranty.md
order-status-faq.md

Keep the files boring and specific. A good support knowledge base says:

how long delivery usually takes
what information is needed to check an order
which items can be returned
how many days the customer has to request a refund
when a person should review the case

Avoid dumping a whole website into the bot on day one. If the source material is unclear, the AI answer will be unclear too. The knowledge base should contain the exact policies you are comfortable sending to customers.

After uploading the files, attach the knowledge base to the AI agent. The agent should answer from those documents rather than from general model knowledge.

Step 3: Add explicit intents for known requests

Use intents for requests that should always follow a predictable path. In this example, add these intents:

Track order
Return or refund
Talk to a human

For Track order, route the customer to a message that asks for the order number:

Please send your order number. It usually starts with FC-.

If you already store order data in an external system, this is where you can later add an integration step. For the first version, it is enough to collect the order number and hand it to support.

For Return or refund, route the customer to a message that explains the policy and asks for the order number:

You can request a return within 14 days after delivery. Send your order number and a short reason for the return, and we will check the case.

For Talk to a human, route directly to the human handoff path.

Everything outside those known intents can still be answered by the knowledge base. That is why the useful mode is not only intents and not only chat. Known requests get deterministic paths; long-tail questions get AI answers grounded in your documents.

Step 4: Define when the bot must hand off

The handoff rule is the part that makes the bot safe to use in production. Add a human handoff path and use it in three cases:

the customer asks for a person
the request involves a refund, complaint, or edge case
the AI answer is not confident enough

Use this message before the handoff:

I will connect you with a teammate. They will see this conversation, so you do not need to repeat the details.

Then route the conversation to Live Chat. The operator should receive the conversation history and the context collected by the bot. The customer should not have to start again.

This is also where the support team can keep control of sensitive topics. The bot can explain standard policy, but a person should handle exceptions, angry customers, payment issues, and anything that affects trust.

Step 5: Test with real customer wording

Before publishing, test the bot with messy messages, not only perfect examples. Use phrases like:

"where is my package"
"i want my money back"
"can someone help me"
"do you ship to Spain"
"my item arrived broken"

Check what happens in each case. A good result is not always an AI answer. Sometimes the correct result is a handoff.

For every test, verify three things:

The bot answers from your policy, not from invented assumptions.
Known requests follow the intent path you configured.
Sensitive or unclear requests reach a person.

If the bot answers too broadly, tighten the source documents. If it misses a repeated request, add a new intent. If it refuses too often, improve the knowledge base with a clearer answer.

Step 6: Improve it after launch

The first version of a support bot is never the final version. After a week, review the conversations. Look for repeated questions, confusing answers, and places where customers asked for a person earlier than expected.

In FlowCastle, use conversation analysis and suggestions to turn those patterns into concrete changes. A useful suggestion might be:

add a new "Change delivery address" intent
add a missing paragraph to shipping-policy.md
rewrite the return answer so it names the 14-day window earlier
route damaged-item reports directly to a human

Approve the changes that match your support policy. Reject anything that would make the bot overconfident. The goal is not to automate every conversation. The goal is to answer the easy questions instantly and send the hard ones to the right person with context.

Use the same flow on your website

Once the Telegram bot works, you can run the same support flow in the website chat widget. That is useful because customers do not all start in the same channel. Some open Telegram, some land on your pricing page, and some come from a help article.

Keep one support flow and adapt the entry point per channel. The policies, intents, and handoff logic should stay consistent.

Where to go next

Clone the AI FAQ + Human Handoff template, attach your own knowledge base, and replace the example intents with the requests your support team sees every week. Start with a small scope: order status, returns, delivery questions, and human handoff.

After the first real conversations, review the transcripts and improve the knowledge base. A good AI support bot is not a one-time launch. It is a support process that gets clearer every week.

New tutorials and product updates are announced in our Telegram channel — fittingly, that's also where FlowCastle's own community lives.

Telegram Marketing You Can Actually Measure

Alex — Thu, 30 Jul 2026 20:29:48 +0000

Originally published on the FlowCastle blog.

Most Telegram marketing tools answer one question well: how many messages went out. Sent, delivered, sometimes clicked — and that is where the reporting ends. Whether any of those sends produced a signup, a payment, or a booked call is left to guesswork.

That gap is why we built FlowCastle's marketing stack around goals instead of counters. This article walks through the four pieces — broadcasts, drip sequences, conversion goals, and AI insights — and shows how they connect, with real screenshots from the product.

Broadcasts that report conversions, not just deliveries

FlowCastle broadcasts do the expected things: one-off and scheduled sends, recurring campaigns, audience filters on any contact variable or past behavior, and A/B splits when you want to test copy.

The difference shows up after the send. Every broadcast is scored against the goals you define, so next to "delivered" you see the number that matters: how many recipients went on to convert, and which goal they hit. Instead of comparing two campaigns by open-rate folklore, you compare them by attributed conversions.

Drip sequences with per-step conversion

Sequences are timed drips: a contact subscribes (after a lead form, a purchase, a /start — any trigger you choose), then receives a series of messages on the schedule you set. Nurture flows, onboarding, winbacks, and re-engagement all run on the same machinery.

Each step reports its own conversion. A contact counts as converted when they hit the sequence's goal after entering it — so you see exactly which step does the work and which step readers ignore. When step 3 converts and step 4 doesn't, you shorten the sequence instead of guessing.

Goals: define what a conversion is

A goal is any event you care about: a button click, a completed payment, a submitted form — or something that happens outside Telegram entirely. FlowCastle's website tracking connects a visitor on your site to the same person in the bot, so "signed up on the website" can be a goal that a Telegram broadcast gets credit for. Tracked links carry the attribution: when a contact clicks a button in a broadcast and converts on your site, the chain from send to conversion is recorded, UTM source included.

Goals also show up on contacts themselves — you can filter your audience by who converted and who did not, and use that filter in the next broadcast.

AI insights: the analysis you would do if you had time

Counting is necessary; interpreting is where teams stall. FlowCastle's analytics include AI-generated insight cards that read your funnel data and surface the findings a growth analyst would: which traffic sources bring contacts that actually convert, which sequence steps carry the conversions, where a funnel leaks, what changed since last period.

The point is not that AI writes a report. The point is that the underlying data model — every send tied to goals and sources — makes the analysis possible at all. Tools that only count sends have nothing to analyze.

How this compares to mailing-first tools

Dedicated mailing platforms are genuinely good at volume, and some bundle a sales CRM — we compare honestly in FlowCastle vs BotHelp and the broader Telegram bot builder roundup. The trade-off to understand is measurement: mailing-focused tools report on mailings, while FlowCastle reports on outcomes. If your marketing decisions come down to "did this campaign make money," the goal layer is the feature to look for.

FAQ

Can I track conversions that happen on my website, not in Telegram?
Yes. The website tracking script identifies the visitor as the same person who talks to your bot, so on-site events (signup, purchase) become goals attributable to Telegram broadcasts and sequences.

Do sequences and broadcasts share the same goals?
Yes — goals are defined once and every broadcast, sequence, and flow reports against them, which is what makes cross-channel comparison possible.

Does FlowCastle support A/B testing?
Yes — random-split branches let you test message variants, and goal attribution tells you which variant converted rather than which one got more clicks.

Try it on your own funnel

The fastest way to see the loop is to run it: define one goal, send one broadcast, and watch the attribution land. Start from a ready-made template or explore the analytics feature page for a deeper look at the reporting.

New tutorials and product updates are announced in our Telegram channel — fittingly, that's also where FlowCastle's own community lives.

The 7 Best Telegram Bot Builders in 2026

Alex — Thu, 30 Jul 2026 20:28:39 +0000

Originally published on the FlowCastle blog.

Full disclosure up front: we build FlowCastle, one of the tools on this list. That is exactly why this comparison stays honest — for several of the platforms below there are real situations where they are the better choice, and we say so. Every claim here is based on the platforms' current public feature sets and pricing as of July 2026.

The short version: if Telegram is your main channel and your bot needs real logic, use FlowCastle. If your marketing lives on Instagram, use Manychat. If you want one suite for email, SMS, and chat, use SendPulse. If you have an engineering team that wants open-source control, use Botpress. The rest of this article is the long version — who each tool is actually for.

At a glance

Tool	Best for	Custom logic	Pricing model
FlowCastle	Telegram-first bots with real logic	TypeScript + HTTP in the flow	Plan-based
Manychat	Instagram/Meta DM marketing	External backend needed	Per active contact
SendPulse	All-in-one marketing (email + SMS + chat)	API calls only	Free tier, scales with subscribers
Chatfuel	Meta-ecosystem commerce	Templates + limited code	Subscription
Botpress	Engineering teams, AI agents	Full code, you own it	Free tier + cloud/self-hosted
BotHelp	Funnels and broadcasts (CIS market)	Integration-based	Subscription
BotMother	One bot on many channels (incl. Viber/VK)	Plugins, limited	Subscription

1. FlowCastle — Telegram-first, with a real code escape hatch

FlowCastle is a visual flow builder designed around Telegram rather than porting a Meta-first product to it. That shows up in the details: native Telegram Payments with catalog and orders, inline keyboards, broadcasts that double as a scheduler, and deep-link entry points into any flow.

The differentiator is the ceiling. Conditions, variables, and HTTP requests are visual; when no-code runs out, you write TypeScript actions inside the flow instead of standing up an external backend — and if you are not a developer, the built-in AI assistant writes the code from a plain-language description. The same AI can draft a whole flow from a prompt. FlowCastle also ships an MCP server, so AI agents like Claude and Cursor can build and edit your bots programmatically — as of mid-2026, no other tool on this list offers that.

Marketing is a first-class citizen too, and a measurable one: broadcasts and drip sequences are tied to goals, so you see conversion attribution per broadcast, sequence step, and traffic source, with AI insights that analyze UTM sources and sequence performance rather than just counting sends.

Where it is not the right pick: FlowCastle is Telegram-first with web chat live and WhatsApp/Instagram still on the roadmap. If your audience is on Instagram or Viber today, look at Manychat or BotMother instead.

2. Manychat — the Instagram marketing standard

Manychat is the biggest name in social-DM automation, and for Instagram funnels — comment-to-DM, story-reply triggers, ad integrations — it is best-in-class. Telegram is supported, but as one of seven channels rather than the product's center.

Two things to know before committing: complex data work (parsing API responses, transformations) requires building your own external backend, and pricing is per active contact — a growing audience directly grows the bill, with AI features as a separate paid add-on.

Pick it when your marketing lives on Instagram and Telegram is a side channel.

3. SendPulse — the all-in-one marketing suite

SendPulse is not primarily a bot builder — it is a marketing platform where chatbots sit alongside email, SMS, and web push with a shared contact base and CRM. Its Telegram flows are solid for marketing funnels, and the free tier is genuinely generous for small lists.

The trade-off is depth: custom logic is limited to API calls, and the whole product is oriented toward campaigns rather than application-like bots.

Pick it when you want one tool for email + SMS + chat, and your bots are funnels rather than products.

4. Chatfuel — Meta-ecosystem commerce

Chatfuel is a mature builder focused on Instagram, Messenger, and WhatsApp commerce — comment-to-DM, abandoned-cart flows, Shopify integrations. It is a safe, established choice inside the Meta ecosystem.

For Telegram specifically it is a weaker fit: the channel is not the focus, and logic beyond templates is limited.

Pick it when you run e-commerce DM automation on Meta surfaces.

5. Botpress — for engineering teams

Botpress is a developer-first, open-source platform for building AI agents, with cloud and self-hosted options. If you have engineers who want to own the architecture, choose LLMs freely, and self-host for compliance, it offers control no managed SaaS matches.

That control is also the cost: without dedicated developers you will hit a wall, and self-hosting means you run the servers, scaling, and security patches.

Pick it when you have an engineering team and the bot is a deep, custom AI agent.

6. BotHelp — mass mailings and a sales CRM for the CIS market

BotHelp is built around mass mailings across Telegram and WhatsApp plus a built-in mini-CRM, and it is especially strong in the Russian-speaking market's info-business stack.

Two limits to know: flow logic beyond funnels and integrations is not what it is for, and its analytics are mailing-focused counters — if you need to know which broadcast or sequence step actually converted, that measurement layer is where FlowCastle goes further.

Pick it when you need very-large-scale mailings with a built-in sales pipeline CRM.

7. BotMother — one project, many channels

BotMother takes a screen-based approach: you link "screens" and deploy the same project to Telegram, WhatsApp, Viber, VK, and more. For menu-and-form bots that must exist on many channels at once — including channels most builders skip, like Viber and VK — it covers unusual surface area.

Logic-heavy bots are the wrong fit: the screen model plateaus where flow-graph builders keep going.

Pick it when you need the same simple bot on many channels, including Viber or VK.

What about writing code yourself?

For completeness: if you are a developer building something truly custom, frameworks like grammY or aiogram plus the raw Bot API remain the maximum-control option. You trade every convenience above — visual editing, hosting, analytics, broadcasts — for total freedom. Most teams that start here eventually rebuild the undifferentiated parts (payments, broadcasts, contact management) that platforms give you out of the box.

FAQ

What is the best free Telegram bot builder?
SendPulse has the most generous free tier for marketing-style bots. Botpress is free if you self-host and have the engineering capacity. FlowCastle's plans include a free way to start building.

Which builder handles payments in Telegram best?
FlowCastle has native Telegram Payments with catalog and order tracking inside the flow. On most other platforms payments are external integrations.

Can I build a Telegram bot without coding at all?
Yes — every tool on this list except Botpress is usable without code. The difference is the ceiling: on most platforms complex logic eventually requires an external backend, while FlowCastle moves that ceiling by putting TypeScript and HTTP requests inside the flow, written by an AI assistant if you prefer.

Which is best for AI-powered bots?
Botpress for custom-engineered agents; FlowCastle for AI agents with knowledge bases, intent routing, and human handoff without code. Manychat's AI is a paid add-on and comparatively basic.

Where to go next

The fastest way to evaluate any builder is to ship something small in it. FlowCastle's template catalog has working bots — lead capture, AI support, digests — you can clone and have running in minutes, free.

New tutorials and product updates are announced in our Telegram channel — fittingly, that's also where FlowCastle's own community lives.

Build a Lead Bot in Telegram in 10 Minutes

Alex — Fri, 17 Jul 2026 19:41:42 +0000

Originally published on the FlowCastle blog.

A lead bot earns its keep when it does two things well: it replies instantly, and it asks the right questions before a human gets involved. If it only says "leave your phone number," it is a slower contact form. If it collects the reason for the request, the budget range, and the expected timing, your team can decide who should answer first and what to say when they do.

In this walkthrough, you will build the simple version: one Telegram flow that welcomes a new contact, asks three button-based questions, stores the answers on the contact, and sends a qualified lead summary to your team. No code, no AI support branch, no complex routing. The point is to get a useful lead bot live in about 10 minutes, then improve the questions after real conversations start coming in.

What you'll build

The finished flow has one straight path: a welcome message, three qualifying questions, a team notification, and a final confirmation for the contact. Each question stores the last clicked button directly into a contact variable, so the context follows the person later for personalization, filters, and broadcasts. If you'd rather skip the build entirely, a ready-made template covering this exact flow is linked at the end of the article.

The complete lead-qualification flow before publishing it to Telegram.

Step 1: Create the flow and the welcome message

Start with a new flow in the editor. Add a message block near the beginning of the canvas and write the first thing the bot will say when someone opens the chat. Keep this message short. It should explain who is answering and why the bot is asking questions.

Use this opener:

Hi, thanks for reaching out. I will ask 3 quick questions so our team can understand what you need and reply with the right context.

That copy does three jobs. It confirms the conversation started, tells the person the bot will not waste their time, and makes the qualification step feel normal. Avoid a long sales pitch here. The user has already opened Telegram; the next best action is to start the questions.

Place the welcome message before the first question. Connect it forward so the conversation continues automatically after the opener.

The welcome message sets expectations before the qualification questions begin.

Step 2: Ask qualifying questions with buttons

Now add the three questions, one at a time, each as a message with buttons. Buttons beat free text here: answers stay clean, consistent, and easy to reuse, while the person can still reply in one tap.

Question 1:

What do you need help with?

Buttons:

Website lead bot
Telegram automation
Support bot

Question 2:

What budget range fits this project?

Buttons:

Under $500
$500–$2k
$2k+

Question 3:

When do you want to launch?

Buttons:

This week
This month
Just researching

Connect the welcome message to Question 1, then connect each answer path to Question 2, then Question 3. For a first version, all answers can continue to the same next question. You are not trying to build a complex decision tree yet. You are collecting three fields that make the lead useful.

If your business needs different labels, change the wording, but keep the shape. Three questions is enough to qualify without making the chat feel like paperwork.

Each question is one message block: text, optional media, and its own button list.

Button answers keep lead data clean and branchable.

Step 3: Save answers to the contact

For each question message, use the button section's Store last clicked button in setting and choose a contact variable. No separate action block is needed. Use clear variable names so the values make sense outside the flow:

lead_need
lead_budget
lead_timeline

These variables are the difference between a chat and a reusable contact profile: when someone from your team opens the contact later, the key details are already attached, ready for follow-up broadcasts, filters, or personalization.

For example, a contact who chose "Support bot," "$500–$2k," and "This month" should carry those values after the conversation ends. The team should not have to scroll through the chat transcript to understand why the person reached out.

Configure this on all three question messages before the team notification fires. The important rule is simple: every selected button should end up on the contact before the handoff.

The button settings panel is where a question's answer gets pointed at a contact variable — here, lead_need.

Step 4: Notify the team with the answers attached

Once the three answers are saved, add the team notification. This is the handoff point: the lead has finished the short qualification path, and a human can now reply with enough context to be useful.

Write a compact notification message, then insert the saved answers with the variable picker. You do not need to type technical placeholders by hand: click the variable button in the message field and choose lead_need, lead_budget, and lead_timeline from the contact variables.

New qualified lead from Telegram

Need: {{lead_need}}
Budget: {{lead_budget}}
Timeline: {{lead_timeline}}

Open the Telegram chat and reply while the context is fresh.

In the editor those fields appear as variable chips, not as raw code — the {{...}} above is simply how the placeholder reads; you insert it by clicking the variable button, never by typing the braces. Send this notification to the Telegram chat or channel your team already uses for incoming leads, and keep it compact: the goal is context for the next human, not a full CRM record.

A message to your team's chat is the simplest handoff. In higher-volume setups, you might instead open a live conversation for an operator inside FlowCastle — covered in the AI support walkthrough — or push the lead into Google Sheets or a CRM, which we'll cover in an upcoming article.

After the notification, add a short confirmation back to the contact:

Thanks. I sent your answers to the team, and someone will reply here soon.

That final message closes the loop. The person knows the bot did something with their answers instead of dropping them into a silent form.

Use the variable picker to add contact fields as chips in the notification message.

Step 5: Publish and test

To run the flow in Telegram, connect your bot token from @botfather — Telegram's official bot tutorial walks through getting the token from @botfather. FlowCastle asks for the token once when you connect the bot.

After the bot is connected, publish the flow and use FlowCastle's Test panel before sending real traffic. Send /start, read the welcome message, tap one button for each question, and open the Chat tab to confirm it shows the same answers you selected.

Test the boring path first: one complete conversation from start to finish. Then test one or two different answer combinations. You are looking for three things: every question appears in the right order, every selected answer is saved to the contact, and the team notification is readable without opening the whole chat history.

If any of those fail, fix the flow before sending traffic to the bot. A lead bot is only useful when the handoff is trustworthy.

The Chat tab shows the entire test conversation end to end, including the confirmation message.

Try it on your own site next

When the Telegram version works, run the same flow in the website chat widget without rebuilding it — it's a JavaScript snippet embed, and the bubble on flowcastle.ai is itself a FlowCastle bot, so the same logic can greet visitors on your site and in Telegram.

When you outgrow this flow

The next version is not "more questions." It is a broader lead-capture template with AI answers from a knowledge base, live-agent takeover, and, coming soon, tracking the same person from your website to Telegram. If you need the support use case today, read the AI support walkthrough; keep this tutorial focused on the fast qualification flow.

Clone the Lead Qualification template, change the three questions to match your sales process, and publish it to your Telegram bot. The first version should stay simple: greet, qualify, save, notify, and let a human take over with context.

New tutorials and product updates are announced in our Telegram channel — fittingly, that's also where FlowCastle's own community lives.