Mango Lollipop

Challenge

Lifecycle messaging scattered across spreadsheets, notebooks, wikis, and slide decks. No single source of truth. Engineering bottleneck on event implementation.

Solution

An AI-powered CLI built on a battle-tested AARRR framework from 10+ years of real engagement work. One tool holds the entire system: strategy, copy, matrix, dashboards, event specs.

Value

33 messages across 6 lifecycle stages, generated in minutes. Production-ready Excel workbooks, interactive dashboards, brand-voice copy, and developer handoff specs.

I've spent 10+ years building lifecycle messaging systems for SaaS companies. Every engagement looked the same. Map the ICPs. Build customer journeys. Define triggers, timing, channels. Write the copy. Then scatter the whole thing across a spreadsheet, a notebook, a wiki, and a slide deck, because no single tool holds the entire picture.

The strategy was never the hard part. Keeping it together was. I was juggling Excel files for the message matrix, notebooks for the copy, docs for the customer journeys, and a separate conversation with engineering about which events they could actually fire. Every iteration meant updating four places. Every new hire meant explaining the system from scratch. Every quarter, the spreadsheet drifted further from what was actually running.

And then there was engineering. Getting events implemented was always the bottleneck. I'd spec out exactly what I needed, file the ticket, and wait. You can design the most sophisticated lifecycle system in the world. If the events don't get instrumented, none of it ships.

I needed a tool that held the entire system in one place. Strategy, copy, matrix, dashboards, event specs. One source of truth I could iterate on without rebuilding the spreadsheet every time. Nothing like that existed. So I built it. It's live on npm.

Interactive dashboard

Start with the output

I've seen lifecycle marketing prompts that give very little context and say "Generate personas." What the fuck are you going to get? Excel files? Blurbs? How do you iterate on that? What happens when you need to redesign them?

The problem isn't the prompt. The problem is nobody defined what they want to receive.

I started building Mango Lollipop the opposite way. I had years of lifecycle messaging work behind me. Real matrices with mapped messages, copy pages, event specs, the actual deliverables I'd hand to clients and engineering teams. I fed Claude the outputs first. Here's what a finished lifecycle matrix looks like. Here's how messages get coded against it. Here's what the copy page looks like when it's ready for implementation.

Then I defined the data model and validation rules. Then I built skills to generate each deliverable: the Excel workbook covering the full matrix, the interactive HTML dashboard, the message previews, the executive overview. Seven commands total: /start, /generate-matrix, /generate-messages, /generate-dashboard, /dev-handoff, /audit, /iterate.

Then I designed the onboarding flow so the whole thing could be collaborative. You paste a URL, the tool analyzes the product and audience, then builds from there. I review each stage, give feedback, steer the output. It's not a magic button. The tool does the heavy lifting. My judgment is what makes it good.

Then I wrapped the whole thing in an npm package. This was my first npm package. The lifecycle methodology was already solved. The packaging was the new challenge. Figuring out how to structure a CLI for public distribution, how to handle versioning, how the npm ecosystem actually works when you're the publisher and not just the consumer. It was unfamiliar territory and I liked that.

Start with what you want to receive. Work backwards from there.

Executive overview

The framework underneath

AI without a framework produces garbage. You can point any LLM at a SaaS website and ask it to write lifecycle messages. You'll get generic onboarding emails that could belong to any product. The model has no system to work within.

Mango Lollipop has one. The lifecycle framework maps every message to one of six stages: Transactional, Acquisition, Activation, Revenue, Retention, Referral. Every message has a trigger, timing, a channel, a CTA, a segment, and tags. Every message has guards (AND conditions that must all be true) and suppressions (OR conditions where any one blocks the send). One channel per message entry, so you never end up with a single row trying to describe an email and a push notification at the same time.

That's what makes the AI output useful. The model generates messages within a structure that already knows what good looks like.

Message previews

Writing the copy

The copy generation runs parallelized agents, batching messages to write faster across all six stages simultaneously. But speed isn't the point. The agents are trained on real-world examples of high-performing lifecycle messages and follow industry-standard frameworks and best practices baked into the tool's copywriting guide. Every message gets written with the right structure for its channel, the right tone for its stage, and the right intent for its trigger. No "Dear valued customer." No generic onboarding drip that could belong to any SaaS product. The copy comes out ready to review because the agents know what good lifecycle messaging actually looks like.

The dev handoff problem

Event implementation spec

This feature exists because of a specific frustration. I'd design the lifecycle system. Map every trigger, every condition, every suppression. Then I'd need engineering to instrument the events. And if resources were tight, that ticket sat in the backlog for weeks.

Mango Lollipop generates a dev handoff package: an intro email I can send to the engineering lead, plus a full technical event specification with priorities, payloads, and code examples. The AI understands all the event logic because it built the matrix. It can explain exactly what needs to be instrumented and why.

When engineering resources were tight, I could deploy events in a sandbox environment and test before production. The spec is detailed enough that the implementation path is clear regardless of who picks it up.

SignalStack

Demo homepage

The live demo shows SignalStack, a fictional company based on real client work, anonymized and generated entirely by the tool. 33 messages across 6 stages. The full matrix, the copy, the dashboards, the dev handoff. All of it.

Most teams either copy generic templates that don't fit their product, hire a consultant for $10k+, or skip lifecycle messaging entirely. Mango Lollipop handles the tedious, multi-tool assembly process that makes lifecycle messaging so hard to maintain. The thinking still has to come from someone who's done it.

Mango Lollipop started because I was tired of rebuilding the same system from scratch for every client. Real users have installed it and run it on their own companies. It's on GitHub. TypeScript, Node.js, Commander.js, no external services. Everything runs locally. That wasn't the plan. I just needed a faster way to do work I'd been doing for a decade.