#nonprofit-cloud — Public Fediverse posts

Clean Data, Smart Flows: Automating Data Cleanup in Salesforce Nonprofit Cloud

I had the privilege of presenting at Nonprofit Dreamin, one of the most community-driven Salesforce events on the calendar. With a sold-out crowd of 300 participants, the energy in the room was exactly what you’d hope for when talking about technology that actually matters for mission-driven organizations. It was a great session, and the conversations that followed reminded me why this work matters. For everyone who attended, asked questions, or tracked me down afterward, thank you. Here’s a deeper look at everything we covered.

The Case for Clean Data in Nonprofit Cloud

Every Nonprofit wants to make decisions grounded in accurate, real-time data. But as any Salesforce professional knows, “accurate data” doesn’t just happen on its own. It requires deliberate architecture, thoughtful automation, and a clear understanding of which tools belong where.

In Salesforce Nonprofit Cloud (NPC), that challenge is multiplied. Built on the Salesforce Industries architecture, NPC introduces a purpose-built data model with Person Accounts, Gift Commitments, Gift Transactions, and volunteer management objects that all need to stay tightly synchronized. The good news? Salesforce Flow, especially with the addition of the Transform element, has become a powerful enough tool to handle both the data hygiene work and the complex calculations your fundraising and volunteer teams depend on, without touching your DPE credit limits.

This post covers two interconnected use cases: automating data sanitization for volunteer management and building advanced donor fulfillment calculations with Flow, including the new Transform element. Together, they demonstrate what’s possible when clean data and smart automation work in concert.

Why Clean Data Is the Non-Negotiable Starting Point

Before we get into calculations and check-in flows, let’s establish something foundational: none of this works without clean data.

In the Salesforce world, “clean data” means records that are accurate, consistent, and free of duplicates. For admins, this has always been best practice. But with the rise of AI Agents, autonomous programs that can execute real transactions inside your org, data quality has become a hard requirement. AI is only as good as what it’s grounded in. Garbage in, garbage out, and now that garbage can trigger a bad transaction at scale.

In NPC specifically, clean data is the backbone of reliable volunteer coordination, accurate donor reporting, and eventually, trustworthy AI-assisted fundraising. One of the most common, and most overlooked, data quality issues is mobile phone formatting.

Part 1: Automating Data Sanitization with Record-Triggered Flow

Volunteers check in using their last name and mobile phone number. That sounds simple until you realize that the same phone number can be stored dozens of different ways: (512) 555-0100, 512-555-0100, 5125550100, 512 555 0100. When a Get Records element tries to match on an exact value, any inconsistency breaks the lookup.

The fix is a record-triggered flow that strips all non-digit characters from the mobile phone field the moment a Person Account is created or updated.

Person Account

A person account is a Salesforce record type that combines Account and Contact into a single entity, allowing you to manage individuals like donors or volunteers without needing a separate business account record. NPC relies on Person Accounts as its primary constituent record.

The “Clean Mobile Phone” Flow

This flow runs when a Person Account is created, or when the mobile phone field is changed and is not blank. The sanitization logic uses a chained SUBSTITUTE formula that removes spaces, dashes, and parentheses in sequence, leaving only pure digits. The result: a consistent, matchable value in every record.

If you need flexibility, there are alternatives. Validation rules can reject improperly formatted entries at the point of save, preventing the problem before it’s created. Scheduled flows can run as a daily batch job to clean up any legacy data that snuck through before your automation was in place. For most organizations, a combination of all three provides the most airtight coverage.

Part 2: Reactive Screen Flows for Volunteer Check-In

Once your data is clean, you can build experiences that actually work. In NPC, volunteer management tracks jobs, positions, and shifts, and getting volunteers into the right slot quickly is a real operational challenge.

Rather than relying on a standard digital experience site, we built a custom screen flow that leverages reactive functionality: the ability for a screen to update dynamically based on user input without navigating to a new page.

Reactive Screen Flow

A reactive screen flow allows components on the same screen to communicate with each other in real time. A data table can update the moment a user types a search term or makes a selection, with no page reload.

How the Check-In Flow Works

The volunteer enters their last name and mobile phone number. Because we’ve already sanitized the phone field, the Get Records query finds an exact match reliably. If no match exists, a warning screen appears immediately.

From there, a data table displays available jobs, such as “Food Distribution.” Once the volunteer selects a job, a Screen Action triggers an auto-launched subflow in the background.

