How I Built an Invisible Telegram CRM

A few months ago, my girlfriend Anna started running into a bottleneck that hits almost every solo service business: managing client bookings manually over personal chat was eating up hours of her day.

The initial spark was my hypothesis and hook to get her to use a system I could engineer: I watched how much time and energy she wasted constantly jumping between apps. A single inquiry required hopping out of Telegram into Google Calendar to inspect open slots, switching to Notes to check previous client preferences, calculating prices, returning to Telegram to text options, hopping back to Calendar to block the tentative slot, and finally opening a banking app to verify deposit receipts.

Doing this across dozens of active client threads every single day creates crippling context fragmentation. When you run local campaigns, incoming messages land at all hours—while she is in the middle of a 3-hour gel manicure set, working out, or asleep. When an inquiry sits unanswered for two hours, potential clients simply move to the next studio on Instagram. If you are paying for client acquisition, slow response times burn capital directly.

My core hypothesis was simple: instead of forcing her or her clients to adopt an off-the-shelf booking SaaS with clunky external forms or hacking together an expensive, unpredictable LLM bot, we could build an invisible CRM that runs directly on top of Telegram Business. It sits silently in her normal chats, processes bookings deterministically in under a millisecond on Cloudflare Workers, and costs practically zero to operate.

Most Telegram bots force clients into an impersonal interaction model: search for a bot handle, click /start, and navigate clunky nested inline menus. For a private beauty master, that model breaks trust. Clients expect personal attention and direct conversation with the artist.

Telegram Business Connected Bots flip this paradigm entirely. The bot connects directly to Anna's personal Telegram account as a passive edge listener.

From the client's perspective, they are texting Anna directly. Behind the scenes, the Cloudflare Worker intercepts incoming webhook events to handle the background orchestration:

• If a new lead asks for pricing while Anna is busy or offline, the bot automatically sends a friendly greeting alongside the curated price list album.
• When Anna types a routine confirmation like "Booked for tomorrow at 10:00 AM, manicure with removal, 2h, 1100k VND", the bot parses the message, creates a database record, checks for calendar overlaps, and calculates her rest window.
• The client never sees slash commands, raw bot messages, or third-party booking URLs.

A frequent architectural flaw in chat automations is treating all data as a single bucket, or relying on ephemeral in-memory state that evaporates when serverless isolates recycle.

Pairing Cloudflare D1 with Cloudflare KV gives an explicit split based on data lifecycle:

Persistent History in Cloudflare D1

D1 houses data that must persist indefinitely:

• Client Records: Maps immutable Telegram user IDs to names, phone numbers, total revenue, visit frequency, and no-show flags. Even if a problematic client wipes the chat history for both participants, their record in D1 remains intact. If a serial no-show reaches out again, the system immediately alerts Anna in private so she can require an upfront deposit.
• Appointment Ledger: Stores timestamps, durations, service tiers, prices, and status transitions (CONFIRMED, PENDING_REMINDER, NO_SHOW, COMPLETED).

