Lesson 5 of 14 · All lessons

Section 3 · Process Automation and Logic · 28% of exam

3.1 Flow Types and Declarative Process Automation

4 min read Updated Nov 16, 2026

Exam objective

Identify the capabilities of Salesforce declarative process automation and select an appropriate Flow type and configuration for a scenario.

Select a Flow by its entry point

Salesforce Flow supports several process patterns. A screen Flow is launched by a user and collects input through screens. An autolaunched Flow runs without screens and is invoked by another automation, Apex, or an API. A record-triggered Flow starts when a record is created, updated, or deleted, based on the configured trigger and entry conditions. A schedule-triggered Flow runs on a schedule for records matching criteria. A platform-event-triggered Flow starts when an event is received. These types differ in entry point, user interaction, timing, and transaction behavior. A useful exam method is to locate the initiating event in the scenario. If a user needs a guided intake process, look toward screen Flow. If a saved record must cause a follow-up action, consider record-triggered Flow. If work must begin at a later time, look for a scheduled path or schedule-triggered design, checking the exact requirement. If another automation needs reusable logic with no user interface, consider an autolaunched Flow. Event-driven architecture may fit when a platform event should decouple the publisher from later processing.

Before-save and after-save record-triggered work

A before-save record-triggered Flow can efficiently update fields on the record that triggered it, before the save completes. Use it for supported same-record changes that do not need to create related records or invoke actions that require the saved record. An after-save Flow runs after the record is saved and can create or update related records, send supported notifications, or invoke other actions. Select timing based on what data exists and what side effects are required, not just on which option seems more powerful.

Entry criteria should be specific. A Flow that runs on every update and then checks a condition internally performs unnecessary work and may create confusing side effects. Configure start conditions and, when appropriate, choose how the Flow runs on updates. A scenario involving a status transition should distinguish “status equals Approved” from “status changed to Approved.” The latter is about a transition and may require comparing current and prior values.

Decisions, loops, fault paths, and maintainability

Use Decision elements to select paths, Assignment to change Flow variables, Get Records to retrieve data, and Create/Update/Delete Records to perform supported data operations. Use loops for collection processing but avoid placing a Get Records or DML operation inside a loop when a collection-based operation can do the work. A fault connector can route errors to a useful response or logging path. Do not create a catch-all fault path that hides failures without preserving diagnostic detail.

Flow formulas and resources should have clear names and types. Keep branches readable and avoid one enormous Flow that owns unrelated processes. Modular autolaunched Flows can be reused where that improves clarity, but over-fragmentation can make execution harder to trace. Record-triggered Flow order can matter when multiple flows run for one object; use supported ordering and explicit responsibilities to make behavior predictable. Consider an account update that should calculate a segment and then notify a manager if the segment changes. A same-record before-save flow may set the segment. An after-save flow may handle the notification only when the old and new values differ. If an Apex trigger also calculates that field, decide which automation is authoritative. Test both insertion and update paths, including unrelated edits that should not resend the notification.

A Flow can update a record that causes another Flow or trigger to run. Map each write and entry condition to find loops, duplicate notifications, and unexpected extra transactions.

Extra concept: automation is a save-path graph

An org's behavior is not one Flow in isolation. Draw the save path as events and writes: user change, before-save automation, validation, Apex trigger, commit, after-save automation, and any secondary updates. This graph helps explain repeated execution, stale values, and failures that appear only when multiple automations interact.

Key takeaways

  • Match the Flow type to the initiating event, interaction requirement, and timing.
  • Use before-save logic for supported changes to the triggering record and after-save logic for post-save or related work.
  • Keep entry criteria selective, bulk behavior efficient, and faults observable; analyze all automation on the save path together.
  • Official references:
  • Salesforce Certified Platform Developer Exam Guide: https://help.salesforce.com/s/articleView?id=005298965&language=en_US&type=1
  • Salesforce Flow documentation: https://help.salesforce.com/s/articleView?id=sf.flow.htm&type=5
  • Decide between before-save and after-save Flow: https://help.salesforce.com/s/articleView?id=platform.automate_flow_build_get_started_r ecord_triggered_before_or_after_save.htm&language=en_US&type=5
  • Record-triggered Flow run order: https://help.salesforce.com/s/articleView?id=sf.flow_task_trigger_run_order.htm&language=en_US&type=5
  • Flow fault paths: https://help.salesforce.com/s/articleView?id=sf.flow_build_logic_fault.htm&type=5

Check your knowledge

Answer exam-style Process Automation and Logic questions with answers and explanations.

Practice Process Automation and Logic
Finished this lesson? Mark it complete to track your progress.

Ready for the real exam?

Take the timed Salesforce Platform Developer simulator: same number of questions, same time limit.

Get Complete Access