Braze

Braze Customer Engagement Platform

Expert-level guidance for Braze — auditing, building, and optimizing Canvases, campaigns, segments, data architecture, and cross-channel messaging.

Install

git clone https://github.com/thatrebeccarae/claude-marketing.git && cp -r claude-marketing/skills/braze ~/.claude/skills/

Core Capabilities

Canvas Auditing & Design

• Audit existing Canvases for logic errors, timing issues, and missed opportunities
• Design multi-step, multi-channel Canvases (email, push, SMS, in-app, Content Cards, webhook)
• Implement Canvas Flow features: Action Paths, Audience Paths, Experiment Paths, Decision Splits
• Review entry schedules, exception events, re-eligibility, and rate limiting

Segmentation & Targeting

• Build segments using Braze's filter system (user attributes, custom events, purchase behavior, engagement)
• Design segment extensions for complex queries (event property filters, nested AND/OR logic)
• Implement predictive audiences (Predictive Churn, Predictive Purchases)
• Connected Audience sync from external CDPs (Segment, mParticle, Amplitude)

Campaign Strategy

• Plan cross-channel campaigns: email, push, SMS, in-app messages, Content Cards, webhooks
• A/B and multivariate testing with Intelligent Selection
• Personalization with Liquid templating, Connected Content, and Catalogs
• Frequency capping and Intelligent Timing optimization

Data Architecture

• Design custom event and attribute schemas
• Implement Currents data export (to Snowflake, BigQuery, S3, Mixpanel)
• Plan data migration from other platforms (Klaviyo, Iterable, Salesforce MC)
• API integration patterns (REST API, SDK implementation)

Deliverability & Compliance

• Email: SPF, DKIM, DMARC, IP warming schedules
• Push: Token management, provisional authorization, opt-in strategies
• SMS: Short code vs long code, compliance (TCPA, CTIA), opt-in management
• GDPR/CCPA data handling and consent management

Key Benchmarks

Essential Canvas Checklist

1. Onboarding — Multi-step cross-channel (push opt-in prompt, email welcome, in-app tutorial) 2. Activation — Drive key actions in first 7 days (feature adoption, profile completion) 3. Re-engagement — Target lapsed users (7d, 14d, 30d inactivity tiers) 4. Transactional — Order confirmations, shipping updates, receipts (use Transactional API) 5. Promotional — Scheduled campaigns with audience targeting and frequency caps 6. Abandoned Cart / Browse — Trigger-based with exception events for conversion 7. Winback — Long-term lapsed users (60d, 90d, 120d) 8. Feature Announcement — Targeted by segment, channel preference, and platform 9. NPS / Feedback — Post-interaction surveys via in-app or email 10. Sunset — Suppress unengaged to protect deliverability

Workflow: Full Braze Audit

When asked to audit a Braze workspace:

1. Canvas & Campaign Inventory — List all active Canvases and campaigns, identify gaps 2. Channel Coverage — Map which channels are active (email, push, SMS, in-app, Content Cards) 3. Segmentation Review — Evaluate segment definitions, overlap, and growth 4. Data Architecture — Custom events, attributes, schema consistency, data freshness 5. Personalization — Liquid usage, Connected Content calls, Catalog implementation 6. Performance Metrics — Channel-level KPIs, Canvas step conversion rates, variant performance 7. Deliverability — Email reputation, push token health, SMS compliance 8. Frequency & Fatigue — Global frequency caps, quiet hours, Intelligent Timing usage 9. Integration Health — SDK version, Currents export, CDP sync, webhook reliability 10. Recommendations — Prioritized by impact with estimated effort (Quick Win / Medium / Large)

Braze vs Klaviyo Context

When working with teams migrating or comparing:

• Braze excels at: Cross-channel orchestration, mobile-first (push, in-app), enterprise scale, real-time event streaming
• Klaviyo excels at: E-commerce focus, simpler setup, Shopify-native, strong email/SMS for DTC
• Key migration consideration: Braze's event/attribute model is more flexible but requires upfront schema design