-- Persistent CRM Relational Layer in Cloudflare D1
CREATE TABLE IF NOT EXISTS clients (
  telegram_user_id TEXT PRIMARY KEY,
  name TEXT NOT NULL,
  phone TEXT,
  total_spend_vnd INTEGER DEFAULT 0,
  visit_count INTEGER DEFAULT 0,
  no_show_count INTEGER DEFAULT 0,
  is_flagged INTEGER DEFAULT 0,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

CREATE TABLE IF NOT EXISTS appointments (
  id TEXT PRIMARY KEY,
  client_id TEXT NOT NULL REFERENCES clients(telegram_user_id),
  service_name TEXT NOT NULL,
  start_time TIMESTAMP NOT NULL,
  end_time TIMESTAMP NOT NULL,
  price_vnd INTEGER NOT NULL,
  status TEXT CHECK(status IN ('CONFIRMED', 'PENDING_REMINDER', 'NO_SHOW', 'COMPLETED')),
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Ephemeral State in Cloudflare KV

KV manages high-frequency, temporary state where built-in Time-To-Live (TTL) auto-expiration eliminates the overhead of manual cron cleanup jobs:

• Master Activity Cooldown (1-hour TTL): Whenever Anna sends a manual message in any chat, the Worker writes a temporary key. For the next 60 minutes, the bot stays completely silent in that specific chat, ensuring it never talks over her during live conversations.
• Anti-Spam Throttling (2-hour TTL): Prevents duplicate greeting albums if an undecided lead sends four short messages in rapid succession.
• Live Digest Pointers (12-hour TTL): Maps appointment IDs to the daily summary message sent to Anna's private channel, allowing in-place edits when clients confirm.

export async function handleIncomingMessage(
  env: Env,
  chatId: string,
  fromMaster: boolean
) {
  const masterCooldownKey = `interaction:${chatId}:MASTER_ACTIVITY`;

  if (fromMaster) {
    // Write 1-hour TTL lock: bot stays completely silent while master is actively chatting
    await env.CRM_KV.put(masterCooldownKey, "active", { expirationTtl: 3600 });
    return;
  }

  const isMasterActive = await env.CRM_KV.get(masterCooldownKey);
  if (isMasterActive) {
    // Silently bypass bot response — human master has active conversational floor
    return;
  }

  // Check 2-hour anti-spam throttle for auto-greeting
  const greetingThrottleKey = `interaction:${chatId}:GREETING`;
  const alreadyGreeted = await env.CRM_KV.get(greetingThrottleKey);
  if (!alreadyGreeted) {
    await sendPriceListAlbum(env, chatId);
    await env.CRM_KV.put(greetingThrottleKey, "sent", { expirationTtl: 7200 });
  }
}

When developers consider natural language chat processing, the instinct is often to pipe every message into OpenAI or Claude. For high-volume chat automation, relying on external LLMs introduces severe failure modes:

• Unbounded Cost: Running inference across thousands of conversational messages in dozens of active chats escalates monthly bills.
• Latency Penalties: LLM round-trips add 1,000 to 3,000 milliseconds of latency to webhook processing.
• Hallucination Risks: Generative models can subtly distort dates, swap numbers, or miscalculate pricing.

Because appointment confirmations follow predictable syntax, parsing runs entirely on deterministic regular expressions and date arithmetic inside the V8 isolate in under 1 millisecond.

interface ParsedBooking {
  timeStr: string;
  durationMinutes: number;
  service: string;
  priceVnd: number;
}

export function parseBookingConfirmation(text: string): ParsedBooking | null {
  // 1. Affirmative verb gating: must contain a confirmation trigger
  const confirmRegex = /\b(booked|scheduled|reserved|записала|запись|готово)\b/i;
  if (!confirmRegex.test(text)) return null;

  // 2. Extract 24h or 12h time pattern (e.g. 15:30, 14.00, or 3pm)
  const timeMatch = text.match(/\b([01]?\d|2[0-3])[:.]([0-5]\d)\b/);
  const timeStr = timeMatch ? `${timeMatch[1].padStart(2, "0")}:${timeMatch[2]}` : "12:00";

  // 3. Extract duration in hours or minutes (e.g. 2.5h, 2h 30m, 90 min)
  let durationMinutes = 120; // default 2 hours
  const durMatch = text.match(/(\d+(?:\.\d+)?)\s*(?:h|hr|hours?|ч|часа?)/i);
  if (durMatch) {
    durationMinutes = Math.round(parseFloat(durMatch[1]) * 60);
  }

  // 4. Extract price in thousands (k VND) or raw currency
  let priceVnd = 0;
  const priceMatch = text.match(/(\d{3,4})\s*(?:k|к)?\s*(?:vnd|донгов|k\b)?/i);
  if (priceMatch) {
    priceVnd = parseInt(priceMatch[1], 10) * 1000;
  }

  return {
    timeStr,
    durationMinutes,
    service: "Manicure",
    priceVnd,
  };
}

Once an appointment confirmation is parsed, the engine checks whether the requested time window collides with existing bookings on that date.

If a conflict is detected, the Worker immediately delivers an alert to Anna's private control chat:

🚨 WARNING: Time overlap with Client A (10:00 AM – 12:30 PM)!

If the slot is clear, it calculates the rest buffer until the subsequent appointment. If that gap matches or exceeds her recovery buffer preference (e.g. 45–60 minutes), it commits the booking:

✅ Booking saved: August 17 at 10:00 AM. ☕ Rest window until next client: 60 min.

interface Interval {
  start: Date;
  end: Date;
}

// Deterministic calendar overlap detection:
// True if and only if Start A precedes End B AND End A exceeds Start B
export function isScheduleOverlap(a: Interval, b: Interval): boolean {
  return a.start.getTime() < b.end.getTime() && a.end.getTime() > b.start.getTime();
}

// Calculate downtime gap between appointments in minutes
export function calculateRestWindow(currentEnd: Date, nextStart: Date): number {
  const diffMs = nextStart.getTime() - currentEnd.getTime();
  return Math.max(0, Math.floor(diffMs / (1000 * 60)));
}

To permanently eliminate hopping out of Telegram into Google Calendar, Anna can inspect her entire schedule directly inside Telegram through a custom Telegram Mini App.

Instead of importing React, Next.js, or complex bundlers, the Mini App is constructed as a single-file vanilla TypeScript template. The HTML, CSS, and client-side logic are inlined into Cloudflare Worker memory and served as a pre-cached single-page app (/app).

• CSS Grid Timeline: A sleek dark-mode calendar displaying booked slots, client handles, and rest windows.
• Cryptographic Authentication: Validates window.Telegram.WebApp.initData using HMAC-SHA256 against the bot secret, guaranteeing that only the studio owner can open and view financial records.

Building this system validated my original hypothesis: eliminating app-hopping friction doesn't require complex enterprise software. It requires meeting users inside their primary interface:

• Preserve Natural Workflows: Operating natively within Telegram Business prevented both the master and her clients from having to navigate unfamiliar web portals or fill out external forms.
• Lifecycle-Driven Storage: D1 guarantees bulletproof relational persistence for client spending and history, while KV provides auto-expiring locks without scheduled cleanup overhead.
• Deterministic Parsing Beats Generative AI: When business logic follows structured patterns, sub-millisecond regex execution eliminates LLM API costs, network latency, and hallucinations.
• Lean Edge Frontends: Delivering vanilla TypeScript and CSS straight from edge memory provides instant load times without bundler bloat.