Speedrunning loyalty without leaving Braze

Traditional loyalty? It's kind of a mess. Points, tiers, clunky dashboards, it all sounds good in theory, but in practice? Slow, disconnected, and most customers don’t care. But here’s the good news: you don’t need a full-blown loyalty platform to drive retention. What you really need is the ability to experiment quickly, with incentives, timing, messaging, and rules, using tools that already talk to each other.

In this post, I break down how to run loyalty-style experiments right inside Braze with Voucherify powering your incentives behind the scenes. Treat it as a guide on how to go from “should we do loyalty?” to “we’re already testing five ways to boost LTV.” (And yes, the title says without leaving Braze, but if you're going to step out, make it worth it.)

Build loyalty with the stack you already have

Here’s how to reframe loyalty as a set of composable touchpoints, not a monolithic program:

• Map loyalty-worthy touchpoints and key moments
• Use Braze’s Data Platform to fuel segmentation and targeting
• Orchestrate flows with Canvas
• Add AI Decisioning to personalize per user
• Pull real-time incentives with Connected Content
• Execute and validate incentive logic with Voucherify
  

1. Identify and map loyalty-worthy touchpoints

Before you build anything, you need a clear view of when loyalty actually happens. Not loyalty as a status (“Gold Tier”), but loyalty as behavior: second purchases, high-margin baskets, repeat orders in short windows, referrals, app reactivations, and so on.

This starts with mapping out your customer journey, but this time, through the lens of retention experiments, not static programs. Ask yourself:

• Where are the drop-offs after first purchase?
• What behaviors signal a likely churn?
• When are customers most likely to upgrade, reorder, refer, or lapse?

Then define what loyalty-worthy looks like for your brand. Some common triggers:

• First to second purchase (critical moment for new buyer retention)
• High AOV or premium SKU purchase (signal of willingness to spend)
• 3+ purchases in 90 days (eligible for “priority” perks or offers)

Use Braze to model these as event or attribute-based triggers, then route users into journeys via Canvas.

2. Set up your data warehouse & CDP in Braze

To map loyalty‑worthy journeys, your foundation is real‑time, unified customer data. Here’s how to connect the dots.

• Centralize your first-party data in a warehouse like Snowflake – link user IDs, purchases, events, and more. This becomes the backbone for segmentation and targeting in Braze.
• Sync your warehouse to Braze to activate fields like LTV, last_purchase_date, or custom scores. Use them to trigger Canvas flows the moment users hit key thresholds.
• Build dynamic segments based on RFM or behavior and plug them into loyalty journeys. For example, “High Spend, No Activity” becomes an entry point for a reactivation campaign.
• Keep it real-time so Braze can respond immediately when a customer takes action or doesn’t. No more waiting on batch updates to trigger the right message.

3. Orchestrate loyalty journeys with Canvas

Orchestrate loyalty journeys with Canvas

Once you’ve mapped out your loyalty-worthy touchpoints and connected your data sources, Braze Canvas is where it all comes together. Canvas isn’t just a journey builder, flexible enough for simple nudges or full retention flows. It can also become your experimentation framework. Control groups and variants let you measure lift, not just activity, so every loyalty idea can be validated before it’s scaled.

Start with one loyalty moment. For example:

• Trigger: User makes their second purchase.
• Flow: Wait 3 days – Send “early access” message – Wait 7 days – If no purchase, send a limited-time offer – Exit if redeemed.

Canvas gives you full control:

• Entry criteria: Event triggers, segment entry, or API calls.
• Control groups: Automatically exclude a slice of users to measure lift.
• Variant testing: A/B test incentives, copy, channels, or timing inside the same flow.
• Channel orchestration: Use the right mix: email, push, in-app, SMS, webhook, depending on user behavior and preferences.
• Exit conditions: Remove users once they qualify for a different journey or complete the desired action.

4. Add AI decisioning (optional)

In loyalty, not every user deserves the same reward and that’s where Braze’s AI Agent Console changes the game. Instead of fixed rules (“3 purchases = $5 off”), you can evaluate loyalty behaviors dynamically, one user at a time. Here’s how it works in practice:

• Set up an AI agent inside Braze to answer a loyalty question like: “Has this user earned a reward? If yes, what kind and how much?”‍
• Feed in loyalty signals: purchase frequency, order value, time since last engagement, offer redemption history, etc. All from your Braze profile fields or real-time event data.
• Run the agent in Canvas: Drop it into your post-purchase, reactivation, or milestone journeys. The agent returns a decision: “yes, reward them with $3 off” or “no, no incentive needed”, plus reasoning you can log or test against.

It’s loyalty personalization at the decision layer: reward only when it matters, preserve margin where it doesn’t, and scale your strategy without bloated tiers or static logic.

5. Connected Content

Connected Content lets you call external APIs directly from your Braze messages and Canvas flows, pulling in real-time loyalty data at the moment of send. Static promo codes and pre-loaded rewards don’t cut it when you’re aiming for personalized, responsive loyalty experiences. 

With Connected Content, you can:

• Fetch live promo codes, point balances, or rewards.
• Show personalized incentives based on the customer’s current profile or journey stage.
• Avoid sending expired or invalid rewards by querying fresh data on each send.
  

In your Braze message, use Liquid to make a request to your loyalty engine. For example:

{% connected_content "https://api.voucherify.io/v1/loyalties/cards/{{custom_attribute.loyalty_card}}"   
:method get   
:headers { "X-App-Id": "APP_ID", "X-App-Token": "API_KEY" }   
:content_type application/json   
:save result %}

Then render the response dynamically: Hi {{${first_name}}}, you have {{ result.loyalty_card.balance }} points available.

Use code {{ result.reward.code }} to redeem your reward today.

Every message reflects the current state of that user’s loyalty data, no batch syncs or manual updates required.

• Pair with Braze’s Canvases to inject rewards at precise moments: post-purchase, reactivation, milestones.
• Use Braze’s custom attributes to save pulled data in user profiles to run follow-up logic or segmentation, e.g., a promo code for subsequent reminders.

Let’s see how Connected Content works in practice: https://app.demoboost.com/playback/mih79z9b 

6. Braze custom attributes

If Connected Content handles real-time lookups at send time, Braze custom attributes are how loyalty data sticks. They let you store the outcomes of incentive logic directly on the user profile, so Braze can remember what happened and act on it later. 

Whenever something meaningful happens in Voucherify, including points awarded, tier changes, referral rewards, or promo code creation and redemption, those updates can be pushed back to Braze and saved as custom attributes on the user profile like loyalty_points_balance or current_tier.

Once stored, this data becomes native to Braze. You’re no longer dependent on a live API call to know where a user stands, as Braze already has the context.

That opens up a new class of loyalty flows:

• Segment users based on stored loyalty state, like “Gold tier with unused rewards.”
• Trigger Canvas journeys when attributes change, such as tier upgrades or milestone thresholds.
• Personalize messages using Liquid without calling external APIs every time.

This works especially well alongside Voucherify’s Distributions. Connected Content pulls data at send time, while Distributions push updates proactively. 

The moment something changes in Voucherify, Braze receives the update, user profiles refresh, and active journeys stay in sync automatically. Take a look: https://app.demoboost.com/playback/mizqk523 

Where Braze orchestrates, Voucherify executes

Braze is your journey builder, it knows when to talk, where to reach users, and how to shape the flow. But when it comes to the logic behind incentives: who qualifies, what they get, how it’s validated, and what happens next, that’s Voucherify’s job.

Here’s how Voucherify handles everything behind the scenes to make your loyalty strategy secure, observable, and attributable. 

1. Incentive generation, validation & redemption

Every loyalty message needs logic behind it. What exactly is the offer? Who qualifies? Has it been redeemed? Is it still valid? 

Here’s what that looks like:

• Generation: Voucherify creates unique codes, loyalty points, wallet IDs, or referral rewards based on predefined rules. Each offer is tied to real business logic, not static templates.
  
• Validation: Before an offer is shown or redeemed, Voucherify checks all conditions: is the customer eligible? Has it expired? Are usage caps hit? Is it stackable? All enforced through metadata, segmentation, and custom logic.
  
• Redemption: When a customer clicks “use offer,” Voucherify runs the redemption logic, deducting balances, marking codes as used, or applying the right discount. It works across channels (ecom, app, POS) and updates Braze via custom attributes or Connected Content.
  

2. Discount formulas for controlled loyalty logic

Voucherify gives you a powerful layer of logic with discount formulas, so you can encode rules directly into the incentive itself. Think of them as programmable safety rails that automatically adjust based on custom data like cart value, customer segment, or location.

This means your loyalty logic isn’t fully dependent on orchestration. You can push high-trust offers through Braze, knowing Voucherify will enforce the incentive rules at redemption time.

To see how this works in practice, take a look at the demo: https://app.demoboost.com/playback/miy7oc3m 

It walks through a full end-to-end flow: a dynamic discount formula that returns different values per country, validation rules that control when the incentive applies, and a Braze campaign targeting the right audience.

At send time, Braze makes a Connected Content call. Voucherify generates a unique code, assigns it to the customer, and returns it straight into the email. The customer profile is created automatically, metadata is stored, and the incentive is fully attributable from issue to redemption. No pre-generated codes or manual synching needed.

3. Validation limits for safe experimentation

Launching hundreds of promo experiments? That’s smart. Losing money on unchecked redemptions? Not so much.

Voucherify gives you programmable safety nets:

• Per-user or segment-based limits.
• Budget ceilings and blackout windows.
• Redemption rules tied to metadata like product type, channel, or location.

Rules are great on paper, but seeing them fire in real time is better. Here’s a fast look at how Voucherify handles eligibility checks, start dates, stackability, and error handling without any extra work from your Braze flow: https://app.demoboost.com/playback/miyfubw9 

4. Full incentive lifecycle & attribution

Braze knows when to send an offer, but it doesn’t know what happens next. Did the customer use it? Did it drive a repeat purchase? Was it shared, ignored, or misused? With full-lifecycle tracking, Voucherify gives you:

• Offer-level attribution: See which campaign, message, or Canvas flow led to each redemption.
• Real-time status updates: Track issued, redeemed, expired, and active rewards in the moment so Braze messages always reflect live incentive states.
• Promo code lookups & search: Let your support or CRM teams instantly find, resend, or deactivate codes without developer help.
• Approvals: Add review gates for high-value or high-risk campaigns, no rogue discounts or budget surprises.
• Promo management: Filter, pause, or clone campaigns by team, region, or brand.

You’ve sent the offer. Now the real story begins. Here’s how Voucherify keeps you in control with live tracking, budget caps, and clean attribution that flows straight back into Braze: https://app.demoboost.com/playback/miyfw542 

Summary

Loyalty shouldn’t be a multi-year platform decision. It should be a system of experiments you can run, measure, and iterate on today.

With Braze as your CEP and Voucherify as your Incentives Engine, you get:

• A loyalty alternative built for experimentation, not rigid programs.
• Tools that optimize for revenue, not points earned.
• Real-time orchestration that supports humans and shopping agents alike.