How to Use This Skill

Ask me questions like:

• "Audit my Braze Canvases and identify gaps"
• "Design an onboarding Canvas for a mobile app"
• "Help me plan a migration from Klaviyo to Braze"
• "What's the best data architecture for a SaaS product in Braze?"
• "My push opt-in rates are low — help me design an opt-in strategy"
• "Build a re-engagement Canvas with Experiment Paths"
• "Plan IP warming for a new Braze workspace"

For detailed Braze data model, Liquid reference, API endpoints, and Canvas patterns, see REFERENCE.md.

Braze Skill — Examples

Example 1: Full Workspace Audit

User Request: "Audit our Braze workspace. We have about 2M users, running email and push but feel like we're not using the platform fully."

Analysis Steps: 1. Inventory all active Canvases and campaigns — map lifecycle coverage against the Essential Canvas Checklist 2. Assess channel coverage — identify which channels (email, push, SMS, in-app, Content Cards) are active vs. available but unused 3. Review segmentation strategy — check for segment overlap, stale segments, and missing behavioral segments 4. Audit data architecture — evaluate custom event naming consistency, attribute usage, and data freshness (last updated timestamps) 5. Pull performance metrics by channel and benchmark against industry standards

Sample Output:

Canvas & Campaign Inventory

Lifecycle Coverage Gaps

Channel Utilization

Prioritized Recommendations

---

Example 2: Onboarding Canvas Design

User Request: "Design an onboarding Canvas for our mobile app. We want to drive push opt-in, send a welcome email, and guide users through key features with in-app messages."

Analysis Steps: 1. Define entry criteria and schedule — action-based on account_created event 2. Map the multi-channel journey — push opt-in prompt, email welcome, in-app tutorial sequence 3. Design Action Paths for branching based on user behavior (opted in vs. not, completed tutorial vs. not) 4. Set timing delays and Intelligent Timing windows 5. Define exception events and exit criteria (e.g., completed all onboarding milestones)

Sample Output:

Canvas Flow

Entry: Action-Based → account_created event
│
├─ [Delay: 2 minutes]
│
├─ [Message: In-App] Push opt-in primer
│   "Enable notifications to get personalized updates"
│   (Educate before system prompt)
│
├─ [Delay: 1 hour]
│
├─ [Action Paths — 24h window]
│   ├── Push Opted In → Path A
│   └── Everyone Else → Path B
│
│   Path A (Push + Email):
│   ├─ [Message: Push] "Welcome! Here's your first tip..."
│   ├─ [Delay: 4 hours]
│   ├─ [Message: Email] Welcome email with 3 key features
│   ├─ [Delay: 1 day]
│   ├─ [Action Paths — 48h window]
│   │   ├── Completed Feature 1 → Feature 2 nudge (push)
│   │   └── Everyone Else → Feature 1 reminder (push + in-app)
│   └─ ...
│
│   Path B (Email + In-App only):
│   ├─ [Message: Email] Welcome email with push opt-in CTA
│   ├─ [Delay: 1 day]
│   ├─ [Message: In-App] Feature 1 tutorial
│   ├─ [Delay: 2 days]
│   └─ [Message: In-App] Push opt-in re-prompt
│
└─ [Exception Event: completed_onboarding] → Exit Canvas

Expected Performance

Settings

• Re-eligibility: No (one-time onboarding)
• Rate limiting: None (time-sensitive)
• Exception event: completed_onboarding custom event
• Quiet hours: 10 PM - 8 AM user local time
• Entry limit: None

---

Example 3: Re-engagement Canvas

User Request: "Build a re-engagement Canvas. We're losing users after the first month and need to bring them back with tiered urgency."

Analysis Steps: 1. Define inactivity tiers — 7-day, 14-day, and 30-day since last session 2. Design channel preferences per tier — lighter touch early, more aggressive later 3. Implement Experiment Paths to test messaging approaches (incentive vs. value reminder vs. social proof) 4. Set exception events for users who return mid-Canvas 5. Define sunset criteria for users who don't respond after all tiers

