Process Builder and Workflow Rules officially reached end of support on December 31, 2025. This isn’t just another Salesforce announcement – it fundamentally changes how you build automation.
Flow Builder is now your only supported declarative automation tool. If you’re still running legacy Process Builders, you’re using tools Salesforce no longer maintains. Any bugs won’t be fixed. Any security issues won’t be patched.
The bigger shift? Spring ’26 introduced AI-powered Flow building through Agentforce. You can now create and modify Flows using natural language. This makes Flow development accessible to more admins than ever before.
However, accessibility doesn’t guarantee quality. Poorly designed Flows cause governor limit failures, data corruption, and frustrated users. This guide provides production-ready best practices for building Flows that scale.
Why Process Builder Retirement Matters Now
The End of Support Timeline
Salesforce stopped allowing new Process Builder creation in Spring ’25. Existing Process Builders still run but receive no support or updates. This creates escalating technical risk as time passes.
Your automation works today. But what happens when you discover a bug? Or when a security vulnerability appears? Salesforce won’t fix it. You’re on your own with unsupported tools.
The Migration Challenge
Many organizations have 50+ Process Builders scattered across their org. Some were built years ago by admins who have since left. Documentation is often incomplete or missing entirely.
The “Migrate to Flow” tool handles simple cases reasonably well. However, complex Process Builders with multiple criteria nodes require manual rebuilding. This takes time and careful testing.
The Hidden Opportunity
Don’t just migrate Process Builders one-to-one into Flow. Instead, consolidate related automation into well-architected Flows. One consulting firm reduced 100 Process Builders to 20 Flows.
This consolidation eliminates redundant logic and improves maintainability dramatically. It also provides an opportunity to implement modern best practices. Think of migration as a chance to improve, not just replicate.
Before-Save vs After-Save: Your Most Critical Decision
The Performance Reality
Before-save Flows run approximately 10 times faster than after-save Flows. This isn’t a small optimization, it’s an architectural game-changer.
Before-save Flows modify records in memory before the database save. They consume zero DML operations because they piggyback on the original transaction. This means 200 records update as fast as one record.
After-save Flows must issue separate Update statements to modify records. Each Update counts against your 150 DML limit per transaction. The performance difference becomes dramatic at scale.
When to Choose Before-Save
Before-save Flows excel at same-record field updates and data validation. They support Assignment, Decision, Loop, Get Records, and Formula elements only. You cannot create child records or send emails.
Ideal before-save use cases:
- Auto-populate Account Number from custom numbering sequence
- Normalize phone numbers to consistent format
- Calculate field values based on other field data
- Validate data before the record saves to database
- Set field values conditionally based on criteria
The key limitation? Before-save Flows cannot access the Record ID on insert. The system hasn’t assigned the ID yet in memory. Therefore, creating child records isn’t possible.
When to Choose After-Save
After-save Flows unlock the complete element library. Create child records, send emails, post to Chatter, invoke subflows. If you need the record’s ID, use after-save.
Ideal after-save use cases:
- Create related Contact when Account is created
- Send email notification to record owner
- Post Chatter updates for team visibility
- Create follow-up Tasks automatically
- Trigger scheduled actions for future dates
Never use after-save Flows to update the triggering record itself. This wastes a precious DML operation. Always use before-save for same-record updates instead.
Combining Both on the Same Object
Using both before-save and after-save Flows on one object is perfectly acceptable. In fact, it’s the recommended enterprise pattern. The key is managing execution order carefully.
Example: New Account creation
- Before-save Flow: Sets Account Number, normalizes data, calculates tier
- After-save Flow: Creates default Contact, sends welcome email, creates Task
This approach optimizes performance while maintaining complete functionality. Each Flow focuses on its specific responsibility clearly.
Bulkification: Preventing Governor Limit Disasters
Understanding the Governor Limits
Salesforce enforces strict limits per transaction to ensure platform stability. These limits apply equally to Flows and Apex code. Understanding them is critical for scalable automation.
Key per-transaction limits:
- 100 SOQL queries maximum
- 150 DML statements maximum
- 10,000 milliseconds CPU time
- 50,000 records via SOQL
- 2,000 records processed by DML
Salesforce automatically bulkifies certain Flow elements. Get Records, Create/Update/Delete Records pause all interviews at that element. Then they execute together as one operation.
However, this automatic bulkification breaks when you place DML inside loops. This is the number one cause of production failures.
The “No Pink in Loops” Rule
Data elements appear pink in Flow Builder. This includes Get Records, Create Records, Update Records, and Delete Records. The rule is simple: never place pink elements inside loops.
Breaking this rule transforms bulkified operations into individual transactions. Process 200 records with DML in a loop? That’s 200 separate DML operations. You’ll hit the 150-statement limit and fail.
The Collection-Based Pattern
The correct approach separates data retrieval, processing, and persistence into distinct stages. This maximizes Salesforce’s automatic bulkification capabilities.
Wrong approach (causes failures):
- Loop through 200 Opportunity records
- Inside loop: Get related Contacts (200 SOQL queries)
- Inside loop: Update Contact (200 DML operations)
- Result: Governor limit exceeded, Flow fails
Correct approach (enterprise pattern):
- Before loop: Get all related Contacts (1 SOQL query)
- Inside loop: Modify Contact fields using Assignment
- Inside loop: Add Contact to output collection
- After loop: Update entire collection (1 DML operation)
- Result: 2 total operations, handles any volume
This pattern works identically whether you process 20 records or 2,000 records. It scales effortlessly without code changes.
Common Antipatterns That Break Production
Antipattern #1: Multiple updates to the same record
Don’t use multiple Update Records elements for one record. Each Update consumes a DML statement. Instead, use one Assignment to set all fields, then one Update.
Antipattern #2: Get Records inside loops
Querying inside loops exhausts your 100-query limit quickly. Instead, use the “In” operator to retrieve all records before looping. Then reference the collection inside the loop.
Antipattern #3: Nested loops with DML
Nested loops multiply operations exponentially. 100 parents × 10 children = 1,000 operations. This far exceeds limits. Always flatten nested operations into sequential stages instead.
Antipattern #4: Empty collection DML
Delete Records fails when given an empty collection. Always check collection size before DML. Add a Decision element: {!Collection.size} Greater Than 0 before proceeding.
Exception Handling: Making Failures Visible
Why Fault Paths Are Mandatory
Every Data element must have a fault path configured. Create Records, Update Records, Delete Records, and all Actions require fault paths. Without them, users see generic “Unhandled Fault” errors.
Fault paths are the dashed red lines extending from elements. The $Flow.FaultMessage variable captures error details. However, never show this raw message to users.
Screen Flow Exception Handling
Screen Flows need user-friendly error messages. Fault paths should route to a Screen element explaining what happened. Provide actionable guidance on next steps.
Screen Flow fault path structure:
- Data element attempts operation (like Create Account)
- If it fails, route to error Screen
- Display: “Unable to save your information. Please contact support.”
- Include error reference ID for troubleshooting
- Provide “Go Back” button for correction
Keep error messages in business language, not technical jargon. Users don’t care about database errors or field API names.
Record-Triggered Flow Exception Handling
Record-Triggered Flows run in the background without user interface. Fault paths must route to notification mechanisms instead. Log errors for analysis and alert administrators immediately.
Background notification options:
- Send Email to administrator or support team
- Post to Chatter group for real-time alerts
- Create custom Flow_ErrorLog__c record
- Send Slack notification via custom Action
- Call Apex error-handling method
The most robust approach combines logging with notification. First create an error log record. Then send notification for critical Flows.
Reusable Error-Handling Subflow
The enterprise pattern uses one centralized error-handling subflow. All Flows call this subflow when errors occur. This keeps error logic consistent across the org.
Subflow input variables:
varT_FaultMessage(from $Flow.FaultMessage)varT_FlowName(from $Flow.APIName)varT_RecordId(from triggering record)varT_UserEmail(from $User.Email)
Subflow logic:
- Create Flow_ErrorLog__c record with all details
- Send email to flow-errors@company.com
- Post to Chatter if error count exceeds threshold
- Return error log ID to parent Flow
When you change notification methods, update one subflow. All Flows automatically inherit the new behavior.
Naming Conventions That Scale
Flow Label Standards
Consistent naming prevents chaos at 200+ Flows. Every team member should understand what a Flow does instantly. Use this standard pattern: ObjectName_TriggerContext_Purpose
Examples:
Account_BeforeSave_SetAccountNumberContact_AfterSave_CreateWelcomeTaskOpportunity_BeforeSave_CalculateProbabilityCase_AfterSave_NotifyOwner
Different Flow types need different suffixes for clarity. Screen Flows use _SCR_, Subflows use _SFL_, Scheduled Flows use _SCH_. This prevents confusion during searches.
Variable Naming Standards
Use typed prefixes for all variables. This makes variable purpose instantly clear in formulas. It also prevents type conversion errors during development.
Variable prefixes by type:
varT_for Text (Example:varT_AccountName)varN_for Number (Example:varN_Revenue)varB_for Boolean (Example:varB_IsActive)varD_for Date (Example:varD_RenewalDate)varR_for Record (Example:varR_Account)varR_plural for collections (Example:varR_Accounts)
Additionally, use forT_ for Formula Text, con_ for Constants, and choice_ for Choice resources. Consistency matters more than specific prefixes.
Element Naming Best Practices
Every element needs a clear, action-oriented name. Avoid generic names like “Decision 1” or “Assignment 2”. Instead, describe what the element does in business terms.
Element naming patterns:
- Get Records:
Get Active Contacts for Account - Create Records:
Create Follow-Up Task for Owner - Update Records:
Update Account Status to Active - Decisions:
Does Contact Have Email Address? - Assignments:
Set Contact Fields from Account - Loops:
Loop Through Each Opportunity
Flow Descriptions
Every Flow must include a comprehensive description. This documentation is critical during maintenance. New team members can understand Flows without reading the entire canvas.
Required description elements:
- Business logic summary in plain English
- Objects it reads from or writes to
- Where it’s invoked from (trigger, button, etc.)
- Business process it supports
- JIRA or story reference number
Enforce this through code review. Reject any Flow without proper documentation regardless of technical quality.
Flow vs Apex: Making the Right Choice
The Flow-First Philosophy
Salesforce recommends a “Flow-First” approach for automation. Approximately 70% of requirements can be handled in Flow. The remaining 30% require Apex for technical reasons.
Flow provides faster development and easier maintenance. Business users can understand Flow logic visually. However, Flow has limitations that make Apex necessary sometimes.
When Flow Is the Right Tool
Flow excels at standard automation with moderate complexity. Business logic changing frequently belongs in Flow. Admins can modify Flows without deployments or developers.
Use Flow for:
- Before-save field updates and data normalization
- Record-triggered automation with standard CRUD operations
- Screen Flow wizards for user data collection
- Scheduled operations under 2,000 records
- Email notifications and Chatter posts
- Standard approval and escalation workflows
- Creating child records based on parent changes
Flow provides immediate value with lower technical complexity. Flow changes don’t require test coverage or deployment planning.
When Apex Becomes Necessary
Apex handles scenarios where Flow’s limitations create technical constraints. Some operations require fine-grained control that Flow cannot provide.
Use Apex for:
- Bulk processing exceeding 100,000 records (Batch Apex)
- Complex REST/SOAP integrations with custom authentication
- Advanced error handling with try/catch/finally logic
- Complex algorithms requiring nested loops or recursion
- Queueable chains for sequential async processing
- Mission-critical operations requiring comprehensive unit tests
- Performance-critical operations needing microsecond optimization
- Third-party library integration unavailable in Flow
The Hybrid Pattern
The strongest architecture combines Flow orchestration with Apex computation. This leverages each tool’s strengths while minimizing weaknesses.
Hybrid implementation:
- Flow determines which records need processing
- Flow builds collection of records needing complex logic
- Flow calls Apex Invocable Method with collection
- Apex performs heavy computation or integration
- Apex returns processed results to Flow
- Flow continues with Updates and notifications
Example: Complex pricing calculation
- Flow identifies Opportunities needing price updates
- Flow calls Apex with Opportunity collection
- Apex performs complex tiered pricing algorithm
- Apex returns updated prices to Flow
- Flow updates records and sends notifications
This keeps orchestration visible while handling computation efficiently.
Security Context: Understanding Permissions
System Context vs User Context
Security context determines which records your Flow can access. This has significant implications for data security and compliance.
Record-Triggered and Schedule-Triggered Flows always run in system context. This cannot be changed. They bypass object permissions, field-level security, and sharing rules. Consequently, they see and modify all records regardless of user permissions.
Screen Flows default to user context when launched. However, you can configure them to system context. This appears in Flow properties under “How to Run the Flow.”
Security Best Practices
Always use minimum necessary privileges for Flow execution. Start with user context unless you have specific reasons otherwise. Document why you chose system context in Flow descriptions.
Keep Screen Flows in user context by default. Only elevate to system context when absolutely required. For Screen Flows needing elevated access, use hybrid approach. Keep parent Flow in user context. Use system-context subflows for specific privileged operations between screens.
Never apply system context to Screen Flows accessible by guest users. This creates massive security vulnerabilities with unauthenticated access.
Guest User Security
Guest users are unauthenticated Experience Cloud visitors. Granting them “Run Flows” permission without restrictions is extremely dangerous. They could access all org data through system-context Flows.
Mitigation strategy:
- Open Flow properties and expand Security section
- Enable “Override default behavior and restrict access”
- Specify which profiles can run this Flow
- Create dedicated permission sets for external Flows
- Audit flow access permissions quarterly
This prevents guest users from invoking internal Flows accidentally. It provides defense-in-depth security for sensitive automation.
Spring ’26 AI-Powered Features
Agentforce Iterative Flow Building
Spring ’26 introduced the most significant Flow Builder advancement in years. Agentforce allows modifying existing Flows through natural language conversation. This fundamentally changes how admins create automation.
How it works:
- Open existing Flow in Flow Builder
- Click Agentforce assistant icon
- Type: “Add Decision checking if Amount exceeds $50,000”
- Agentforce modifies Flow canvas automatically
- Changes appear highlighted for review
- Iterate further with additional instructions
- Save final Flow with all changes
This dramatically reduces technical barriers to Flow development. Non-technical admins can build complex automation through conversation. However, proper architecture principles still apply.
Other Spring ’26 Enhancements
Spring ’26 delivered several additional productivity improvements. Editable Data Tables enable inline grid editing in Screen Flows. Native Kanban Board component provides visual status tracking.
Message component displays styled notifications and alerts. Collapsible branching elements reduce canvas clutter significantly. Component-level styling overrides enable brand customization.
Flow Logging with Data 360 provides production observability. Real-time execution monitoring, variable inspection, and error tracking. This gives administrators visibility into Flow behavior.
AI Doesn’t Replace Architecture
AI-powered flow building makes creation faster and more accessible. However, it doesn’t eliminate the need for proper architecture. Review all AI-generated Flows for bulkification patterns and error handling.
AI may not apply consistent naming conventions automatically. Rename elements and variables after AI generation completes. Apply your org’s standards before activating any AI-generated Flow.
Testing and Bypass Mechanisms
Build and Test Incrementally
Never build a complete 50-element Flow then test at the end. This makes debugging extremely difficult when issues arise. Instead, build incrementally and test continuously throughout development.
Build first Decision element, then test with debug mode. Add next Assignment element, then test again. Continue building and testing each section separately. This identifies issues immediately when they’re easiest to fix.
Flow Builder Debug Mode
Flow Builder includes powerful built-in debug mode. Use it extensively during Flow creation and modification. Debug mode prevents accidental data changes in production orgs.
Enable “Roll Back Records” checkbox during debugging. This prevents test data from persisting in sandbox. It allows testing destructive operations safely without cleanup.
Native Flow Tests
Native Flow Tests provide persistent test scenarios for automation. They work for record-triggered Flows and support CI/CD integration. Run them alongside Apex tests for comprehensive coverage.
Create reusable tests by clicking “Test” button in Flow Builder. Provide realistic record values and define expected outcomes. Save tests with descriptive names for repeated execution.
Bypass Mechanisms for Migrations
Data migrations require bypassing Flows without deactivating them. Deactivation impacts all users, not just migration processes. Use Custom Permissions for the cleanest implementation.
Custom Permission approach:
- Create Custom Permission:
Bypass_Flows - Create Permission Set:
Data_Migration_Bypass - Add Custom Permission to Permission Set
- Assign to migration user with expiration date
- Add to Flow entry criteria:
$Permission.Bypass_Flows Equals False
Permission Sets support automatic expiration dates. This ensures bypass access removes itself without manual cleanup.
Conclusion: Three Essential Principles
Master these three fundamentals before worrying about advanced optimization. These principles separate production-ready Flows from those that break under load.
Use Before-Save for Same-Record Updates
This single decision provides 10x performance improvement immediately. Before-save Flows consume zero DML operations for triggering record updates. If you’re only updating the triggering record, always use before-save.
Never Place DML Inside Loops
This is the most common cause of production failures. The “No Pink in Loops” rule is non-negotiable. Use the collection-based pattern: Get before loop, modify inside loop, DML after loop.
Add Fault Paths to Every Data Element
Unhandled exceptions become invisible data quality problems. Every Create, Update, Delete Records element needs a fault path. Use reusable error-handling subflows to centralize logging logic.
The Path Forward
Spring ’26’s AI-powered flow building makes Flow creation dramatically easier. Admins can build complex automation through natural language. However, this accessibility makes robust standards even more critical.
Organizations treating Flow development with Apex-level rigor will build automation that scales. Those taking shortcuts will accumulate compounding technical debt. The tools are more powerful than ever.
The question is whether your team has the discipline to use them correctly.
Learn Moar!
Winter ’26: Automatic Permission Set License Release Finally Arrives
The Latest Lightning Web Components Updates Every Salesforce Developer Must Know
Leave a Reply