That subflow queries available shifts for that specific day and passes them back to a second data table on the same screen. The volunteer selects their shift and clicks Next, and the flow creates a Job Position Assignment record with a status of “Complete.” Clean, fast, no paper sign-in sheet required.

Part 3: Complex Donor Fulfillment Calculations with Flow and the Transform Element

With volunteers managed and data sanitized, let’s look at the other side of the NPC operation: donor management. Here, the goal is to give fundraising teams a real-time snapshot of donor health directly on the Account page.

Specifically, we want to calculate three things for each donor:

Current Year Gift Commitment: The donor’s pledge for the year. In NPC’s data model, this tracks promises rather than payments.

Current Year Paid Amount: The total actually received via Gift Transactions. A single commitment can have multiple transactions associated with it as the donor makes payments over time.

Fulfillment Rate and Membership Level: The percentage of the commitment that’s been paid, and a tiered classification (Gold, Silver, Bronze) based on actual payments.

Why Flow Instead of DPE?

NPC includes pre-built Data Processing Engine (DPE) calculations for Donor Gift Summary. Think of DPE as a mini-ETL tool built directly into Salesforce, designed to handle millions of records with joins, filters, and aggregations that would push a standard Flow to its governor limits. It’s powerful, but it comes with two significant constraints: a steep learning curve that many admins haven’t climbed yet, and a license-based DPE credit limit that can be exhausted quickly if calculations run in real time or too frequently.

Flow provides a low-code alternative that doesn’t count against those credits, making it the right choice for on-demand or daily updates across mid-sized datasets. The golden rule: always use the tool you already know if it fits the case at hand.

Step 1: The Auto-Launched Subflow

We start by building an Auto-Launched Flow to house all the calculation logic. Keeping the math in a subflow means the same logic can be triggered by a user button, a nightly schedule, or an automated event, without ever rebuilding it.

The flow takes three input variables: the Account ID we’re processing, a StartDate, and an EndDate. Formulas handle null inputs gracefully, defaulting to January 1st of the current year and today’s date respectively, so the flow still works if those values aren’t provided.

Two Get Records elements pull the data. The first retrieves Gift Commitments filtered by DonorId and EffectiveStartDate within the selected range. The second retrieves Gift Transactions for the same donor where Status is Paid and TransactionDate falls within range.

The Transform Element

This is where Flow Builder has meaningfully evolved. The Transform element allows you to map and aggregate data collections without the traditional Loop + Assignment pattern. Instead of iterating through every transaction record manually, we point the Transform element at the Gift Transactions collection, set the target to a currency variable, select Sum, and choose the Amount field. The element does the rest. Repeat the process for Gift Commitments.

This approach is bulkified by design and significantly easier to debug than a loop-based alternative.

Categorization via Formulas

A nested IF formula handles Membership Level assignment: Bronze for paid amounts under $50,000, Silver up to $100,000, and Gold above that. A separate formula calculates the Fulfillment Rate as a percentage. Both formulas include null checks to handle donors who have commitments but no transactions yet.

Step 2: The Screen Flow and Quick Action

The subflow handles all three rollups in a single execution: total paid amount, total commitment, and the derived fulfillment rate and membership tier. The Screen Flow itself grabs the Account ID from the page, passes it into the subflow, receives the calculated values back, and writes them to custom fields on the Account using an Update Records element. A Flow Message component displays a toast-style confirmation to the user when the calculation is complete.

Step 3: Nightly Automation via Scheduled Flow

A button is great for one-off checks. But data goes stale. The subflow architecture makes automation straightforward: a Schedule-Triggered Flow runs nightly at 8:00 PM, loops through all active donor Accounts, and calls the same subflow we built for the button. Every morning, the fundraising team logs in to dashboards and Account views that are already current.

Conclusion

Clean data and efficient automation are the engine of nonprofit effectiveness. Accurate volunteer check-ins mean accurate service records. Accurate service records mean accurate outcome data. And accurate outcome data is what allows organizations to apply for larger grants, deepen constituent relationships, and scale their mission year over year.

The same principle applies on the donor side. When gift fulfillment data is reliable and up to date, fundraising teams can have better conversations, identify at-risk donors earlier, and make the case for continued investment with confidence.