Sample Output:

Canvas Flow

Entry: Scheduled (daily at 10 AM UTC)
Audience: Last Session > 7 days ago AND Last Session < 60 days ago
│
├─ [Audience Paths]
│   ├── 7-13 days inactive → Tier 1 (Gentle Nudge)
│   ├── 14-29 days inactive → Tier 2 (Value Reminder)
│   └── 30-59 days inactive → Tier 3 (Last Chance)
│
│   Tier 1 — Gentle Nudge:
│   ├─ [Decision Split: Push Opted In?]
│   │   ├── Yes → [Message: Push] "We miss you! Here's what's new..."
│   │   └── No → [Message: Email] "Here's what you've been missing"
│   ├─ [Delay: 3 days]
│   ├─ [Action Paths — 72h]
│   │   ├── Session Started → [User Update] Set re_engaged = true → Exit
│   │   └── Everyone Else → Continue to Tier 2
│   └─ ...
│
│   Tier 2 — Value Reminder:
│   ├─ [Experiment Paths]
│   │   ├── Variant A (40%): Personalized content recap email
│   │   ├── Variant B (40%): Social proof ("12K users loved this feature")
│   │   └── Holdout (20%): No message
│   ├─ [Delay: 5 days]
│   ├─ [Message: In-App] (queued for next session) Feature highlight
│   └─ [Action Paths — 7 days]
│       ├── Session Started → Exit
│       └── Everyone Else → Continue to Tier 3
│
│   Tier 3 — Last Chance:
│   ├─ [Message: Email] "Before you go..." with incentive
│   ├─ [Delay: 3 days]
│   ├─ [Message: Push] Final nudge with urgency
│   ├─ [Delay: 7 days]
│   └─ [User Update] Set lifecycle_stage = "dormant" → Exit
│
└─ [Exception Event: session_start] → Exit Canvas at any point

Experiment Path Configuration (Tier 2)

Winner: Variant A (content recap) at 95% confidence. Incremental lift: +8.3pp over holdout.

Expected Overall Impact

---

Example 4: Data Architecture Review

User Request: "Review our Braze data architecture. We have 47 custom events and 83 custom attributes and I think it's gotten messy. Help us clean it up."

Analysis Steps: 1. Export the custom event and attribute list — categorize by domain (user profile, behavior, transaction, engagement) 2. Identify naming inconsistencies (camelCase vs. snake_case, abbreviations, duplicates) 3. Assess event property coverage — are properties being passed consistently? 4. Check data freshness — when were attributes last updated? Are any stale? 5. Recommend a normalized schema with naming conventions and deprecation plan

Sample Output:

Naming Consistency Audit

Event Schema Assessment

Data Freshness

Recommended Schema (Normalized)

Naming Convention: snake_case, {domain}_{action}_{object}

Prioritized Recommendations

---

Example 5: Push Notification Strategy

User Request: "Our push opt-in rate is 28% on iOS and we know it should be higher. Help us design an opt-in optimization strategy."

Analysis Steps: 1. Benchmark current opt-in rate against industry averages (iOS median: 42-50%) 2. Audit the current opt-in flow — when is the system prompt triggered? Is there a primer? 3. Design a provisional authorization strategy (iOS 12+) to capture quiet push first 4. Plan a multi-touchpoint opt-in strategy across the user journey 5. Define measurement framework for tracking opt-in lift

Sample Output:

Current State Assessment

Root Cause Analysis

1. System prompt fires on first launch — Users haven't experienced value yet, default to "Don't Allow" 2. No pre-permission primer — No in-app screen explaining push value before iOS system dialog 3. No re-prompting — Users who initially decline are never re-asked 4. No provisional authorization — Missing the "quiet push" fallback for iOS 12+

Recommended Opt-In Flow

