User Lifecycle (CLM) RFM Segmentation · Growth 0→1 Program Pathao Food · 2024

RFM & CLM Engine
Reactivating a 3.9M-User Base

How I designed Pathao Food's Customer Lifecycle Management program from the ground up: scoring every user on Recency, Frequency, and Monetary value, building a 28-segment matrix out of it, and turning that matrix into a budget-governed, always-on reactivation engine - not a one-off promo blast.

3.9M+ users
Scored and segmented across the RFM engine
28segments
7 value tiers × 4 recency cohorts
83%
Of the base sat in the lowest-value, most-dormant tier
12weeks
Always-on lifecycle comms roadmap I designed
01 — Background

A super-app with millions of food users, and no systematic way to keep them.

Pathao is Bangladesh's leading super-app - rides, deliveries, and food ordering under one roof. Pathao Food, the food delivery vertical, had built up a user base in the millions over several years of acquisition pushes, seasonal campaigns, and organic growth riding on the rest of the super-app.

What it hadn't built was a systematic way to manage that base over time. Retention activity existed, but it was campaign-shaped: a promo push around a holiday, a blanket "we miss you" notification, a discount code blasted to everyone regardless of whether they needed the nudge. There was no persistent model of who a user was in their lifecycle - newly acquired, loyal and active, drifting, or already gone - and no infrastructure that let the growth team target spend at the users who actually needed it.

I proposed and built the RFM-based Customer Lifecycle Management (CLM) engine to close that gap: a persistent segmentation model that scores every user on Recency, Frequency, and Monetary value, and a treatment framework built directly on top of it - so retention spend goes where it changes behaviour, not where it's easiest to send a push notification.

The product vision: Replace one-off retention campaigns with a persistent lifecycle infrastructure - one that classifies every user into a value-and-recency segment, prescribes the right treatment for that segment, and measures success on cohort migration and long-term behaviour change, not just short-term redemption.


02 — Problem

Blanket campaigns were burning budget on the wrong users - and missing the real one.

When I pulled the full active-user base and looked at it through a recency and value lens for the first time, three problems became impossible to ignore.

01
No segmentation meant no discipline in where promo budget went
Retention pushes went out to broad user lists with little differentiation. A user who had ordered food three days ago received the same "come back" promo as a user who hadn't ordered in eight months. Spend wasn't correlated with need - it was correlated with whichever list was easiest to pull. That's an expensive way to run retention at super-app scale.
02
A massive dormant tail was being treated the same as everyone else - or ignored entirely
When I scored the base, 78% of users hadn't placed a food order in 200+ days, and the large majority of the total base fell into the lowest-value tier. This wasn't a small edge case to clean up later - it was the dominant shape of the user base. Any retention strategy that didn't put this group at the centre of the plan was solving the wrong problem.
03
No way to isolate what the spend was actually causing
Without a control group built into the design, there was no way to know whether a user who came back after a promo would have come back anyway. Every campaign retro was guesswork about incrementality. I needed a framework where holding out a group wasn't an afterthought bolted onto an existing campaign, but a first-class part of how every segment's treatment was decided.

03 — My Approach

Five decisions that turned a spreadsheet exercise into lifecycle infrastructure.

