RFM
Segments customers by recency, frequency and monetary value, overlaid with a behavioural trend, using a transparent 13-rule tree a marketer can read and defend.
An explainable value-and-behaviour segmentation, live in Braze from day one, that the whole stack builds on.
Where this sits
Braze is the hub of the activation layer and better at that than anything else we would put there. It is not a data platform: no joins, no window functions, and profile event retention materially shorter than a warehouse, so a median gap between purchases or an exposure-normalised activity rate cannot be expressed in a segment. So the model runs upstream and hands Braze a short, named contract rather than its logic. Plan the policy upstream, resolve the instance in Braze.
What crosses into Braze
The five-band value axis. In Braze it is the dial inside a journey: contact frequency cap, offer richness, budget.
One of twelve named states, the output of the rule tree. In Braze it chooses which journey a customer enters.
Which of the 13 rules fired. This is what makes a change of state explainable after the fact rather than an argument.
The next product to introduce, computed from category coverage rather than a raw breadth count. Personalisation inside a journey, not a new segment.
Marks customers whose recency and frequency are structurally pinned by a standing order, so they route to their own track instead of pinning to the top cell.
Silence measured against the customer's own rhythm rather than an absolute day count. It fires retention, and it refreshes weekly so it lands before the customer leaves the active window.
Assigned upstream on a stable hash of the customer id. Braze only ever excludes on it; the assignment logic never crosses, which is what keeps the control clean at programme level.
7 attributes, and only these. Everything else stays where it is computed.
Computed upstream
- Recency, frequency, monetary, breadth and tenure, with frequency and monetary scored as rates over exposed time, so someone who joined mid-window is not penalised against someone who was there all year.
- Monetary as habitual intensity, the typical spend per active week, rather than a twelve-month total that a single large event would otherwise dominate.
- Both recency reads, from the same data in the same place: the fixed-window lifecycle stage a marketer expects, and the personal cadence that is accurate. Either or both can cross as attributes, but neither is recomputed in Braze, so exactly one system ever decides whether a customer is active.
- A personal cadence per customer, the median gap between purchases, which is what lapse is measured against instead of a fixed window.
- The 13-rule classification tree, evaluated in priority order, so every customer lands in exactly one behavioural segment and the rule that fired is recorded.
- The value tier from a recency-decayed value measure, plus the previous tier, so migration between tiers can be read over time rather than inferred.
- A snapshot per customer per run. Without it you can only measure response, never whether anyone's trajectory changed, and you cannot retrofit a baseline you never took.
Resolved in Braze
- Which of the permitted messages goes out, on which channel, at what moment, given what the customer just did.
- Journey orchestration: triggers, waits, branching and exits. The segment selects the journey, the tier sets its intensity.
- Content, rendering and personalisation at send time, reading these attributes through Liquid.
- Frequency capping and quiet hours, enforcing the caps the tier sets.
- Sends, delivery and engagement. This data originates in Braze and exists nowhere else until Currents streams it out, so Braze is the source of truth for it and nothing else is.
- Send-time and channel optimisation, because that is where we have chosen to put it. Two optimisers fighting is worse than either alone, so the choice is written down.
What deliberately does not cross
- Identity resolution
- Braze has external IDs, aliases and merge on identify, not an identity graph. No householding, no survivorship, and no way to reconcile one person who exists as three profiles because they signed up on web, on the app and through a competition form.
- The segment and tier definitions
- They need a version history, an owner and a test. Braze gets the result, not the logic. Every rule that moves into a journey condition leaves version control, the test suite, the diff and the audit trail behind it.
- Anything needing a join, a window function or twelve months of history
- A median gap between purchases, an exposure-normalised rate, a concentration index. None of it fits in a segment, and profile retention is shorter than a warehouse anyway, so the window cannot be rebuilt there.
- Holdout assignment
- It has to be stable, person level and outside the tool. Campaign holdouts leak: someone held out of one campaign still receives the other eleven, so every campaign is measured against a control that is being marketed to.
- Business outcome and lift
- Braze answers whether a campaign worked in channel, and it is authoritative there. It cannot see margin, offline behaviour or the counterfactual, which is a different question.
- The test record
- Braze knows what was sent. It does not know the hypothesis, who was held back, the result or the decision that followed, and that set is what makes a programme cumulative rather than a series of one-offs.
- The plan
- A contact plan per cohort, with an author and a test history, that both layers read. A plan buried in warehouse logic is one marketers cannot challenge, and a plan nobody can argue with is a configuration.
Hard suppressions sit in both layers on purpose. Consent, regulatory and safeguarding rules are enforced upstream so the mistake never reaches Braze, and again at send so it never reaches the customer. Defence in depth, worth the duplication.
Cadence. A monthly full recompute with a weekly recency and lapse refresh, so lapse risk fires inside the window rather than after it. Braze consumes both axes and recomputes neither.
The portability test. If Braze were replaced tomorrow, the segmentation, the definitions, the holdouts and the test record would all survive, because none of them live there. That is the test for anything calling itself an architecture.
Who it's for
Any brand with transaction history and a Braze workspace that wants an explainable segmentation live now, not a black box in six months. The natural first engagement.
The engagement
What you get
- RFM+BT segmentation model and the 13-rule classification logic, documented
- Segment and tier attributes written to Braze per customer
- Segment definitions, thresholds and a marketer-readable playbook
- Starter journeys and audience recipes per segment
What Fuse does
- Audit the transaction data and agree the recency, frequency and monetary thresholds with you
- Build the RFM+BT model and the 13-rule classification against your data
- Write the segment and tier attributes into Braze per customer on an agreed refresh cadence
- Document the logic and hand over a marketer-readable playbook and starter journeys
- Validate segment sizes and stability, and tune the bands with you before go-live
What we need from you
Data & access
- Purchase / transaction history per customer
- Braze workspace access
Your responsibilities
- Provide transaction / purchase history at customer-record grain
- Provide a Braze workspace with an API key and an agreed attribute namespace
- Nominate a marketing owner to agree thresholds and sign off the segment definitions
Outcomes and proof
- The whole base classified into actionable value and behaviour segments from day one
- Segment-targeted campaigns replace batch-and-blast, measured against a holdout
- Baselines for revenue per segment and for migration between tiers over time
- Lift proven per campaign with a held-out control, honest from the first send
Assumptions
- Transaction records can be tied to a stable customer identifier
- Roughly 12 months of history is available to set stable thresholds
- Braze is the activation channel and attributes are the hand-off point
Out of scope
- Data warehouse build or ETL from source systems (assumes a usable feed exists)
- Predictive scoring such as churn or pLTV, which are separate services that build on RFM
- Creative, campaign build and channel execution beyond the starter journeys