First Session:
├─ [iOS 12+] Enable Provisional Authorization (quiet push)
│   User automatically receives quiet notifications in Notification Center
│   No prompt needed — builds habit before explicit opt-in
│
├─ [After Value Moment — e.g., first purchase, first saved item]
│   Show in-app primer screen:
│   "Get notified when your saved items go on sale"
│   [Enable Notifications] → trigger system prompt
│   [Not Now] → flag for re-prompt later
│
├─ [7 days later, if still provisional/declined]
│   In-app message: "You have 3 unread updates"
│   Contextual CTA to enable full notifications
│
└─ [30 days later, if still declined]
    Settings deep-link prompt during high-intent moment

Rich Push Best Practices

Projected Impact

---

Example 6: Klaviyo to Braze Migration Plan

User Request: "We're migrating from Klaviyo to Braze. We have 500K profiles, 12 Flows, and heavy Shopify integration. Help me plan the migration."

Analysis Steps: 1. Map Klaviyo data model to Braze — profiles, events, lists/segments, Flows to Canvases 2. Design the event schema translation — Klaviyo's Shopify events to Braze custom events 3. Plan the channel migration sequence — which channels cut over first? 4. Build the parallel-run timeline — both platforms active during transition 5. Define rollback criteria and success metrics

Sample Output:

Data Model Mapping

Event Schema Translation

Flow-to-Canvas Migration

Migration Timeline

Parallel Run Rules

• Never send the same user the same message from both platforms — use suppression segments
• Braze sends to new users (signed up after SDK integration)
• Klaviyo sends to existing users until Canvas equivalents are validated
• Monitor: delivery rates, open rates, and spam complaints on both platforms daily

Rollback Criteria

• Email delivery rate drops below 95% on Braze
• Spam complaint rate exceeds 0.1%
• Revenue per email drops >20% compared to Klaviyo baseline

---

Example 7: Deliverability & IP Warming

User Request: "We just set up a new Braze workspace with dedicated IPs. We have 800K email subscribers. Plan our IP warming schedule and monitoring framework."

Analysis Steps: 1. Assess email list health — engagement recency, hard bounces, spam traps 2. Build a tiered warming schedule — start with most engaged, gradually expand 3. Design the monitoring dashboard — key metrics to watch daily 4. Plan fallback strategy if deliverability drops during warming 5. Set up authentication (SPF, DKIM, DMARC) verification checklist

Sample Output:

Pre-Warming Checklist

List Segmentation for Warming

IP Warming Schedule

Daily Monitoring Dashboard

ISP-Specific Notes

Fallback Protocol

If any RED metric triggers: 1. Immediately reduce volume to last-known-good level 2. Investigate — check for spam trap hits, content issues, authentication failures 3. Wait 48 hours at reduced volume before attempting to scale again 4. If persistent — contact Braze deliverability team and ISP postmaster support

---

Common Analysis Patterns

Pattern: Canvas Performance Review

For each active Canvas:
1. Pull 30-day performance by step
2. Identify drop-off points (>50% exit between steps)
3. Compare variant performance (if Experiment Paths exist)
4. Check exception event trigger rate
5. Benchmark against channel-level KPIs

Pattern: Segment Health Check

For each active segment:
1. Current size and 30-day growth trend
2. Overlap with other segments (>60% overlap = consolidation candidate)
3. Filter complexity (>5 filters = review for Segment Extension)
4. Usage count (which Canvases/campaigns reference this segment?)
5. Reachability by channel (what % of segment is push/email/SMS reachable?)

Pattern: Channel Mix Optimization

1. Map reachability: % of users reachable per channel
2. Calculate channel-level conversion rates
3. Identify channel preference by segment (which channel drives action?)
4. Model frequency caps per channel
5. Recommend optimal channel sequence for key Canvases

Pattern: Data Quality Audit

1. List all custom events — check naming convention consistency
2. List all custom attributes — check for stale (>90d since update) and unused
3. Verify event properties are passed consistently (no missing required fields)
4. Check for PII in custom attributes that shouldn't be there
5. Validate external_id coverage (% of profiles with external_id vs. anonymous)