01
Build a persistent engine, not a campaign
The brief could have been answered with a single "win-back" promo blast. I deliberately scoped it wider: a reusable RFM scoring and segmentation model that any future campaign - not just this one - could plug into. That meant defining recency bands, a value-tier taxonomy, and a scoring cadence as durable infrastructure, not a spreadsheet built for one send.
02
Name the value tiers in plain language cross-functional teams could actually use
Raw RFM scores are meaningless in a stand-up with finance or marketing. I mapped every user's combined Frequency and Monetary score into seven named value tiers - Diamond down to Rust - so growth, finance, and comms could talk about "the Rust cohort" instead of "users scoring 1-2 on F and M," and immediately understand where they sat in the value ladder.
03
Cross value tier with recency to get a matrix that's actually actionable
A value tier alone doesn't tell you whether to spend on someone this week. I crossed the 7 value tiers with 4 recency bands (0–30, 31–90, 91–200, 200+ days since last food order) to produce a 28-cell matrix - the smallest structure that let me prescribe a distinct treatment, message, and budget allocation per segment instead of one blanket rule.
04
Design control holdouts into the matrix itself, not as an afterthought
Instead of holding out a random sample after the fact, I built the holdout logic directly into the treatment matrix: segments that were already organically engaged - recently active, already ordering food as their primary app behaviour - were deliberately excluded from treatment, both to protect margin and to give every future analysis a clean, built-in incrementality baseline.
05
Model the budget before asking for it, and measure more than redemption
Before taking this to finance, I modelled promo burn across worst, average, and good-case redemption scenarios and two different discount-cap structures - so the ask was grounded in numbers, not intuition. I also designed the measurement framework - 20+ metrics across eight categories - before launch, so success would be judged on cohort migration and tier stability, not just how many promo codes got redeemed.

04 — RFM Framework

Two axes, 28 cells, and a user base that looked nothing like I expected.

RFM segmentation scores every user on three independent dimensions and combines them into an addressable structure. I defined how each axis would be measured for Pathao Food specifically, then combined them into the matrix that drove every downstream decision.

Axis 01
Recency
Days since last food order · 4 bands
0–30D 31–90D 91–200D 200D+
Answers: how long has it been since this user last ordered food? I set the band cuts at 30, 90, and 200 days rather than even splits, because the treatment logic changes sharply at each of those points - a user at day 25 is still organically warm, a user at day 250 needs a fundamentally different (and more expensive) reactivation offer than a user at day 40.
Axis 02 & 03
Frequency & Monetary
Combined into 7 named value tiers
Order count Spend Composite score
Answers: how valuable is this user when they are active? I combined order frequency and cumulative spend into a single composite value score, then mapped that score into seven tiers - Diamond, Platinum, Gold, Silver, Bronze, Iron, Rust - so the value axis could be communicated as clearly as the recency axis.
Cross-cut
Food-Usage Category
Primary · Secondary · Non-food
Primary Secondary Non-food
Answers: is food this user's primary reason for being on Pathao at all? Because Pathao is a super-app, a user can be high-value overall - frequent rides, high spend - while barely touching food. I tagged every segment's dominant food-usage status so the campaign could tell the difference between "win this user back to food" and "reactivate this user in food, full stop."

The number that reframed the whole program: once I ran the scoring, 3,913,386 users fell into the addressable base. Of those, 83% sat in the lowest-value Rust tier, and 78% hadn't ordered food in 200+ days. This wasn't a loyalty program for an already-engaged base - it was overwhelmingly a reactivation problem for a long, dormant tail, and that single insight changed where I put the program's priority and budget.

The 28-segment matrix

Every one of the 3.9M+ users falls into exactly one of 28 cells - one of 7 value tiers crossed with one of 4 recency bands. Each cell shows its population and whether it received a promotional treatment or was deliberately held out as a control.

Value Tier 0–30 days 31–90 days 91–200 days 200+ days
Diamond 244
Control
45
Treated
12
Treated
503
Treated
Platinum 2,053
Control
1,095
Treated
330
Treated
5,760
Treated
Gold 2,090
Treated
1,026
Treated
1,625
Treated
35,782
Treated
Silver 9,755
Control
8,520
Treated
1,531
Treated
7,952
Treated
Bronze 9,716
Treated
7,772
Treated
13,961
Treated
50,167
Treated
Iron 48,360
Treated
57,557
Treated
67,504
Treated
313,406
Treated
Rust 137,978
Treated
188,635
Treated
283,477
Treated
2,656,530
Treated

Bottom-right cell - Rust tier, 200+ days dormant - is the single largest segment in the base at 2,656,530 users, 68% of the entire addressable population on its own.


05 — Value Tiers

Seven tiers, one value ladder, an extreme long tail.

I named the tiers after a familiar loyalty-ladder convention - Diamond at the top, Rust at the bottom - specifically so non-technical stakeholders could reason about segment value at a glance. Underneath the names, each tier is a composite Frequency + Monetary score band, computed against the full active base.