With NPC’s purpose-built data model and Flow’s growing capabilities, especially the Transform element, there has never been a better time to consolidate your automation strategy around tools your team already understands. The result is an org that’s not just manageable, but genuinely ready for whatever comes next, including AI.

Want to walk through these builds step by step? The Clean Data Playbook is available FREE on Flow Canvas Academy.

Explore related content:

Mastering Data Rollups in Nonprofit Cloud

What Nonprofits Taught Me About Building Salesforce for Humans, Not Just Systems

Salesforce NPSP vs Nonprofit Cloud Consultant Certifications

How the Salesforce Architecture Program Is Being Rebuilt with the Community

Mastering Data Rollups in Nonprofit Cloud

Every forward-thinking organization wants to base their business management decisions on intelligence derived from accurate, real-time data. However, as any Salesforce professional knows, “accurate data” is often the result of sophisticated background calculations and complex statistics. Depending on your specific Salesforce environment, the tool you choose for these calculations can vary wildly. In a standard Sales Cloud environment, you might reach for a simple Summary Report or a Roll-up Summary field. But when you move into the world of Salesforce Industries (like the new Nonprofit Cloud – NPC, aka Agentforce Nonprofit), the decision-making process becomes significantly more complex. Suddenly, you have a massive arsenal of tools: the Data Processing Engine (DPE), the Business Rules Engine (BRE), OmniStudio, and of course, Salesforce Flow.

My golden rule is this: Always use the tool you already know if it fits the case at hand. While advanced tools like DPE are powerful, they often come with steep learning curves and license-based limitations. In this tutorial, I’m going to show you how to perform complex donor fulfillment calculations using Flow and the new Transform element, writing that data directly to the Account record in a way that is efficient, scalable, and easy to maintain.

In this scenario, we want to provide our fundraising team with a clear snapshot of a donor’s health directly on their Account page. Specifically, we want to calculate:

Current Year Gift Commitment: In the Nonprofit Cloud data model, this represents a donor’s promise or pledge. For example, if a donor promises to pay $100,000 over the next year, that commitment is tracked here.

Current Year Paid Amount: Total amount actually received via transactions. Transactions represent the actual financial record of money received. A single Gift Commitment can have multiple paid Gift Transactions associated with it as the donor makes payments over time.

Fulfillment Rate: The percentage of the commitment that has been paid.

Membership Level: A tiered categorization (Gold, Silver, Bronze) based on their actual payments.

Why Flow Instead of DPE?

Nonprofit Cloud (NPC), built on the Salesforce Industries (formerly Vlocity) architecture, represents Salesforce’s modern reimagining for nonprofits. Unlike the legacy Nonprofit Success Pack (NPSP), NPC runs on the core Salesforce platform, leveraging Person Accounts and purpose-built objects designed to support high-scale fundraising and program management.

NPC includes pre-built Data Processing Engine (DPE) calculations for Donor Gift Summary. Think of DPE as a “mini-ETL” (Extract, Transform, Load) tool built directly into Salesforce. It is designed to handle massive datasets, millions of records, performing joins, filters, and aggregations that would typically cause a standard Flow to hit governor limits. While robust, it presents two significant limitations for many organizations:

1. Complexity: Customizing a DPE requires a deep understanding of data orchestration that many admins haven’t mastered yet.

2. Computational Limits: Your Salesforce license includes a specific number of “DPE Credits” or computational hours. If you run these calculations in real-time or too frequently, you can quickly exhaust your limits.

Flow provides a “Low-Code” alternative that is highly customizable and doesn’t count against your DPE hour limits, making it the perfect choice for on-demand or daily updates for mid-sized datasets.

Step 1: Building the Logic (The Auto-Launched Subflow)

We start by building an Auto-Launched Flow. By keeping the math in a subflow, we ensure that we can trigger the calculation from a button, a schedule, or even an automated trigger without ever having to rebuild the logic.

1. Defining Input Variables

We need three primary inputs to make this flow flexible:

• recordId: The Account ID we are currently processing.

• StartDate: The beginning of the date range (e.g., the start of the fiscal year).

• EndDate: The end of the date range (e.g., today).

Pro Tip: Use formulas to handle “Null” inputs. If the user doesn’t provide a StartDate, my formula defaults to January 1st of the current year using:

IF(ISBLANK({!StartDateVar}),DATE(YEAR({!$Flow.CurrentDate}),1,1),{!StartDateVar})

