Cloud Giants’ Recommended Flow Framework
Evolving Flow Trigger Framework Best Practices
For many years, a widely accepted best practice was to consolidate all declarative automation, first in Process Builder and later in Record-Triggered Flows, into a single process or Flow per object. This approach gained traction before Salesforce provided execution order control for Flows, and it was primarily adopted for two reasons:
Controlled Execution Order – Ensured that automation on a given object ran in a predictable sequence.
Optimized Performance – Minimized initialization costs per transaction by reducing the number of process builders that needed to initialize.
When record-triggered Flows replaced Process Builder as the primary declarative automation tool, the one-per-object methodology was carried over. However, as Salesforce has continued to enhance Flow capabilities, best practices have evolved. Notably, Salesforce now allows explicit execution order control for Flows and has confirmed in its architecture documentation that consolidating all automation into a single Flow per object does not provide a material performance advantage over multiple Flows.
Given these advancements, Cloud Giants now recommends taking a modular approach to Flow automation, organizing Flows by function while maintaining execution order control. This approach leverages Flow entry criteria to ensure that Flows only run when specific conditions are met, significantly reducing unnecessary executions and minimizing performance impact. By preventing Flows from triggering on every record update, this design improves efficiency while keeping automation scalable. The following sections outline a framework for implementing this approach in a structured and maintainable way.
Recommendations For Implementing A Modular Flow Framework
1. Focus Flows on Specific Business Scenarios
The core principle of the modular framework is to ensure that each Flow is focused on a specific business function or scenario. This ensures clarity, ease of maintenance, and reduces unnecessary complexity. By keeping each Flow aligned with a single business objective, it becomes easier to troubleshoot, modify, and scale the automation as your organization grows.
Best Practices for Focused Flows:
Single Scenario: Each Flow should address all actions related to a specific business scenario—whether that’s updating fields, creating records, or triggering emails. For example, a Flow that handles updates, record creation, and notifications when an Opportunity’s stage is updated to "Negotiating" should be treated as a single Flow for that scenario.
Avoid Overloading: Do not combine multiple, unrelated tasks in a single Flow. Keep Flows aligned with specific scenarios to maintain clarity, flexibility, and ease of updates.
2. Share Logic Across Flows
When possible, reuse logic across different Flows by moving common tasks to subflows or invokable Apex. This reduces redundancy, improves consistency, and makes it easier to update shared logic in a single place.
Best Practices for Sharing Logic:
Subflows for Common Tasks: Use subflows to handle reusable operations (e.g., processing data, sending notifications, updating related records).
3. Clear, Descriptive Naming
Flow names should clearly describe both the scenario the Flow addresses and the description should explain the tasks that the flow performs. This helps anyone reviewing a Flow quickly understand its purpose and trigger conditions, without needing to open and inspect it.
Best Practices for Flow Naming:
Descriptive Naming Convention: Include both the object and the specific business scenario in the Flow name (e.g., "Opportunity – Update Fields and Send Email on Closed Won" or "Account – Create Case and Notify Owner on Status Change").
Consistency: Use a consistent naming convention across all Flows to make it easier to understand the purpose of each Flow at a glance.
4. Use Entry Criteria to Control Flow Execution
Use entry criteria to ensure that Flows are only triggered when necessary, reducing unnecessary runs and improving performance. This ensures that each Flow operates efficiently and only when the conditions are right.
Best Practices for Entry Criteria:
Simple, Specific Conditions: Set narrow, focused criteria to avoid unnecessary Flow triggers.
Limit Complexity: Ensure that the entry logic is as simple as needed to avoid unnecessary complexity.
5. Flow Execution Order
When multiple Flows need to run for the same object, use the execution order to manage the sequence in which they trigger. This ensures that Flows run in the correct order, preventing conflicts or errors.
Best Practices for Execution Order:
Prioritize Critical Flows: Define which Flows are most critical (e.g., data validation) and ensure they run first.
Document the Order: Keep track of the execution order to maintain consistency and simplify troubleshooting.
6. Documentation and Version Control
As your Flow automation grows, maintaining clear documentation is essential. Proper documentation makes it easier to onboard new team members, troubleshoot issues, and track changes over time.
Documentation Practices:
Flow Purpose and Function: Document the main purpose of each Flow, its entry criteria, and any relevant business logic.
Version Control: Keep a record of any changes to your Flows, with clear notes on updates and revisions.
Steps for Transitioning to a Modular Flow Framework
Shifting from a one-flow-per-object model to a modular flow framework requires careful planning. Below are the steps to make this transition smoother:
1. Audit Existing Automation
Before transitioning, take the time to audit existing automation to understand the current structure and flow dependencies. This audit will provide insight into how automation is working and where improvements can be made.
Start with Flows on high-use objects (Lead, Account, Opportunity, etc.): These objects typically have the most complex automation, so focus on them first.
Document Automation and Dependencies: Identify the triggers for each flow and how they interact with other processes to better understand interdependencies.
Create a Transition Plan: Develop a strategy for gradually transitioning existing flows to a modular structure, ensuring a smooth and phased move.
2. Create New Flows Using the Modular Framework
Moving forward, all new record-triggered flows should be built following the modular framework principles:
Structure Flows Around Specific Business Scenarios: Rather than grouping all automation into a single flow per object, each flow should be designed to address a specific business scenario (e.g., Opportunity Stage Update or Account Status Change).
Use Entry Criteria for Control: Leverage entry criteria to ensure that flows are only triggered when necessary, improving performance and scalability.
Maintain Clear Naming Conventions: Adhere to a consistent and descriptive naming convention that indicates both the object and the scenario the flow handles.
By following these steps, your organization can transition to a modular flow structure that is more efficient, easier to maintain, and scalable as your automation needs grow.
Designing for What’s Next
As Salesforce automation evolves, a modular Flow framework strikes the right balance of performance, maintainability, and scalability. By organizing Flows around specific business scenarios and using entry criteria to control execution, teams can build efficient, manageable automation that adapts as business needs change.
Moving away from a one-per-object model requires planning, but the benefits, fewer unnecessary executions, and greater flexibility make it a valuable investment for any Salesforce organization.
Following these best practices will help your team create a scalable, long-term Flow architecture while avoiding the unnecessary complexity of giant flows.
Key Takeaways
Modular Flows improve maintainability by keeping automation focused on specific business scenarios rather than consolidating everything into a single Flow.
Entry criteria allow for the use of asynchronous paths, enabling better handling of time-dependent or resource-intensive automation.
Entry criteria help optimize performance by ensuring Flows only run when necessary, reducing unnecessary executions.
Subflows and shared logic can reduce redundancy, making it easier to update and maintain automation if multiple record-triggered flows need to take similar actions.
Execution order control ensures Flows run predictably, preventing conflicts or unintended behavior.
Troubleshooting may take more effort, as automation is distributed across multiple Flows rather than concentrated in a single process.