Diamond
0.02%
~800 users
Platinum
0.24%
~9.2K users
Gold
1.04%
~40.5K users
Silver
0.71%
~27.8K users
Bronze
2.09%
~81.6K users
Iron
12.44%
~486.8K users
Rust
83.5%
~3.27M users

The distribution isn't a gentle pyramid - it's a cliff. Diamond through Bronze together hold less than 4% of the base. Iron and Rust alone account for over 96% of all users. That shape told me something a flatter distribution wouldn't have: this program couldn't be designed primarily around rewarding the top of the ladder. The real product problem, and the real budget, needed to live at the bottom of it.

Why I kept seven tiers instead of collapsing them: it would have been simpler to run this as three buckets - high, medium, low. I kept seven because the treatment logic genuinely differs between adjacent tiers, especially near the bottom: Iron and Rust needed materially different discount depths and messaging even though both sit in the "low value" region of a simpler model. Collapsing them would have hidden exactly the granularity the campaign needed to act on.


06 — Treatment Logic

Different offer, different target, different reason - for every cell in the matrix.

I didn't design one promo and apply it everywhere. Each of the 28 segments has its own combination of: whether it's treated at all, the discount depth and minimum order value, the usage cap, whether curated collections accompany the push, and which RFM dimension the treatment is designed to move - recency alone, or recency and frequency together.

Freshly active users (0–30 days): spend only where it's needed

Within the most recent recency band, I split treatment on food-usage category, not just tier. Users who were already ordering food as their primary app behaviour got no promo at all, regardless of value tier - they were already converting organically, and spending budget on them would have been pure margin loss. Users who were active on Pathao but not yet primary food users got treated, specifically to cross-sell them into the food vertical.

TierFood statusTreatmentOfferTarget
DiamondPrimaryNo treatmentOrganic, no intervention needed
PlatinumPrimaryNo treatmentOrganic, no intervention needed
GoldNot yet primaryTreated30% off, up to Tk80, MOV Tk349, cap 2 uses + collectionsRecency & frequency (cross-sell to food)
SilverPrimaryNo treatmentOrganic, no intervention needed
BronzeNot yet primaryTreated30% off, up to Tk80, MOV Tk249, cap 2 usesRecency & frequency (cross-sell to food)
IronSecondaryTreated20% off, up to Tk80, MOV Tk249, single useRecency
RustSecondaryTreated20% off, up to Tk80, MOV Tk249, single useRecency

Dormant users (200+ days): the largest, most expensive-to-move segment

At the other end of the recency axis, every tier gets treated - the priority flips entirely to just getting one order placed again. Discounts here are the deepest in the entire matrix, minimum order values are lowered to reduce friction, and usage caps are raised so a single reactivation can turn into a short habit-forming streak.

TierFood statusTreatmentOfferTarget
DiamondPrimaryTreated50% off, up to Tk100, MOV Tk349, cap 3 usesRecency
PlatinumPrimaryTreated50% off, up to Tk100, MOV Tk349, cap 3 usesRecency
GoldPrimaryTreated50% off, up to Tk100, MOV Tk349, cap 3 usesRecency
SilverSecondaryTreated50% off, up to Tk100, MOV Tk249, cap 3 usesRecency
BronzeSecondaryTreated50% off, up to Tk100, MOV Tk249, cap 3 usesRecency
IronSecondaryTreated50% off, up to Tk100, MOV Tk249, cap 3 usesRecency
RustSecondaryTreated50% off, up to Tk100, MOV Tk249, cap 3 usesRecency

The control-holdout decision: only 5 of 28 segments - the already-primary, already-fresh, higher-value tiers in the 0–30 day band - were held out as control, covering roughly 24,000 users, under 1% of the base. Every other segment, including all four recency bands of the dominant Rust tier, received a tailored treatment. That's a deliberate, asymmetric holdout: protect margin on the small slice that doesn't need spend, and commit budget everywhere else, especially the dormant tail that makes up the majority of the base.


07 — Budget Governance