IF(ISBLANK({!EndDateVar}),{!$Flow.CurrentDate},{!EndDateVar})

2. Fetching the Data

We use two Get Records elements to gather our collections:

• Get Gift Commitments: We filter by the DonorId (matching our recordId) and ensure the EffectiveStartDate falls within our selected range.

• Get Gift Transactions: We filter for records for the same Donor where the Status is ‘Paid’ and the TransactionDate is within our range.

3. Aggregating with the Transform Element

The Transform element is a powerful addition to Flow Builder that allows you to map and aggregate data collections. It eliminates the need for the traditional “Loop + Assignment” pattern when calculating sums or counts, making your flows significantly more readable and efficient. This is where the magic happens. Instead of a loop, we add a Transform element.

• Source: The collection of Gift Transactions.

• Target: A currency (single) variable.

• Mapping: Connect the source collection to the target variable, select Sum, and choose the Amount field.

This method is “Bulkified” by nature and much easier to debug than traditional loops. We repeat this process for the Gift Commitments.

4. Categorization via Formulas

To determine the Membership Level, we use a Nested IF formula:

IF(ISNULL({!Sum_of_Paid_Transform}),"",IF({!Sum_of_Paid_Transform}<=50000,"Bronze",IF({!Sum_of_Paid_Transform}<=100000,"Silver","Gold")))

We also calculate the Fulfillment Rate as (number, not percentage):

100*({!Sum_of_Paid_Transform}/{!Sum_of_Commitments_Transform})

Step 2: Creating the User Interface (The Screen Flow)

Now that the logic is built, we need to expose it to the users. We create a simple Screen Flow and place it on the Account record page using a Quick Action.

1. Pass the ID: The Screen Flow automatically grabs the recordId from the page.

2. Call the Subflow: It passes that ID into our “Logic Subflow.”

3. Update the Account: The subflow returns the calculated values (Total Paid, Rate, Level). The Screen Flow then uses an Update Records element to save these values directly onto the custom fields on the Account.

4. The Success Message: We use the new Flow Message component to show a nice, “Toast-like” confirmation to the user that the calculation is complete.

Step 3: Automating with Scheduled Flows

While the “Calculate” button is great for one-off checks, you don’t want your data to go stale. This is the beauty of the subflow architecture.

We created a Schedule-Triggered Flow that runs every night at 8:00 PM.

• Object: Account

• Filter: All Active Donors.

• Action: It simply loops through the accounts and calls the same subflow we used for the button.

This ensures that every morning when the fundraising team logs in, their dashboards and Account views are perfectly up to date without them having to click a single button.

Advanced Considerations: Performance & Scalability

When deciding between real-time (Record-Triggered) and batch (Scheduled) processing, consider your data volume:

• Real-Time: If you trigger this every time a GiftTransaction is created, it provides the most “Live” data. However, this could have performance implications.

• Batch: Running this nightly is the safest and most efficient way to handle large volumes of data without impacting the user experience during business hours.

Troubleshooting Common Issues

• Null Values: If a donor has zero transactions, the Transform element might return a null. Always ensure your formulas handle null values.

• Currency Conversion: If your org uses Multi-Currency, ensure your Get Records and Transform elements are looking at the “Converted” currency fields to maintain accuracy across different regions.

Conclusion: The Power of Low-Code

The introduction of the Transform element in Flow Builder has significantly narrowed the gap between standard Flows and high-performance tools like the Data Processing Engine. For most Nonprofit Cloud and Industry users, Flow provides the perfect balance of ease of use and computational power.

By centralizing your logic in a subflow, you create a “single source of truth” for your calculations, whether they are triggered by a user, a schedule, or a system event. In Nonprofit Cloud, this approach is especially valuable, where fundraising, commitments, and transaction data must stay tightly aligned across multiple purpose-built objects. This not only makes your org easier to manage but also ensures that your business decisions are always backed by the most reliable data available.

[youtube https://www.youtube.com/watch?v=fUvb2a1mpEc?version=3&rel=1&showsearch=0&showinfo=1&iv_load_policy=1&fs=1&hl=en-US&autohide=2&wmode=transparent&w=640&h=360]

Explore related content:

The Ultimate Guide to the Salesforce Screen Flow File Preview Component

What Nonprofits Taught Me About Building Salesforce for Humans, Not Just Systems

New Trailhead Badge: Accessible Salesforce Customizations