Launching a Journey in Braze vs Salesforce Marketing Cloud: A Product Waitlist Example

Home / MarTech / Braze vs SFMC
Daniel Robles Published SFMC Braze

Someone joins the waitlist for a new trail shoe. A confirmation should arrive in seconds, then a short series: a sneak peek for people who opted in to marketing, and a launch-day email the moment it goes on sale. It is about the simplest journey there is, and it is a good way to see how differently Salesforce Marketing Cloud and Braze think. This article builds the same launch on both platforms, step by step, with no CDP in the middle: your form, your backend, and the marketing platform. The difference that matters is not the UI. In SFMC the sign-up becomes a row in a data extension. In Braze it becomes an event on a person. That difference is the thread I will pull on in a follow-up about events versus data extensions, and it connects to Object Oriented Marketing and Marketing Eventing.

1. The scenario

A product launch waitlist for the Ridge 2 trail shoe, with a landing page form. Three fields, one checkbox, and one rule that trips teams up: joining the waitlist cannot depend on opting in to marketing. The confirmation and the launch notice are what the person asked for; anything else that promotes something is marketing and needs consent.

FieldExampleNotes
first_nameAnaPersonalization only
emailana@example.comRequired to join and to send the launch notice
size10.5Optional; lets the launch email show stock in their size
marketing_opt_intrue / falseOptional, never pre-checked, stored with a timestamp

The form posts to your backend, never straight to the marketing platform. The backend validates and rate-limits the sign-up (launches attract bots and resellers), dedupes it, writes it to your own database, generates a stable customer ID if the person has no account, and then hands a copy to SFMC or Braze. The platform is a consumer of the sign-up, not its system of record.

ONE FORM, TWO PLATFORMS, NO CDPformwaitlist sign-upbackendform handlerSALESFORCE MARKETING CLOUD1 OAuth tokeninstalled package2 API Event/interaction/v1/eventsSignups DEa row per sign-upJourneyentry: API Eventemail%%FirstName%%setup: data extension, installed package, event definition, journey, re-entry rulesBRAZE1 REST API keyusers.track scope2 /users/trackattributes + eventuser profileevent on thetimelineCanvasaction-based entryemail{{first_name}}setup: API key, Canvas with a custom-event entryHover or tap any box. Orange: the sign-up becomes a row in a table. Blue: the sign-up becomes a fact on a person.
The same sign-up, launched into a journey on each platform. Hover or tap any box for the request, the setting or the gotcha behind it.

2. Salesforce Marketing Cloud: a journey fed by a data extension

The modern SFMC pattern for “something happened, start a journey” is a Journey Builder API Event entry source. Your backend calls one endpoint and the contact enters the journey. Under the hood, that event is an insert: Journey Builder writes the payload into a data extension and the journey reads from it. So the table comes first.

Step 1. Create the entry data extension

Name: Waitlist_SignupsSendable: ContactKey → Subscriber KeyRetention: delete rows after 180 days
FieldTypeLengthKeyRequiredNotes
SignupIdText50primary keyrequiredOne row per sign-up, so a person can join more than one waitlist
ContactKeyText254requiredYour stable customer ID, not the email
EmailAddressEmailAddressrequiredWhere the email goes
FirstNameText100optionalPersonalization
ShoeSizeText10optionalSize-aware launch email
WaitlistIdText50requiredWhich launch, e.g. ridge2_launch
OptInBooleanrequiredMarketing consent from the checkbox
JoinedAtDaterequiredDefault value: current date

Every field the form will ever send must exist, with a type and a length, before the first sign-up. The primary key is SignupId, not ContactKey, so a person can join more than one waitlist. ContactKey should be your stable customer ID, not the email address: contact keys are permanent, emails are not.

Step 2. Create an installed package and get a token

An admin creates a server-to-server API integration under Setup, Apps, Installed Packages, with Journeys (read, execute) and Data Extensions (read, write) scopes. Your backend trades the client ID and secret for a short-lived token and caches it:

POST https://{subdomain}.auth.marketingcloudapis.com/v2/token
Content-Type: application/json

{
  "grant_type": "client_credentials",
  "client_id": "<installed package client id>",
  "client_secret": "<secret from your vault>",
  "account_id": "<business unit MID>"
}

Step 3. Build the journey on an API Event entry source

In Journey Builder, add an API Event entry source, bind it to Waitlist_Signups, and copy the generated EventDefinitionKey. Build the flow: confirmation email, wait three days, a decision split on OptIn for the sneak peek, then a wait until launch day and the launch email. Set re-entry to no re-entry, so each person goes through once per waitlist, and activate it.

Step 4. Fire the event from your backend