---

Pro Tips

Braze Reference

Data Model

Users (Profiles)

• external_id — Primary identifier (from your system)
• braze_id — Braze-assigned internal ID
• email — Email address (for email channel)
• phone — Phone number with country code (for SMS/WhatsApp)
• push_tokens — Device tokens for push notifications
• Standard Attributes — first_name, last_name, email, phone, gender, dob, country, city, language, time_zone
• Custom Attributes — Any key-value pair (string, number, boolean, array, date, object)
• Custom Events — Timestamped actions with optional properties

Events & Attributes

Standard Events

• Purchase — With product_id, currency, price, quantity
• Session Start / Session End — App session tracking
• Push Notification Open — Push engagement
• Email Open / Email Click — Email engagement

Custom Events

{
  "name": "added_to_cart",
  "time": "2024-01-15T10:30:00Z",
  "properties": {
    "product_id": "SKU123",
    "product_name": "Widget Pro",
    "price": 49.99,
    "category": "electronics"
  }
}

Subscription States

• Email: opted_in, subscribed (default), unsubscribed
• Push: opted_in, subscribed, unsubscribed
• SMS: subscribed, unsubscribed (requires explicit opt-in)
• Subscription Groups — Granular topic-based preferences

Canvas Flow Reference

Entry Schedule Types

Canvas Steps

Message Step

• Send email, push, SMS, in-app, Content Card, or webhook
• Supports Intelligent Timing, rate limiting, quiet hours
• A/B testing within step (up to 8 variants)

Action Paths

Branch users based on actions taken within a time window:

Action Paths
├── Purchased (within 3 days) → Thank you path
├── Added to Cart (within 3 days) → Nudge path
└── Everyone Else → Re-engage path

Audience Paths

Branch by user attributes/segments at a point in time:

Audience Paths
├── VIP Customers → Premium offer
├── New Customers → Welcome discount
└── Everyone Else → Standard message

Experiment Paths

A/B/n testing with statistical significance tracking:

• Winner auto-selection based on open rate, click rate, conversion, or revenue
• Configurable confidence level and holdout group

Decision Split

Binary yes/no filter on user attributes or behaviors

Delay

• Fixed time delay (hours, days)
• Until specific day/time
• Intelligent Timing (per-user optimal time)

User Update

Modify user attributes or subscription status within Canvas

Canvas Settings

• Re-eligibility — Can users re-enter? After how long?
• Rate limiting — Max messages per minute
• Frequency capping — Max messages per channel per time period (global setting)
• Exception events — Exit Canvas early if event occurs (e.g., user converts)
• Entry limits — Max users entering per schedule

Segmentation Reference

Filter Categories

• User Profile — Standard and custom attributes
• Engagement — Email/push/SMS interactions, session recency
• Purchase — Purchase history, product, total spend
• Custom Events — Event occurrence, count, property values
• Retargeting — Clicked card, received campaign, in Canvas step
• Technology — App version, device model, OS, carrier
• Location — Country, city, most recent location
• Testing — A/B test membership, random bucket number

Segment Extensions (Advanced)

For complex queries beyond standard filters:

• Event property filtering (e.g., "purchased product where category = electronics")
• Nested AND/OR logic
• Time-windowed event counts
• Regex matching on string properties

Predictive Suite

• Predictive Churn — Likelihood to churn score (0-100)
• Predictive Purchases — Likelihood to purchase score (0-100)
• Both require 30+ days of data and sufficient user base

Liquid Templating Reference

Basic Variables

{{${first_name} | default: "there"}}
{{${email}}}
{{custom_attribute.${loyalty_tier}}}

Conditional Logic

{% if ${first_name} != blank %}
  Hi {{${first_name}}},
{% else %}
  Hi there,
{% endif %}

Connected Content (Dynamic API Calls)