Modelling the worst case before asking anyone to approve the average case.

A 28-segment matrix with differentiated discount depths is only useful if finance will actually fund it. Before this went to sign-off, I built a burn model across every segment - projecting cost under three redemption scenarios and two different discount-cap structures, so the conversation with finance started from numbers, not intuition.

Worst case
100% theoretical redemption
Every eligible user in every treated segment redeems their offer at maximum usage. This is the ceiling I modelled to know the absolute exposure - not a forecast, a boundary. It's the number that makes a budget conversation honest.
Average case
~12.55% redemption
Modelled off realistic promo redemption benchmarks for this offer structure and audience. This is the figure I built the actual budget ask around - roughly an order of magnitude below the worst case, and the number I held the campaign accountable to.
Good case
~16% redemption
An upside scenario reflecting stronger-than-typical engagement, used to show finance the ceiling of value the program could return if the offers landed better than the average-case assumption.

Two discount-cap structures, modelled side by side

I also stress-tested two different discount-cap ceilings - a higher-cap structure (Tk80–100 max discount per order) and a lower-cap structure (Tk50–70 max discount per order) - across every tier and cohort, so the eventual budget decision could weigh reactivation strength against cost efficiency directly, rather than guessing at the trade-off.

What this modelling changed: the worst-case exposure across the matrix looked alarming in isolation - well over Tk100M under the higher-cap structure. Framed against the realistic 12.55–16% redemption range, the expected spend landed roughly an order of magnitude lower. Presenting both numbers together, instead of just the ask, was what got the program funded without a drawn-out negotiation.


08 — Execution Roadmap

A 12-week comms sequence, not a single blast.

Segmentation and offers only work if the delivery cadence gives users more than one reason to come back. I designed a 12-week rolling sequence that alternates between direct promo pushes, curated content collections, and cuisine-specific moments - so the same dormant user sees several different reasons to open the app, not the same discount code on repeat.

01
General re-engagement push
A broad "place an order" notification to re-establish app presence before any promo lands, so the first touch doesn't feel purely transactional.
02
Promo 1 launch
Segment-specific offers go live across Dhaka and Chattogram - four promo variants tuned to different MOV and usage-cap combinations depending on the receiving segment.
03
Promo 1 reminder
A reminder push for users who saw the first promo but hadn't redeemed it yet - recovering intent that didn't convert on the first touch.
04
Collection: Free Delivery
A curated in-app collection surfacing free-delivery restaurants, giving high-frequency-sensitive segments a low-friction reason to order without needing a discount code.
05
Promo 2
A second promo wave, timed roughly a month after the first so segments that missed the initial window get another entry point.
06
Collection: Fast Delivery
A speed-focused collection targeting users likely to be swayed by convenience rather than price - a different lever from discounting.
07
Collection: New on Pathao
Surfacing newly onboarded restaurant partners to give returning dormant users something genuinely new to discover, not just a repeat of what they left behind.
08
Cuisine collection: Fast Food
The first of two cuisine-specific collections, using purchase-history signals to personalise the reactivation moment around a cuisine the user is likely to want.
09
Cuisine collection: Biryani
A second cuisine-specific collection - biryani is one of the highest-affinity categories on the platform, used deliberately as a late-funnel pull.
10
Promo 3
A third and final scheduled promo wave, closing out the structured 12-week window while the program transitions into an always-on, trigger-based state for individual segments.

09 — Metrics

Twenty metrics across eight categories - because redemption rate alone lies.

North Star: the % of treated users whose RFM value improved after the campaign - not the redemption rate. A user can redeem a promo once and never return; a user whose recency and frequency genuinely improve is the actual product of a lifecycle program. I designed the full measurement framework around this distinction before launch.

