nav[aria-label="Primary Navigation"] { padding: 0; & ul { list-style: none; width: 100%; display: flex; flex-direction: row; justify-content: start; align-items: start; gap: 30px; padding: 0; & li { margin: 0; } & ul li { list-style: none; } } }

Collecting Team Affinity Data

charissechang

Hi everyone!

I’m working on a project that relies 100% on explicit user data (no implicit/behavioral signals), and I’m trying to determine the best way to capture Team Affinity using Braze tools/features.

My main goal is to figure out the best channel (Email, Push, or In-App Message)—or a mix of all—to collect explicit team preference data, then use that data for downstream targeting and personalization.

Goal:
Assign each user a preferred team (their “team affinity”) based completely on explicit data they provide — not inferred behavior.

What I’m trying to solve:
I want to build a system where, once a user selects their preferred team, Braze can:

Capture and store that explicit preference reliably
Update or overwrite it if the user changes their selection later
Allow future campaigns/segments/targeting to easily reference this “team affinity” value
Trigger follow-ups or automations based on a user’s declared team

What I need help understanding:
What is the recommended Braze setup for:

Storing team affinity (Custom Attributes? Subscription Groups? Catalogs?)
Capturing the explicit selection (e.g., In-App Message button actions, email deep links, or other methods)
Updating the stored value cleanly when the user changes teams
Making the system scalable when there are many teams
Ensuring the affinity value can be used instantly for segmentation and personalization

If anyone has examples, best practices, or a tried-and-true workflow for managing explicit-preference data like this, I’d love to learn from you.

Thank you!

Find more posts tagged with

Mobile App Push

In-App Message

Comments

TedScott

Hi,

Assuming there are many teams and one "preferred team" (which might change over time), saving is as a user attribute is a good path.

https://www.braze.com/docs/developer_guide/analytics/setting_user_attributes
https://www.braze.com/docs/api/objects_filters/user_attributes_object

You can collect this data using web form, landing page, user profile page, content card, in-app message, as well as email where a click leads to the form / landing page.

As far as which collection point gets the best results, some a/b testing might be in order (I find a combination of channels is best), and of course, Braze intelligent timing (if you have enough send history) can help.
https://www.braze.com/docs/user_guide/brazeai/intelligence/intelligent_channel

Nirnay

Hello @charissechang

For your use case, I’d recommend Custom Attributes - they’re the most scalable and flexible way to store team affinity, especially as your list of possible teams grows.

I’ve broken down answers to each of your questions individually.

--> Storing Team Affinity:

For your use case, Custom Attributes are the most scalable and flexible option.

Why not Subscription Groups?

Subscription Groups are binary (subscribed/unsubscribed) and capped at ~350 per workspace. They aren’t meant to store open-ended preference data, especially if you might have dozens or hundreds of teams.

Why not Catalogs?

Catalogs are excellent for storing metadata about teams (logos, colors, stats), but they cannot be used for segmentation, Canvas entry criteria, action paths, or triggered logic. So they’re not well suited for storing the actual user preference.

Why Custom Attributes?

Can store a single team as a string
Can be easily expanded into an array or object for multiple favourites
Fully supported in segmentation, Canvases, filters, Liquid personalisation
Can be overwritten or updated at any time
Unlimited scalability (millions of possible team values)

One attribute like team_affinity can handle all current and future needs.

--> Capturing the Explicit Selection :

Because this relies completely on explicit user input, multichannel collection is ideal.

1️⃣ In-App Messages (IAM)

The most direct method. IAM buttons can “Set User Attribute” instantly.

Examples:

Modal with team options
Survey IAM
“Choose Your Team” slideup

2️⃣ Email

Send users to a landing page (external or Braze’s native landing page) where they choose their team.

Once selected, update the custom attribute via your app/website using the SDK or REST API.

You can also use a persistent global email component (header/footer) in your emails (if your header/footer is a global component)

“Tell us your favorite team for personalised updates.” Once they click this, they are redirected to a landing page.

Use Liquid to hide it once the value is set.

3️⃣ Push Notifications

Great for nudging users back into the app or preference center where the selection is made.

A multichannel strategy increases capture rates while reducing drop-off.

Updating the Stored Value When a User Changes Teams

With Custom Attributes, this is clean and straightforward:

team_affinity: "Warriors" → "Bulls"

Braze simply overwrites the previous value.

--> Tracking Change History (Important Note)

Custom Attribute updates are not automatically logged as user events.

Unlike Subscription Groups - which generate currents enagements events like subscribed or unsubscribed—Custom Attributes do not create a built-in audit trail.

If you want to track historical changes (e.g., who changed teams and when), consider:

A Dedicated Canvas

Create a Canvas that triggers on team_affinity changing.

Inside the Canvas:

Fire a Webhook
Send the onew values with a timestamp
Store it in your external database

Scalability Across Many Teams

Because the preference is stored in a single Custom Attribute, this architecture scales indefinitely - even with hundreds or thousands of teams.

If you need additional team metadata (colours, conference, logo), pair the attribute with a Braze Catalog for lookup.

--> Real-Time Segmentation & Personalisation

Custom Attribute updates occur in real time, which enables:

Instant segmentation
Canvas entry when team_affinity changes
Action paths based on the chosen team
Liquid personalisation
Dynamic images/text based on team selected
Audience paths and message variations

Example Liquid:

Welcome, {{custom_attribute.${team_affinity}}} fan!

Everything updates as soon as the user makes a choice.

Just something to be aware of:

"Subscription Group changes don’t count toward data points, whereas Custom Attribute updates do. It shouldn’t impact your overall strategy, but it’s worth noting for data point planning.”

This approach is based on my experience and on what I understood from your use case.
Hope this helps!