DEV Community: Evgenii Zinner

How I Built an Invisible Telegram CRM for My Girlfriend's Nail Studio on Cloudflare Workers, D1, and KV

Evgenii Zinner — Mon, 17 Aug 2026 12:20:24 +0000

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.

Instead of signing up for an off-the-shelf booking SaaS with clunky external forms or hacking together an expensive LLM bot, I built a lightweight, serverless CRM that runs directly inside Telegram Business. It uses Cloudflare Workers, D1 (edge SQLite), KV, and a vanilla TypeScript Mini App.

The system processes bookings deterministically in under a millisecond, costs practically zero to run, and works silently inside normal client conversations without slash commands or bot menus.

The Real-World Friction: Lost Leads, Ghost Clients, and Calendar Juggling

On paper, running a private manicure studio is simple: do great nails, get booked, get paid. In reality, handling bookings through direct messages gets messy fast.

When you run local ads, inquiries land at all hours. People message asking for prices or open dates while Anna is in the middle of a 3-hour gel set, working out, or asleep. When an inquiry sits unanswered for two hours, potential clients just move to the next salon on Instagram. If you're paying for traffic, slow response times directly burn your ad budget.

Once a conversation starts, two bigger headaches appear:

Constant Context Switching: Scheduling meant constantly jumping out of Telegram into Google Calendar, checking open slots, typing out times, waiting for replies, hopping back to block the slot, and setting manual reminders. Doing this across 20+ active chats a day destroys your focus.
The "Ghost Client" Problem: Telegram lets users wipe entire chat histories for both sides with a single tap. Problematic clients would book prime Saturday slots, no-show, and immediately delete the chat. Two weeks later, they'd message again as if nothing happened. Because the conversation history was gone, Anna had no way to track repeat offenders.

The initial plan was modest: set up a quick auto-responder to send a price list photo album when Anna was away so new leads wouldn't bounce.

Once I started digging into the Telegram Business API, though, I realized we could do much more. We could turn the bot into an invisible assistant that sits directly on top of her normal conversations—logging client history, detecting double-bookings, and rendering an in-app daily schedule.

How Telegram Business Connected Bots Change the UX

Most Telegram bots require clients to search for a bot handle (@my_salon_bot), click Start, and tap through interactive menus. That works for large businesses, but for a private service master, it feels impersonal. Clients want to feel like they are talking directly to the artist.

With Telegram Business Connected Bots, the integration connects directly to Anna’s personal Telegram account.

From the client's perspective, it's just a normal conversation with Anna. Behind the scenes, the Cloudflare Worker intercepts incoming webhook events to handle the background logic:

If a new lead asks for pricing while Anna is busy, the bot automatically drops a friendly greeting and the price list.
When Anna types a routine confirmation like "Booked for tomorrow at 3:00 PM, manicure with removal, 2.5h, $55", the bot parses the message, creates a database record, checks for calendar overlaps, and calculates her rest window.
The client never sees command prompts, raw bot messages, or awkward third-party links.

Architectural Separation: Relational Storage (D1) vs. Ephemeral State (KV)

A common mistake with chat automations is trying to shove everything into a single database, or relying entirely on in-memory state that disappears whenever a serverless container spins down.

Pairing Cloudflare D1 with Cloudflare KV gives a clean split based on data lifecycle:

1. Cloudflare D1 for Persistent CRM History

D1 holds everything that must persist indefinitely:

Client Records: Maps immutable Telegram user IDs to names, phone numbers, lifetime spend, visit counts, and no-show flags. Even if a client wipes the chat history, their record in D1 remains untouched. If a serial no-show reaches out again, the bot immediately flags them in Anna’s private notes so she can require a 50% non-refundable deposit.
Appointment Ledger: Stores timestamps, durations, services, prices, payment methods, and statuses (CONFIRMED, PENDING_REMINDER, NO_SHOW, COMPLETED).
Config & Media Cache: Stores working hours, buffer preferences, and cached Telegram file_id strings so the bot doesn't waste bandwidth re-uploading media over webhooks.

2. Cloudflare KV for Ephemeral Coordination

KV handles short-lived state where built-in Time-To-Live (TTL) auto-expiration eliminates the need for cleanup jobs:

Active Master Cooldown (interaction:{chatId}:ANYA_ACTIVITY, 1-hour TTL): Whenever Anna sends a manual message in any chat, the Worker writes this key. For the next 60 minutes, the bot stays completely quiet in that chat. This guarantees the bot never talks over Anna while she is actively texting a client.
Anti-Spam Throttling (interaction:{chatId}:GREETING, 2-hour TTL): Prevents duplicate greeting messages if an undecided client sends four short texts in a row.
Live Digest Pointers (appt_digest_key:{apptId}, 12-hour TTL): When the morning reminder cron runs, it maps each appointment ID back to a single summary message sent to Anna's private chat. When a client confirms via button, the Worker updates the existing summary message in place instead of spamming her with new notifications.

Deterministic Parsing: Why I Skipped LLMs

When developers hear "parse natural language chat messages," the default reaction is to reach for OpenAI or Claude. For this use case, calling an LLM on every incoming message was the wrong move:

Cost: Running an LLM across every message in dozens of active chats adds up fast.
Latency: External LLM calls add 1 to 3 seconds of overhead.
Reliability: Generative models can hallucinate dates, drop numbers, or subtly misinterpret prices.

Because booking confirmations follow predictable phrasing, the parser runs entirely on deterministic regex and simple date arithmetic inside the Worker in under 1 millisecond.

1. Affirmative Verb Gating

To make sure the bot doesn't accidentally record a booking when Anna is just discussing availability, the parser requires an affirmative confirmation keyword (e.g., Booked, Scheduled, Reserved, Set).

Phrases containing exploratory words (can do, open slots, what time works) are ignored.

2. Time, Date, and Duration Normalization

The parser handles conversational variations:

Times: Converts standard 24h formats (15:30, 14.00) as well as relative conversational hours (turning afternoon single digits like 3 or 5 into 15:00 and 17:00, while preserving 10 and 11 as morning slots).
Dates: Resolves relative terms (today, tomorrow, day after tomorrow), ordinal suffixes (26th, 28th), and weekdays (this Friday, next Monday).
Durations: Extracts explicit values (2.5h, 2h 30min, 90 min), falling back to default durations per service.
Pricing: Normalizes mixed notation ($55, 55$, 55 usd, 55 bucks, or raw numbers like 55) into clean integer values.

Overlap Detection and Break Calculations

Once an appointment is parsed, the engine checks whether the slot conflicts with existing bookings and calculates the downtime between clients.

If an overlap is detected, the Worker sends an alert directly to Anna's private chat:

🚨 WARNING: Time overlap with Client A (11:00 AM - 1:30 PM)!

If the slot is clear, it calculates the rest gap until the next client. If that gap matches or exceeds her buffer setting (e.g., 30 minutes), it logs the confirmation:

✅ Booking saved: August 26 at 2:15 PM. ☕ Rest window until next client: 45 min.

In-Chat Timeline via Telegram Mini App

To eliminate switching between Telegram and Google Calendar, Anna can open her full daily schedule directly inside Telegram via a lightweight Mini App.

Instead of bringing in React, Vue, or build tooling, the Mini App is a single-file TypeScript template. The HTML, CSS, and client-side JS are inlined straight into Worker memory and served as a cached single-page app (/app).

CSS Grid Timeline: A clean vertical grid for the day (08:00 to 22:00).
Dynamic Offsets: Minimal vanilla JS calculates the exact pixel height and top margin for appointment blocks based on start time and duration.
Authentication: Requests pass window.Telegram.WebApp.initData. The Worker verifies the HMAC-SHA256 signature against the bot token, ensuring only Anna can access the view.

Interactive 24-Hour Reminders with In-Place Updates

Checking next-day appointments and texting reminders used to take 20 minutes every morning. Now, a Cloudflare Cron Trigger runs daily at 11:00 AM local time (0 4 * * * UTC).

Client Reminders

The cron pulls confirmed bookings for the next day and sends interactive inline buttons to each client:

"Hi! Just reminding you about our appointment tomorrow (August 18) at 2:00 PM for Manicure + Removal 💅"