POST https://{subdomain}.rest.marketingcloudapis.com/interaction/v1/events
Authorization: Bearer <access_token>
Content-Type: application/json

{
  "ContactKey": "c_20931",
  "EventDefinitionKey": "APIEvent-7c1e2f",
  "Data": {
    "SignupId": "wl_55120",
    "ContactKey": "c_20931",
    "EmailAddress": "ana@example.com",
    "FirstName": "Ana",
    "ShoeSize": "10.5",
    "WaitlistId": "ridge2_launch",
    "OptIn": true
  }
}

-> 201 { "eventInstanceId": "8f6e..." }

Every key inside Data must match a field in the data extension. An unknown field, a value longer than its column or a missing required field fails the call. A valid call against a paused or unpublished journey version still writes the row, and nobody enters, which is the bug teams find the morning after launch.

Step 5. Personalize from the row

Hi {{Event.APIEvent-7c1e2f."FirstName"}},

%%[ SET @size = AttributeValue("ShoeSize") ]%%
You're on the Ridge 2 waitlist%%[ IF NOT Empty(@size) THEN ]%% in size %%=v(@size)=%%%%[ ENDIF ]%%.
We will email you the moment it launches.
%%[ IF AttributeValue("OptIn") == "True" THEN ]%%
  Watch for a sneak peek before launch day.
%%[ ENDIF ]%%

Emails read the row through Journey Data ({{Event.APIEvent-...}}) or AMPscript. The confirmation and launch notice are what the person asked for; the sneak peek is promotional, so it needs a commercial send classification and must respect the subscriber's status.

3. Braze: a Canvas triggered by an event

Braze has no table to create. Your backend tells Braze two things in one request: what is true about the person (attributes) and what just happened (an event). A Canvas listens for the event.

Step 1. Create a REST API key

Under Settings, APIs and Identifiers, create a key with the users.track permission and store it in your vault. There is no token exchange; the key goes in the Authorization header.

Step 2. Build the Canvas on an action-based entry

Set the entry schedule to action-based, with the trigger “performs custom event waitlist_joined”, optionally filtered on the property waitlist_id = ridge2_launch. Add the confirmation message, a three-day delay, an audience path on email subscription state for the sneak peek, a delay until launch day and the launch message. Turn re-eligibility off, and add exit criteria for leaving the waitlist or buying the shoe. Launch it.

Step 3. Send the sign-up from your backend

POST https://rest.iad-01.braze.com/users/track
Authorization: Bearer <REST API key>
Content-Type: application/json

{
  "attributes": [{
    "external_id": "c_20931",
    "email": "ana@example.com",
    "first_name": "Ana",
    "shoe_size": "10.5",
    "email_subscribe": "opted_in"
  }],
  "events": [{
    "external_id": "c_20931",
    "name": "waitlist_joined",
    "time": "2026-11-14T16:05:00Z",
    "properties": {
      "waitlist_id": "ridge2_launch",
      "signup_id": "wl_55120",
      "size": "10.5",
      "opt_in": true,
      "source": "instagram_ad"
    }
  }]
}

-> 201 { "attributes_processed": 1, "events_processed": 1, "message": "success" }

Attributes and event names that do not exist yet are created on first use. Only set email_subscribe to opted_in when the box was checked; otherwise leave it alone so you do not overwrite an existing preference. If people on the waitlist have no account and you would rather not mint IDs, Braze can also identify users by email or by a user alias in the same endpoint.

Step 4. Personalize from the event

Hi {{${first_name} | default: 'there'}},

You're on the Ridge 2 waitlist{% if canvas_entry_properties.${size} %} in size {{canvas_entry_properties.${size}}}{% endif %}.
We will email you the moment it launches.
{% if canvas_entry_properties.${opt_in} == true %}
  Watch for a sneak peek before launch day.
{% endif %}

canvas_entry_properties exposes the properties of the event that started the Canvas, for every step of it. The rest comes from the profile.

WHAT YOU BUILD BEFORE THE FIRST SIGN-UPSFMC1sendable DE2installed package3contact key plan4API Event source5journey + emails6re-entry + activate6 steps | schema designed up front | sign-up stored as a rowBraze1REST API key2Canvas, event entry3subscription state3 steps | schema created on first use | sign-up stored on the person
What has to exist before the first sign-up can enter a journey. Hover or tap any step.

4. Side by side

