Pipeline context variables are input variables that MoveData passes into your Lightning Flows during pipeline execution. They provide information about the current processing state, the type of record being processed, and records created in earlier stages.

Understanding these variables is essential when you build custom flows that need to apply different logic depending on the record type, access records from earlier stages, or read notification data from the source platform.

Variable categories#

MoveData pipeline context variables fall into four categories:

For flow command variables (Cancel, Break, Continue, PostUpsert) and execution context variables (DuplicateCheck, IsActor), see the flow command reference and flow variable reference.

Stage context variables#

Each pipeline stage can process multiple record types. For example, the contact stage processes donors, fundraisers, tribute contacts, and matched gift contacts. Stage context variables tell your flow which type of record is being processed in the current iteration.

Donation pipeline#

Account stage context#

The account stage runs once for each account type present in the notification.

Contact stage context#

The contact stage runs once for each contact type present in the notification.

Campaign stage context#

The campaign stage runs once for each campaign in the hierarchy. A peer-to-peer fundraising notification can contain multiple campaigns (event, team, fundraiser page).

Recurring and donation stages#

The recurring and donation stages do not have stage-specific context variables because they each process a single record type per notification. The recurring stage only runs when the notification contains a recurring donation.

Commerce pipeline#

The commerce pipeline shares the Account, Contact, and Campaign stages (and their context variables) with the donation pipeline.

The Catalogue, Order, and Order Item stages do not define additional stage context variables. They each process a single record type per iteration.

Record variables#

Every pipeline stage passes a record variable into your flows. This variable represents the Salesforce SObject record that MoveData is creating or updating for the current stage.

The Record variable#

The SObject type of Record depends on the stage and the extension:

In mapping flows, Record is available for both input and output. You read existing field values and assign new values to it. MoveData upserts the record after the mapping flows complete.

In post-upsert flows, Record is input-only. The record has already been saved to Salesforce and includes the Salesforce record ID.

Alt record variables#

When you change the SObject type for a stage (either through static metadata or a dynamic SObject flow), MoveData renames the record variable to prevent type conflicts in existing flows.

The renamed variable follows the pattern {Stage}RecordAlt. For example:

• If the Campaign stage SObject is changed from Campaign to Opportunity, the record variable in downstream flows becomes CampaignRecordAlt.
• If the Contact stage SObject is changed from Contact to Lead, the record variable becomes ContactRecordAlt.

The Alt naming applies not only within the current stage's flows but also when the record is passed as a cross-stage variable to later stages.

Fieldset scope#

The fields available on the Record variable are determined by the fieldset configured for the stage. Only fields included in the fieldset are queried from Salesforce when an existing record is matched.

If you need to read or write a field that is not on the record variable, add it to the relevant fieldset in Salesforce Setup.

Cross-stage record variables#

As MoveData processes each pipeline stage, records created or matched in earlier stages become available as input variables in later stages. This enables your flows to reference related records without querying Salesforce.

Donation pipeline cross-stage variables#

The following table shows which cross-stage record variables are available at each donation pipeline stage.

Commerce pipeline cross-stage variables#

The commerce pipeline shares Account, Contact, and Campaign cross-stage variables with the donation pipeline. It adds the following commerce-specific variables:

How cross-stage variables work#

MoveData populates cross-stage variables automatically. You do not need to configure them.

When you create a custom flow for a later stage (such as a donation mapping flow), add the cross-stage variable as an input variable with the exact name and type shown above. MoveData passes the record from the earlier stage into your flow.

Example: Accessing the donor contact in a donation mapping flow

1. Open your donation mapping flow in Flow Builder.
2. Create a new variable:
   - Name: DonorContact
   - Type: Record (Single)
   - Object: Contact
   - Available for input: Yes
3. Use DonorContact.Id or DonorContact.AccountId
   in your flow logic.

Notification and platform variables#

Every flow in the pipeline receives variables containing data from the source platform notification. These variables provide the raw data that your flows map to Salesforce fields.

Platform identification#

Notification data variables#

MoveData transforms each notification into a standardised set of variables based on the schema (donation or commerce). These notification variables are available as inputs to every flow in the pipeline.

Common notification data variables include:

For a detailed reference of notification variables, see the relevant schema documentation:

• Donation schema overview
• Commerce schema overview

Configuration variables#

Configuration variables follow the Config_ naming convention and control pipeline behaviour. They can be set through the MoveData settings interface or through a configuration flow at stage 0 of the pipeline.

Common configuration variables include:

Configuration variables are available in every flow across all stages after stage 0 completes.

Variable lifetime and scope#

Understanding when variables are available helps you design flows that reference the correct data.

Within a stage#

Across stages#

Variables from earlier stages are carried forward automatically. A flow in the donation stage has access to records from the account, contact, campaign, and recurring stages.

Variables do not flow backwards. A flow in the account stage cannot access records from the contact or campaign stages because those stages have not yet executed.

Account → Contact → Campaign → Recurring → Donation
  │          │          │           │           │
  │          │          │           │           └─ Has: ParentAccount, DonorContact,
  │          │          │           │              DonationCampaign, RecurringRecord
  │          │          │           │
  │          │          │           └─ Has: ParentAccount, DonorContact,
  │          │          │              DonationCampaign
  │          │          │
  │          │          └─ Has: ParentAccount, CampaignContact
  │          │
  │          └─ Has: ParentAccount
  │
  └─ No cross-stage variables (first stage)

How to use pipeline context variables in a flow#

To use any pipeline context variable in your flow:

1. Open the relevant flow in Salesforce Flow Builder.
2. Create a new variable with the exact name listed in this reference.
3. Set the variable's Type to match the type shown (Text, Boolean, Number, or Record).
4. For record-typed variables, set the Object to the correct SObject type.
5. Enable the variable as Available for input.
6. Use the variable in your flow logic (decisions, assignments, formulas).

Other resources#

• Flow variable reference for DuplicateCheck and IsActor context variables.
• Flow command reference for commands that control flow execution.
• Pipeline overview for an introduction to MoveData pipelines.
• Donation pipeline for the donation-specific pipeline stages and context.
• Commerce pipeline for the commerce-specific pipeline stages.
• Conditional business rules based on source platform for a worked example using the Platform variable.