[ ✅ I will be on time ] [ 🔄 Reschedule ] [ ❌ Can't make it ]

Updating the Daily Digest Without Notification Spam

When reminders go out, the bot also sends Anna a consolidated morning digest:

📅 Tomorrow's Schedule (August 18):

❓ 10:00 AM — Alina (Manicure + Removal) (Waiting for reply)

❓ 2:00 PM — Katya (Pedicure) (Waiting for reply)

The Worker saves this digest to KV (daily_digest:{timestamp}) and creates pointer keys for each appointment (appt_digest_key:{apptId}).

When a client taps [ ✅ I will be on time ]:

The webhook reads appt_digest_key:{apptId} to find the message ID.
It flips that client's icon from ❓ to ✅.
It calls Telegram’s editMessageText API to update the digest message in place.

Anna can check her morning summary at any point during the day and see real-time updates without her phone buzzing every time someone confirms.

External Calendar Sync with ETag Caching

For instances where Anna wants her schedule synced to a desktop calendar app, the Worker exposes an RFC 5545 .ics feed over webcal://.

External calendar clients poll feeds aggressively, which can trigger unnecessary D1 reads. To keep overhead minimal, the endpoint generates an ETag based on the active booking count and the most recent modification timestamp:

ETag: "{appointmentCount}_{latestModifiedTimestamp}" (e.g. "14_1723982400000").

When a client polls with a matching If-None-Match header, the Worker immediately responds with 304 Not Modified, skipping data serialization and body transfer completely.

Wrap-Up

Building this setup reinforced a few practical rules for indie edge tools:

Keep users in their existing workflow: Building on top of Telegram Business meant Anna and her clients didn't have to learn a new app or deal with third-party booking portals.
Right tool for the right lifespan: D1 handles permanent relational records (clients, revenue, history), while KV handles short-lived state (cooldowns, message pointers) with zero manual cleanup.
Don't overcomplicate with AI when deterministic rules work: A few well-crafted regex patterns run in under a millisecond, cost nothing, and don't hallucinate dates or prices.
Lean frontends on the edge: Serving vanilla TypeScript and CSS straight from edge memory gives sub-100ms load times without managing client-side build pipelines.

MCP Server to generate custom QR codes directly in Cursor and Claude

Evgenii Zinner — Mon, 20 Jul 2026 05:39:29 +0000

If you use Cursor, Claude Desktop, or Cline as your daily driver, you know how annoying it is to leave your editor just to generate simple project assets.

Last week, I was testing print layouts for a physical marketing project that needed scannable codes. I was tired of opening browser tabs, fighting spammy online generators that lock vector downloads behind paywalls, or getting forced into a subscription just to get an SVG.

So, I built an MCP (Model Context Protocol) server for my QR Generator.

Now, my AI assistant can generate high-resolution, customized QR codes (including clean vectors, custom shapes, and embedded logos) directly inside my IDE.

Here is how it works, what it does, and how to hook it up to your environment.

What it does (and why standard PNGs suck)

Most basic QR generators output low-resolution PNGs. If you try to print them on packaging or signage, they pixelate and scan terribly under bad lighting.

To solve this, the MCP server exposes a single, highly flexible tool: generate_qr_code. It lets you control:

Format: Choose between standard png, svg (perfect for print), or raw json.
Design Physics: Custom dot styles like circle, hex (hexagon), and diamond instead of boring old squares.
Color & Branding: Direct primary hex color mapping (e.g., #00f0ff) and custom logo uploads inside the data grid.

Setting it up in your IDE

Because the server runs over Server-Sent Events (SSE) hosted on our cloud backend, you don't need to install local runtimes or configure Python/Node environments.

To add it to your Claude Desktop or Cursor configuration, open your claude_desktop_config.json (or your Cursor MCP settings) and paste this snippet:

{
  "mcpServers": {
    "ez-qr-generator": {
      "url": "https://ez-qr-generator.com/mcp",
      "transport": "sse"
    }
  }
}

Once saved, your AI agent will automatically detect the connection.

How to use it in practice

You don't need to write any JSON arguments manually. Just tell your assistant what you want in plain English. For example, if you are working in Cursor, you can prompt your agent:

"Hey, generate a hexagonal green QR code pointing to https://ez-qr-generator.com and place it in my assets folder as a SVG."

The assistant calls the server, processes the base64 or SVG output, and writes the file directly to your workspace. No context switching, no signups, and no paywalls.

If you want to test the raw JSON-RPC endpoint yourself or see the official registry, you can check out the Smithery page.

Give it a spin, and let me know if you run into any schema or connection issues!

Technical Architecture of EZ EDGE CMS

Evgenii Zinner — Tue, 17 Mar 2026 20:58:02 +0000

I developed EZ EDGE CMS with a specific goal: to create a content management system that runs entirely on Cloudflare Workers without the bloat of traditional frameworks. By moving styling, image processing, and SEO logic to the edge, I’ve eliminated the need for origin servers and complex build pipelines.

Here is the technical breakdown of the engine and the trade-offs I made to keep it fast.

1. Zero-CSS Middleware (with Theme Constraints)

EZ EDGE CMS has no static CSS files. I integrated a Just-In-Time (JIT) UnoCSS middleware that runs at the edge. When a request is made:

The middleware scans the HTML content.
It generates the minimal utility classes required for that specific page.
It injects the CSS directly into the . The Restriction: To maintain this performance, you cannot upload custom CSS files. You are limited to built-in themes where you can only customize colors and fonts. This ensures the JIT engine stays lightweight and prevents slowing down the edge isolate.

2. Edge-Native Image Processing

Instead of relying on external S3 buckets or heavy image transformation services, I handle assets directly within the Worker:

WebP Conversion & Resizing: When you upload an image, the CMS automatically resizes it and converts it to WebP format. This ensures maximum compression and faster loading times for end-users.
KV Binary Storage: Images are stored as Uint8Array binaries in Cloudflare KV. They are served from the same edge location as your content.
Garbage Collection: When you save a page, I've implemented logic that identifies "orphaned" images (assets no longer used in your content) and deletes them from KV to keep your storage costs at zero or near-zero.

3. Automated SEO & JSON-LD Graphs

I dont like to manually manage metadata, so I automated the SEO layer using Schema.org JSON-LD graphs.

Automated SEO Layer: Replaced manual metadata management with a dynamic system built on Schema.org JSON-LD graphs to provide search engines with a high-accuracy site map.
Persona Integration: Automatically injects identity data (Organization/Owner) directly into the page structure.
Dynamic Breadcrumbs: Generates a real-time BreadcrumbList hierarchy that maps the page’s exact position.
Automated Asset Delivery: Serves optimized Open Graph (OG) images and tailored meta tags without manual updates.
Structured Metadata: Pulls standard SEO values from the CMS editor.

4. Script Injection for Interactivity

Since the themes are constrained, I added the ability to inject Global and Page-Related Scripts.

Global Scripts: Useful for adding analytics (like Google Analytics or Plausible) or sitewide chat widgets.
Page Scripts: Allows you to add specific functionality to a single page without bloating the rest of the site.

5. Block-Based Editor

To ensure the edge engine receives clean, predictable data, I integrated Editor.js. Unlike traditional WYSIWYG editors we store and parse a clean JSON structure.

Structured Data: The CMS stores content as JSON blocks, which are then parsed at the edge into semantic HTML.
Clean Output: This ensures that the JIT CSS engine (mentioned below) only scans valid, structured content, reducing processing overhead.
Extensibility: I’ve plan to customize editor to handle specific blocks that sync perfectly with the edge-native theme.

6. Current Technical Restrictions

Being honest about the limitations is part of the "Edge-Native" philosophy. If you use EZ EDGE CMS, you need to be aware of these:

Design Limits: You cannot build a "from-scratch" custom layout. You must work within the parameters of my optimized built-in themes (Colors/Fonts only).
25MB Value Limit: Cloudflare KV has a hard limit of 25MB per entry. This applies to individual pages and images.
Propagation Delay: While the updateQueue prevents write errors, it can still take up to 60 seconds for a new post to appear in every single Cloudflare data center globally due to KV's native consistency model.
Limitation for distributed teams: Currently recommended for solo work; without Durable Objects for atomic locking, simultaneous editing by multiple users is not possible to avoid data loss due to "last write wins" conflicts.

It is in a POC stage now, I need some time to work with it to shape a finalized vision and fix bugs, but i welcome everyone who willing to try or contribute
See it in action: First website made on EZ EDGE CMS
Explore the Code: Source code
Try it yourself: Deploy to Cloudflare Workers

ez_commit: A Rust CLI for AI-Powered Conventional Commits

Evgenii Zinner — Thu, 05 Feb 2026 18:44:20 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

ez_commit is an interactive Rust-based CLI designed to take the friction out of writing Conventional Commits. It combines a compact Terminal User Interface (TUI) for selecting and staging files with an AI-assisted generation engine.

The tool enforces a human-in-the-loop model: Copilot suggests a commit draft based on your staged changes, and you review or edit it before it ever touches your git history.

Why I built this: Maintaining a clean, consistent commit history is vital for changelogs and team collaboration, but it’s often the first thing to slide when developers are in a rush. ez_commit makes doing the "right thing" the fastest path.

Demo

You can find the full source code and installation instructions here:

Evgenii-Zinner / ez_commit

CLI tool for fast commiting using GitHub copilot

ez_commit

Interactive CLI tool for generating conventional commit messages with AI assistance.

A simple, fast, and human-in-the-loop commit workflow. Select files, let AI analyze your changes, review the message, and commit—all from the terminal.

Features

✨ Interactive file selection - TUI-based multi-select of changed files
🤖 AI-powered messages - GitHub Copilot integration for smart commit messages
📝 Conventional Commits - Automatically formats to type(scope): description
✏️ Manual review - Edit the generated message before committing
⚡ Fallback analyzer - Works without Copilot with built-in smart analysis
🔍 Verbose mode - Debug details with -v flag

Quick Start

# Build
cargo build --release

# Run
./target/release/ez_commit

# With verbose output
./target/release/ez_commit -v

Usage

Select files - Arrow keys to navigate, Space to toggle, Enter to confirm
Review message - AI generates a commit message with summary + bullet points
Edit (optional) - Your editor opens for final tweaks
Commit - Changes…

View on GitHub

Screenshots

My Experience with GitHub Copilot CLI

I developed this project using an agentic loop, where GitHub Copilot CLI handled much of the heavy lifting. My workflow looked like this:

Initial Design: I started with a README.md acting as a design doc. I described the problem, the required features, and my choice of Rust.
The Agentic Cycle: I used Copilot CLI to generate boilerplate and logic from prompts. It was a cycle of: Generate → Build → Copilot read Errors → Fix.
Fast Prototyping: Copilot produced a working prototype remarkably fast. I spent roughly three hours total on this project—including thinking, waiting for builds, and reviewing results.
The "Premium" Wall: I wasn't read docs too thoroughly, so didn't notice that any usage of Copilot CLI count as premium calls, so i spent prompt budget really fast.
Granularity of Feedback: While Copilot is working on a file, it often reports the number of lines it is changing. However, it would be much more helpful to see the actual code diff directly in the dialogue rather than just numbers. Since it processes one file at a time, seeing the specific logic changes live would allow for much faster verification

Overall Impression: The speed of iteration is the killer feature here. Moving from a blank folder to a Rust CLI with TUI and AI integration in one afternoon felt like having a senior pair-programmer who never gets tired. And I used this tool after first iteration to create commit messages (so some errors are logged in history), it was fun experience.

How to Use

To get started with ez_commit locally:

# Build the project
cargo build --release

# Run the binary
.\target\release\ez_commit.exe

Key Features:

-v, --verbose: See exactly what's being sent to the AI.
-s, --skip-copilot: Use the local fallback analyzer if you're offline or out of credits.
-d, --diff-limit: Control how much code context is sent to the model.

I built an app and got tired of manual avatar struggles: Inconsistent colors for the same user. Two different users getting the same color. The fix? Use a hash of the name to generate a color. https://pub.dev/packages/ez_circle_avatar

Evgenii Zinner — Sat, 22 Nov 2025 02:31:52 +0000

ez_circle_avatar | Flutter package

A defensive, customizable avatar widget that automatically generates initials and colors from names.

pub.dev