Portfolio · Case studies

Work that moved the needle.

Three product management case studies, anonymised where required. Each led from ambiguity to a measurable outcome.

Case study 01

Legacy app rebuilt from the inside out

Not a gradual migration—a parallel build, a module-by-module beta with real customers who had to greenlight each piece, and a single clean deployment that replaced the old app without asking anyone to redownload.

70%Of engineering time freed from firefighting—back to building
>20%Recovery in customer trust—satisfaction past its pre-decline peak
$2M+ARR that had been at churn risk, retained through confident migration

The real problem

The app had accumulated years of debt—bugs eroding customer confidence, API performance dragging the experience, and an engineering team spending most of their time on fixes rather than progress. Replacing it entirely was the right call, but while the new build happened, the live product still had to work. Customers couldn't wait 12 months for a rewrite.

The product question was: how do you manage two roadmaps simultaneously without letting either one fail?

The call I made

I ran two roadmaps in parallel. The live app roadmap was about surgical triage: I prioritised which bugs had the highest customer impact and which APIs most needed reoptimisation, then deployed fixes in sprints. Customers saw improvement immediately. Crucially, as bug-related work fell, engineering capacity was freed—and I redirected that capacity directly into the new build.

The new app roadmap was a full product build: which pages to rebuild first, complete redesigns of each, which new functionality to scope, and how to sequence it all. The new app was developed on a separate branch in parallel with the live product, with every unresolved issue from the old version baked in from the start rather than carried over as debt.

Before any cutover, we ran a structured beta—select customers testing module by module, with a greenlight required from every stakeholder before we moved on. Once the final sign-off came, we pushed the new app to the production branch. Users didn't redownload anything. They just logged back in. The old app was retired.

What it produced

The cutover was invisible to users—no redownloads, no retraining, no disruption. Bug-related engineering work fell 70%, freeing the team to build forward rather than patch backward. Customer satisfaction recovered past its pre-decline baseline, and the nature of customer conversations changed: from reporting problems to asking what was next. The $2M+ ARR at churn risk was retained, and the rebuilt platform became the foundation for product lines that would never have been possible on the old stack.

Ionic FrameworkParallel-build strategyModule-by-module betaCustomer greenlight processZero-disruption cutover
Case study 02

Turning a fragmented integration into a repeatable playbook

Brought in to build a team that could get acquired and in-house brands live on a white-label platform—but the first product problem wasn't customer-facing. It was the launch process itself, which was taking 12 months and nobody owned.

12→3Months to launch a new brand—before and after the playbook
20%Engineering effort recovered—no more rebuilding the same work twice
$30MCLV grown through experimentation across the brand portfolio

The real problem

Every new brand launch touched 12 teams—but none of them owned it. The work wasn't part of anyone's OKRs, so POs had no real incentive to prioritise it. Each team was doing their piece in isolation, with no visibility into what the others were doing or what the overall launch depended on. Launches were taking 12 months—not because the work was complex, but because the system wasn't set up to move it.

The call I made

Before I could build anything, I needed to understand what each of the 12 teams actually contributed to a launch. I went to every PO individually—not with a brief, but with questions. Once I had the full picture, I designed a launch playbook: every work package defined, sequenced, and scoped into a template engineers and project managers could follow without reinventing it each time.

That cut launches from 12 months to 3. Then I used the foundation to do what I'd been hired to do: build a product roadmap for the white-label platform itself. I identified improvements that could be deployed across all brands or scoped to a single one, and ran experiments—social proofing, sign-up funnel redesigns, layout and colour A/B tests—all measured against subscriber growth and customer revenue.

What it produced

Launch timelines fell from 12 months to 3—not through pressure, but through clarity. Once every team knew exactly what they owned and how it connected, the work moved. Engineering effort that had been spent rebuilding the same components for each brand dropped 20%. The white-label platform stopped being a static infrastructure layer and became a product we actively improved: experiments ran across a portfolio of brands, generating signal on what actually drove subscribers and revenue. The $30M CLV figure reflects what those improvements compounded into.

White-label platformLaunch playbook designCross-team OKR alignmentStatsigA/B experimentationFunnel optimisation
Case study 03

Getting a two-year-delayed MVP out the door

The schedule problem was real. But the product problem was that nobody had agreed on what the MVP actually was—and until that was resolved, nothing else would move.

$50MRevenue from a product that nearly never made it out the door
30%Operations moved faster post-launch—the product was built to be iterated on
2→12Team scaled on the foundation we built—not a rewrite

The real problem

Two years of development without a ship. Scope had expanded with every quarter, ‘done’ meant something different to everyone in the room, and the team had quietly stopped believing it would happen. They were technically capable—the environment had failed them, not the other way around.

Adding more process or more pressure wouldn't have worked. The first product decision was figuring out what had actually broken down before trying to fix anything.

The call I made

I started with 1:1s—not to gather requirements, but to understand where trust had gone. Before I could make good product decisions, I needed to know what the team needed from the process to believe in it again. That came first.

Then: ruthless scope reduction to a defensible MVP definition, tight sprint goals designed to feel achievable (not aspirational), and an early-adopter cohort before any general release. The cohort was a deliberate product choice—not a soft launch but a validation instrument. Real signal from real users before we committed to scale. When the product worked for them, we had the evidence to move fast.

What it produced

The MVP shipped—which, two years in, wasn't a given. $50M in revenue in the initial market window, from a product that had nearly been written off. Post-launch, the ops team moved 30% faster because the product had been built to be worked with, not worked around. The team that launched at two people scaled to twelve on the same foundation—no rewrite required. And the early-adopter model held: every product I've launched since has started with a defined validation cohort before general release, because that's what prevented us from scaling the wrong thing.

MVP scopingEarly-adopter validationIncremental AgileScope reductionProduct-team trust