CategoryMetricWhy it's on the dashboard
EngagementPN open rate, app engagement rate, promo utilisation rateThe funnel's first checkpoint - did the communication even land and get noticed before any behaviour could change?
ConversionOrder conversion rate; first-time conversion rate for non-food usersDistinguishes users who converted to an order from users who merely engaged with the message - and separately tracks whether the cross-sell into food for non-food users actually worked.
MonetaryAverage order value, campaign revenueThe direct commercial return on the promo spend - the number finance cares about most immediately.
RetentionRepeat purchase rate; post-campaign retention rateWhether a reactivated user placed one order and vanished again, or kept ordering after the promo incentive disappeared - the real test of whether the intervention worked.
Cohort ImprovementRecency, frequency, and monetary improvement rate; % of users with any RFM improvementThe North Star category - measures whether a user's underlying behaviour genuinely shifted, independent of any single order.
User Category TransitionPromotion to primary food user rate; demotion to non-food rate; lateral movement; transition success rateTracks the cross-sell objective specifically - are Secondary and Non-food users actually becoming Primary food users, or just placing an isolated promo order?
Cohort StabilityCohort stability rate; improvement-to-demotion ratioChecks the program isn't just shuffling users sideways - are more users improving tier than falling to a lower one?
RFM Distribution ShiftAverage RFM value increase; RFM segmentation retentionThe macro view - is the entire user-base distribution shifting up and to the right over time, or is the same 83% still sitting in Rust six months later?

10 — Risks

What could go wrong - and how I designed against it.

High
Training the dormant tail to only return for a discount
Aggressive 50%-off offers on the 200+ day cohort risk creating a base that orders exclusively on promo weeks and churns again the moment the code expires. Mitigated by: the post-campaign retention metric specifically isolating behaviour after the incentive disappears, and a deliberate mix of discount pushes with non-discount levers (free delivery, curated collections) so not every re-engagement moment is price-driven.
High
Budget exposure if redemption runs above the modelled average case
A 3.9M-user matrix with deep discounts on the largest segments carries real financial exposure if redemption behaves closer to the worst case than the average case. Mitigated by: hard usage caps per segment, MOV floors on every offer, and the three-scenario burn model built specifically to give finance an honest ceiling, not just a hopeful average.
Medium
Control holdout resentment or leakage
Users in held-out segments who notice peers receiving offers they don't could churn out of frustration, or word-of-mouth could partially "leak" promo codes across segments and contaminate the incrementality read. Mitigated by: keeping holdouts limited to already-organically-engaged segments least likely to notice or need the offer, and segment-specific promo codes rather than a shared code.
Medium
Seven-tier taxonomy adding coordination overhead
More segments means more variants for comms, engineering, and finance to track and QA before each send. Mitigated by: the plain-language tier naming convention specifically designed to reduce cross-team confusion, and grouping the 28-cell matrix into a small number of distinct treatment archetypes rather than 28 fully bespoke campaigns.
Low
Cuisine-specific collections underperforming generic promos
Personalised cuisine collections are a newer lever than straightforward discounting and could see lower engagement than expected. Mitigated by: sequencing them alongside proven discount waves rather than replacing them, so the roadmap doesn't depend entirely on an unproven tactic succeeding.

11 — Lessons

What building a lifecycle engine taught me that a single feature never would.

01
CLM work is a different kind of PM job - the "feature" is a decision framework, not a screen
There's no single UI to demo for this project - the deliverable is a scoring model, a 28-cell decision matrix, a budget model, and a measurement framework. My job was defining the rules that decide what millions of individual users experience, not designing any one experience directly. That's a materially different kind of ownership than shipping a screen, and it required thinking in populations and distributions rather than user flows.
02
The most important insight came from the distribution, not the average
If I'd only looked at average recency or average tier across the base, I'd have missed the real story entirely. Seeing that 83% of users sat in the lowest tier, and 78% were 200+ days dormant, reframed the whole program from "reward loyal users" to "this is fundamentally a reactivation problem at massive scale." Segment-level distributions, not blended averages, are where the real product decisions live.
03
Designing the control group is a product decision, not a data-science afterthought
It would have been easy to launch treatment everywhere and worry about measurement later. I designed the holdouts as part of the segmentation logic itself - deciding which specific segments to exclude, and why, before a single promo went out. That decision determines whether the retro six months later can say anything credible about incrementality, or just reports a redemption number nobody can act on.
04
Budget credibility comes from showing the worst case, not hiding it
My instinct going into the finance conversation was to lead with the realistic average-case number. Leading with the worst-case exposure first, then showing how redemption modelling brought it down to a defensible ask, built more trust than presenting only the number I wanted approved. Finance stakeholders fund plans they can see the edges of.
05
Measure the behaviour change, not the mechanism that triggered it
Redemption rate measures whether people used a discount code. It says nothing about whether they became a better long-term customer. Building cohort-improvement and tier-stability metrics into the framework from day one - not bolted on after a promo underperformed on redemption alone - was the decision that made this a lifecycle program instead of a discount campaign with extra reporting.
Appendix — The Evidence