SFMCBraze
What the backend calls/v2/token, then /interaction/v1/events/users/track
Where the sign-up landsA row in Waitlist_SignupsAn event on the user profile
SchemaDesigned up front: fields, types, lengths, keyCreated on first use; manage with blocklists and naming rules
TriggerAPI Event entry source bound to one data extensionAction-based entry on a custom event
PersonalizationJourney Data or AMPscript reading the rowLiquid reading the profile and canvas_entry_properties
Repeat sign-upsRe-entry setting plus a primary key that allows duplicatesRe-eligibility setting; every sign-up is another event
ConsentSubscriber status, publication lists, send classificationSubscription state and subscription groups on the profile
Reuse laterSQL query activity joining tables on a scheduleSegment filter on the event and its properties
Typical failureJourney not active: row written, nobody entersEvent name typo: event recorded, Canvas never fires

Neither path is hard once it is set up. The difference is what you have built when you are done. In SFMC you have a table that exists because this campaign exists. In Braze you have a fact about a person that any future campaign can use.

5. After the launch: using the sign-up again

A week later, someone asks a normal question: which waitlist members bought the shoe after it launched? This is where the two models really diverge.

SFMC: join tables on a schedule

-- Automation Studio, SQL Query activity, nightly
-- Target: Waitlist_Members_Who_Bought (overwrite)
SELECT w.ContactKey, w.EmailAddress, COUNT(o.OrderId) AS Orders
FROM Waitlist_Signups w
JOIN Orders_Nightly_DE o ON o.ContactKey = w.ContactKey
WHERE w.WaitlistId = 'ridge2_launch'
  AND o.ProductId = 'ridge2'
  AND o.OrderDate >= w.JoinedAt
GROUP BY w.ContactKey, w.EmailAddress

Plus a target data extension, an automation to run it nightly, and the knowledge that the answer is as fresh as last night's run. The next launch gets a new data extension, and this query gets copied and edited.

Braze: a segment

Segment: Ridge 2 waitlist members who bought
  Custom event  waitlist_joined
    property    waitlist_id = ridge2_launch
    performed   at least 1 time in the last 90 days
  AND
  Purchased     product ridge2 in the last 30 days

No new table, no schedule, and it updates as events arrive. The next launch sends the same event with a different waitlist_id.

A ROW IN A TABLEA FACT ON A PERSONSignupIdContactKeyWaitlistJoinedAtwl_55120c_20931ridge211-14wl_55121c_31877ridge211-14wl_55122c_20931trailpack11-15wl_55123c_40112ridge211-15Waitlist_SignupsWaitlist_Summit3_DELaunch_Signups_Final_v2Orders_Nightly_DEexternal_id: c_20931 Ana ana@example.com2026-11-14 waitlist_joinedridge2_launch size 10.52026-11-15 waitlist_joinedtrailpack_launch2026-11-20 email_clickedsneak peek2026-12-02 purchaseridge2 10.5 $1492027-03-02 waitlist_joinedsummit3_launch
Where the sign-up ends up. Hover or tap the rows, the tables and the events.

6. Gotchas on each side

SFMC

  • Use a stable ID as ContactKey, not the email address. You cannot change a contact key later, and All Contacts is what you are billed on.
  • Activate the right version. Editing an active journey creates a new draft version; events go to whatever version is active.
  • Match the schema exactly. Send the exact field names, respect the lengths, and use consistent boolean and date formats.
  • Set retention on the sign-up data extension, or it quietly becomes a permanent copy of everyone's PII.
  • Cache the token. Requesting a new one per sign-up is slow and can hit limits during a launch spike.

Braze

  • Name events like facts (waitlist_joined), keep one name across launches, and put the campaign in a property.
  • Watch data points. Attribute updates and custom events count toward your contract; do not resend unchanged attributes on every sign-up.
  • Batch during spikes. /users/track accepts up to 75 events, attributes and purchases each per request.
  • Do not overwrite consent. Only send email_subscribe when the person actually opted in.
  • Prefer the action-based entry over the API-triggered Canvas endpoint. The event can start this Canvas and every other use of the sign-up; an API trigger only starts this one.

7. What this sets up

Strip away the UI and the two launches differ in one way. SFMC asks you to design a table, write a row into it and point a journey at the table. Braze asks you to state a fact about a person and let anything that cares about that fact react to it.

Data extensions made sense when the email platform was the database: nightly files, batch sends, one table per use case. They are the reason SFMC programs accumulate hundreds of tables nobody owns, SQL activities that join them back together, and journeys that are only as fresh as the last import. Events and profiles are how modern platforms, warehouses and event-driven architectures already work. In a follow-up article I will make that case directly: why sending communications from events is replacing data extensions, and how to migrate an SFMC program that is built on them.

Related: Object Oriented Marketing, Marketing Eventing, AMPscript 101 and Liquid 101.

Sources

Product names, IDs, keys and payload values are illustrative.