Broodli logo Broodlibuilt by Andrew Usachev
Broodli Case study

A family planner in Telegram, built end to end by one person

Product, code, payments, analytics and a content engine — shipped solo and live in production. What I decided, what I built, and how I measure whether it works.

Role: product builder (solo) Built in 17 days Live TypeScript · Telegram · Postgres · LLM

The problem

Household planning is invisible work, and it usually lands on one person.

Existing family apps ask for setup before they give anything back: create an account, connect a calendar, invite people, build lists. The person who carries the mental load does not want another system to maintain.

Broodli starts from the opposite end. A parent opens Telegram, answers three questions, and gets a plan for today. Lists, routines, reminders and family sharing grow from use, not from a setup wizard.

What it does

Onboarding

Three questions, then a plan

No calendar or email connection. The first useful output arrives in under a minute, which is the whole retention bet.

Planning

Text and voice in, a day out

“Milk, dentist, nappies, Sasha is allergic to nuts” becomes a plan with times, a shopping list and a dinner that fits.

Family

Shared lists and assignments

Up to six members, shared open lists, task assignment with a direct Telegram notification, weekly repeats.

Pacing

A lighter day, on request

“Too much” and “just right” feedback changes the pace of the current and future plans instead of only apologising.

Growth

Invites that reward both sides

A personal invite link: the invitee gets seven extra trial days, the referrer gets seven once the invitee finishes onboarding. Self-invites are ignored.

Broodli chat: a message becomes today's plan
Text in, plan out — the first screen a new user sees.

Decisions I made

Four calls that shaped the product more than any feature.

01

Telegram instead of an app

No install, no push infrastructure, no app-store review. The cost is platform risk and a smaller market — acceptable for a first version.

02

AI with a deterministic fallback

If the model is down or returns something unparseable, the user still gets a plan from a template. A planner that fails to plan is not a planner.

03

Price on AI actions, not seats

The free tier is deliberately tight, and the paid tiers are sized by daily AI actions — the actual cost driver — rather than by team size.

04

Activation before acquisition

Onboarding, the first plan and the pacing feedback came before any paid channel. Paying for traffic before activation works is how products die politely.

What I said no to: calendar and email integrations, a shared plan for the whole family, and “books or buys for you”. Each would have doubled the surface area before retention was proven. The feature-status doc marks them as not available, so public copy cannot drift into promising them.

How it is built

Two services, six packages, one repository, one deploy pipeline.

280commits in 17 days
250tracked files
144tests passing
2services in production

AI in the loop

Three different jobs, three different bars.

In the product

Gemini generates plans and extracts tasks from text and voice. Responses are parsed strictly; when that fails, a deterministic template takes over. A rolling token budget warns admins before the bill surprises them.

In the build

I build with Claude Code and OpenCode against a written spec: positioning, feature status, decision gates. The docs are the contract the agents work from, which is why they live in the repo next to the code.

In growth — a closed loop

A scheduled agent writes and renders short episodes three times a week and posts to Instagram, Telegram, Facebook, YouTube and TikTok. It then pulls the metrics back, groups episodes by hook, and feeds a brief from the last measured ones into the next story. It refuses to call a winning hook before three measured episodes.

How I decide whether it lives

Metrics were instrumented before launch, and the kill criteria were written down before the first ad dollar.

Every funnel step is tracked: started → onboarding_completed → plan_created → day-2 return → purchase. Attribution travels in the Telegram start parameter, so a channel can be judged on users, not clicks.

StepKeep goingStop / pivot
Landing → bot≥ 25%< 15%
Onboarding completed≥ 50%< 35%
Day-3 return≥ 30%< 15%
Day-7 return≥ 20%< 10%
The rule I wrote for myself: low onboarding means the first plan is wrong, not the channel. Low retention means the product did not become a habit, and no ad will fix that. Good retention with no purchases means the offer is wrong, not the product.

The gate was written before the first ad dollar. Deciding in advance what would make me stop is what separates a product bet from a hobby — and it is the first thing I set up.

Links

Source is private. Architecture, decisions and this write-up are what I can share; a code walkthrough is available on request.