Framework Spec Excerpts

User stories, acceptance criteria, and the segmentation-to-measurement pipeline as specified in the CLM program design.

Appendix A — User Stories
IDAs a…I want…So that…
US.1 Growth manager planning a retention campaign every user pre-classified into a recency and value segment I can target spend at the segments that need it instead of blasting the entire base uniformly
US.2 Dormant user who hasn't ordered food in over 200 days a compelling, low-friction offer that acknowledges I've been away re-entering the app to order food feels worth the switching cost back from habits I've formed elsewhere
US.3 Finance stakeholder approving campaign budget a modelled cost range across realistic and worst-case redemption scenarios I can approve spend against a defensible ceiling, not an optimistic single estimate
US.4 Product/growth lead reviewing the campaign after launch metrics on cohort migration and tier stability, not just redemption count I know whether the program changed user behaviour or just gave away margin to users who'd have ordered anyway
Appendix B — Key Acceptance Criteria
#CriteriaOwnerVerified by
AC.1 Every active user must be scored and placed into exactly one of the 28 recency x value-tier segments, with no unclassified users in the eligible base. Data / Growth QA: row count of scored users reconciles to full active-base count with zero nulls on tier or recency band
AC.2 Each segment's treatment - offer, MOV, usage cap, control/treatment status - must be resolvable from the treatment mapping without manual lookup at send time. Growth / CRM Config review: treatment mapping table validated against comms tooling before each scheduled send
AC.3 Burn projections must be produced for worst-case, average-case (~12.55% redemption), and good-case (~16% redemption) scenarios across both discount-cap structures before budget sign-off. Growth / Finance Finance review: all three scenarios present and reconciled against approved budget ceiling
AC.4 Control-holdout segments must be excluded from every promotional touchpoint for the full campaign window, with no cross-segment code leakage. CRM / Eng Audit: holdout segment IDs checked against every send list prior to dispatch
AC.5 All eight metric categories must report at segment level, not just campaign-aggregate level, so cohort migration is visible per tier and per recency band. Data / Analytics Dashboard review: each of the 28 segments individually selectable in the reporting view
Appendix C — Segmentation-to-Measurement Pipeline

How a raw order history becomes a targeted treatment, and how that treatment's impact is measured back into the model.

1
Raw order & usage data ingestion
Order history, spend, and cross-vertical app usage (rides, other services) pulled for every user in the active base to compute Recency, Frequency, and Monetary inputs.
2
RFM scoring & tier assignment
Recency bucketed into 4 bands. Frequency and Monetary combined into a composite score and mapped into 7 named value tiers, Diamond through Rust. Food-usage category (Primary / Secondary / Non-food) tagged per user.
3
28-segment matrix construction
Every user placed into one of 28 cells. Each cell resolved against the treatment mapping to determine control/treatment status, offer structure, and target RFM dimension.
4
Budget modelling & sign-off
Segment-level burn projected across three redemption scenarios and two discount-cap structures. Reconciled against approved budget before any send is scheduled.
5
12-week comms execution
Push notifications, promo drops, and curated collections dispatched on the rolling schedule, segment by segment, per the treatment mapping.
Segment-level measurement feeds the next cycle
Engagement, conversion, monetary, retention, cohort-improvement, transition, stability, and distribution-shift metrics computed per segment · Users re-scored on the next cycle and re-placed into the matrix · Treatment mapping refined based on what moved each segment and what didn't.