{% connected_content https://api.example.com/recommendations?user={{${user_id}}} :save recs %}
{% if recs.products.size > 0 %}
  Check out: {{recs.products[0].name}}
{% endif %}

Catalogs (Built-in Product Data)

{% catalog_items your_catalog_name {{custom_attribute.${favorite_product_id}}} %}
{{items[0].name}} - {{items[0].price}}

Aborting Messages

{% if ${email_subscribe} == "unsubscribed" %}
  {% abort_message("User unsubscribed") %}
{% endif %}

Date Formatting

{{${date_of_birth} | date: "%B %d"}}
{{ "now" | date: "%Y-%m-%d" }}

API Reference

Base URLs

REST API:  https://rest.iad-01.braze.com  (US-01)
           https://rest.iad-02.braze.com  (US-02)
           https://rest.fra-01.braze.eu   (EU-01)
SDK:       sdk.iad-01.braze.com (varies by instance)

Authentication

Authorization: Bearer {REST_API_KEY}

Key Endpoints

User Data

POST /users/track          # Send events, attributes, purchases
POST /users/identify       # Alias to external_id
POST /users/delete         # Delete users (GDPR)
POST /users/export/ids     # Export user data
POST /users/export/segment # Export segment

Messaging

POST /messages/send              # Immediate send
POST /messages/schedule/create   # Scheduled send
POST /campaigns/trigger/send     # API-triggered campaign
POST /canvas/trigger/send        # API-triggered Canvas

Catalogs

POST /catalogs                    # Create catalog
POST /catalogs/{name}/items       # Add items
PUT  /catalogs/{name}/items/{id}  # Update item

Subscription Groups

POST /subscription/status/set     # Update subscription
GET  /subscription/status/get     # Check subscription

/users/track Example

{
  "attributes": [{
    "external_id": "user123",
    "first_name": "Jane",
    "custom_attribute_key": "custom_value"
  }],
  "events": [{
    "external_id": "user123",
    "name": "viewed_product",
    "time": "2024-01-15T10:30:00Z",
    "properties": {"product_id": "SKU123"}
  }],
  "purchases": [{
    "external_id": "user123",
    "product_id": "SKU123",
    "currency": "USD",
    "price": 49.99,
    "time": "2024-01-15T10:35:00Z"
  }]
}

Currents (Data Export)

Supported Destinations

• Amazon S3, Google Cloud Storage, Azure Blob
• Snowflake, BigQuery, Databricks
• Mixpanel, Amplitude, Segment
• Custom webhook

Event Types Exported

• Message engagement (sends, deliveries, opens, clicks, bounces)
• User behavior (sessions, custom events, purchases)
• Subscription changes
• Campaign/Canvas enrollment and conversion

Data Format

• Avro format (default)
• JSON lines (configurable)
• Partitioned by event type and date

Channel-Specific Reference

Push Notifications

• iOS: Requires APNs certificate/key, provisional authorization available (iOS 12+)
• Android: FCM server key required
• Web: Service worker + VAPID keys
• Rich push: Images (2:1 ratio), action buttons (up to 4), custom sounds
• TTL (Time to Live): Default 30 days, configurable per message

In-App Messages

• Types: Slideup, modal, full-screen, custom HTML
• Triggers: Session start, custom event, push click
• Priority: Can stack, configure display priority
• Dark mode: Automatic support with color tokens

Content Cards

• Types: Banner, captioned image, classic (icon + text)
• Persistence: Stay in feed until dismissed or expired
• Personalization: Liquid + Connected Content supported
• Analytics: Impressions, clicks, dismissals

Email

• Drag-and-drop editor or custom HTML
• Dynamic content with Liquid/Connected Content
• AMP for Email support
• Link aliasing for click tracking
• Preference center (built-in or custom)

SMS/MMS

• Short code, long code, or alphanumeric sender ID
• Keyword processing (STOP, HELP, custom)
• Link shortening with tracking
• MMS: Images, GIFs, vCards

IP Warming Schedule

Monitor: Delivery rate >97%, bounce rate <3%, spam complaint <0.08%.