The independent daily for Salesforce admins, developers and architects

Curated by Abhinav (opens in a new tab)

How the Salesforce order of execution sequences flows, triggers and validation (opens in a new tab)

You will learn the rough sequence in which Salesforce runs Flows, Apex triggers, Validation Rules and after-save automation when a record is saved, and why that order matters when several automations touch the same record.

Why read this

The article is a general overview rather than a detailed reference.

  1. Initial record submission
  2. Before-save Record-Triggered Flows
  3. Before Apex triggers
  4. Validation and duplicate rules
  5. Save to database, not yet committed
  6. After triggers and after-save flows
  7. Commit and post-commit operations
The main stages Salesforce runs when a record is saved

When a record is created, updated or deleted, Salesforce runs several kinds of automation in a defined sequence. The article says this matters because multiple automations touching the same record can produce unexpected results, repeated updates or errors. Understanding the sequence helps teams troubleshoot and avoid needless complexity.

The process starts with the initial submission, whether from the user interface, the API, Apex, Data Loader or an external application. Before-save Record-Triggered Flows then run before the record is written to the database, and are described as efficient for simple field updates because they avoid an extra save. Before Apex triggers follow, with a short example that sets a default value on a Contact description. Validation Rules and duplicate rules run before the save completes.

Once the record is saved to the database, the transaction is not yet committed, so later errors can still roll the changes back. After triggers and after-save flows then run, handling tasks such as creating related records, sending notifications or starting further processes. The article also notes that legacy workflow, escalation and assignment rules can cause extra updates that re-run parts of the sequence. After a successful transaction, the changes are committed and post-commit work such as Queueable Apex, future methods and scheduled paths can run.

The article closes with common mistakes: several Flows on one object without reviewing their order, duplicating field updates across Flows and Apex triggers, ignoring recursion, and skipping tests for API updates. Its advice is to review existing automation on an object before adding a new Flow, trigger or Validation Rule.

Read the original at dev.to (opens in a new tab)

Worth reading?

Recommended

A four-bucket Kit of 100 prompts for Admin work with Agentforce Vibes (opens in a new tab)

You will learn how the Admin Accelerator Kit's four prompt buckets (Understanding, Configuring, Troubleshooting, Documenting) are meant to be used, and which prompts to run first in a sandbox.

Why read this

You will also see how the buckets chain together on a real change, such as converting a text field to a picklist.

  1. Understanding: map what the org already does
  2. Configuring: plan, then build the change
  3. Troubleshooting: diagnose what breaks
  4. Documenting: record the change and the why
The four prompt buckets are meant to be used in sequence on a single change

The post introduces a set of 100 ready-made prompts for everyday admin tasks, presented at a Dreamforce 2026 session on Agentforce Vibes. The prompts are hosted as a markdown file in the Admin Accelerator Kit on GitHub, and readers can simply browser-copy them. They are organized into four buckets of five categories with five prompts each, and placeholders in angle brackets must be replaced with real API names. The authors note the prompts also work with other agents connected to a Salesforce org through MCP.

The author advises starting in a sandbox or Developer Edition org, especially for Configuring prompts, because Understanding and Documenting prompts mostly read metadata while Configuring prompts change it. Understanding prompts help map objects, Flows, permissions and business processes, and impact-analysis prompts help check what breaks before a field change. Configuring prompts range from “How do I” questions that yield click paths to “Create” and “Write” prompts that generate Flow or Validation Rule metadata for review before deployment.

Troubleshooting prompts cover Flow errors and permission problems, with the advice to paste the full fault email along with record IDs and the affected user. The kit also addresses conflicting automations that silently revert field values. Documenting prompts produce data dictionaries, release notes, deployment checklists and, most importantly, a record of why a rule was configured as it was.

The post closes by showing the buckets chained together on a Region picklist change, and invites feedback and contributions to the kit’s repository.

Read the original at Salesforce Admins Blog (opens in a new tab)

Worth reading?

Recommended

Modelling FCA complaints data in Salesforce and avoiding the UTC time zone trap (opens in a new tab)

You will know how to model the fields COM001 needs for Cases, including a UK-local date that puts complaints in the correct half-year.

Why read this

You will also know how to test the setup before the 2027 deadline.

  1. Complaint received in UTC
  2. Convert to Europe/London date
  3. Store in Date_Received_UK__c
  4. Derive H1 or H2 formula
  5. Group report by legal entity
How the UK date feeds the half-year label used in COM001 reporting

From 1 January 2027, UK financial services firms will report complaints to the FCA in a new return, COM001, covering fixed half-years. The article sets out a data model for this built from standard Salesforce features, for orgs that hold complaints as Cases. Group reporting is removed, so each complaint needs a required legal entity, held as a restricted picklist or a lookup to a reference object that compliance controls. Every trading name and acquired brand must map to exactly one entity.

The return counts complaints from vulnerable customers and complaints about a failure to consider or respond to vulnerability, which can overlap. The author recommends two separate checkboxes rather than one picklist, with Field History Tracking switched on. Standard history is kept for 18 months, or 24 months via the API, unless Field Audit Trail is enabled, so it should not be relied on for longer retention.

The main pitfall is time zones. Datetime values are stored in UTC, so a complaint received just after midnight on 1 July during British Summer Time falls on 30 June in UTC and lands in the wrong half-year. The fix is a separate date field holding the UK date, set in a before-save trigger or invocable Apex using the Europe/London time zone, with the same done for the closed date. A formula on that date field then derives the half-year label, and reports are grouped by legal entity and that label.

The article also advises keeping the reason for a vulnerability marker in a separate field or related record, protected by field-level security, since health details can be special category data under UK GDPR. Before 1 January, it recommends testing a complaint created at 00:30 UK time on 1 July, running the same report twice a week apart, and confirming that changes to a vulnerability marker on a closed complaint are logged. The exact field names and validations are in the FCA’s COM001 Data Reference Guides.

Read the original at dev.to (opens in a new tab)

Worth reading?

Using Flow Orchestration to coordinate multi-step business processes (opens in a new tab)

You will understand how Flow Orchestration organizes stages and steps across automated and interactive work, and when it is better than chaining several Flows.

Why read this

The article gives a worked onboarding example and a short checklist for a first build.

  1. Automated Flow stage
  2. Interactive Screen Flow stage
  3. Automated provisioning stage
A Flow Orchestration advances to the next step only when the previous one completes

Most automations start as one Flow, but as a process grows, several Flows can conflict, run out of order or duplicate work. Flow Orchestration, which the article describes as generally available in recent releases, lets you build one process made of stages and steps, where each step is an automated Flow, a background Apex or invocable action, or an interactive Screen Flow or approval assigned to a user or queue with a due date.

An orchestration advances to the next step only when the previous one completes. If a step fails, the orchestration pauses rather than continuing silently, and the orchestration run record shows the current stage, step, assignee and status in one place. The author’s onboarding example has an automated stage that creates tasks and a project, an interactive stage where a specialist confirms a kickoff call within three days, and an automated stage that provisions a portal user and sends a welcome email.

The article says orchestration suits processes with handoffs between people and automation, such as approvals, onboarding, case escalation and quote-to-cash, and is excessive for a single condition-and-action rule. It advises mapping the process on paper first, keeping one job per Flow, and remembering that orchestration runs consume Flow interviews and so still need governor-limit planning.

Read the original at dev.to (opens in a new tab)

Worth reading?

Ten Flow design mistakes that break Salesforce orgs as they scale (opens in a new tab)

You will learn how bulk record processing, database operations inside loops, repeated writes, hard-coded IDs and weak fault handling make Flow fail under load, and how to design around each one.

Why read this

The piece is practical guidance for anyone whose orgs run record-triggered automation at volume.

This Salesforce Ben article, written for architects, lists ten Flow design mistakes that cause failures as orgs grow, and suggests a fix for each. The first concerns treating Flow as a single-record tool: bulk operations from Data Loader or List Views share one transaction’s governor limits, so authors should use before-save flows for same-record updates, tighten entry conditions, and make invocable Apex bulk-safe. The second warns against database operations inside loops, recommending retrieving records before the loop, changing values in memory, and saving a collection once afterwards, with Collection Filters and Transform as alternatives. The third covers writing to the database too often, since each write can fire further automation and cause record-locking, so decisions should come first and writes should be batched near the end.

The next several points cover maintainability, testing and error handling. Hard-coded IDs break when flows move between environments, so the article recommends looking up records by DeveloperName, using Custom Metadata, Custom Labels or Custom Settings. Flows without deliberate fault handling leave failures to Salesforce’s default response, so authors should choose between blocking saves, guiding users, or logging failures, and should understand how rollback differs for unhandled errors, handled faults and explicit rollbacks. Testing with a single record gives little assurance, so the article urges bulk tests of at least 200 records, representative data, and separate logic, transaction-limit and load testing.

The final points address structure and design. Monolithic flows are hard to maintain, so the piece suggests subflows for repeated logic, self-contained processes and frequently changing rules, while warning against too many tiny subflows and recommending grouping flows by business purpose. Transaction boundaries matter because governor limits apply per transaction, and asynchronous paths, scheduled paths, screens, Wait elements and Platform Events can move work out of the original save, with the trade-off that committed changes cannot be rolled back. Screen Flows need care when users click Previous, which can cause duplicates, so the article advises saving at the end and making steps idempotent. Finally, it cautions that data model problems such as data skew, non-selective queries, recreated roll-up functionality and master-detail choices can limit what Flow design alone can fix. The conclusion advises reviewing the highest-volume objects first.

Read the original at Salesforce Ben (opens in a new tab)

Worth reading?

Recommended

Rehearse a Salesforce Data load locally before uploading to the Org (opens in a new tab)

You will learn how to simulate a Salesforce data load against your project's triggers, flows and Validation Rules on your own machine, catching refused rows before any reach the org.

Why read this

The piece is a product walkthrough, so treat its claims about the runtime's fidelity with some caution.

  1. Map the CSV onto an object
  2. Simulate rows in a rolled-back transaction
  3. Fix refused rows and simulate again
  4. Upload to Org
How a data load is rehearsed before it reaches the org

The article argues that a Salesforce data load is effectively a deploy: each row runs through the org’s triggers, Validation Rules and flows, and problems usually surface only after the rows are in. It presents Renmy runtime, a local Apex runtime that runs the same automation on a developer’s or admin’s own computer against an embedded database, with no org, Scratch Org or sandbox needed. The piece is a vendor product walkthrough, so its claims about how closely the runtime matches Salesforce should be read with caution. The article points to a public parity record, which it says lists where the runtime matches the platform and where it does not.

The walkthrough runs in IntelliJ IDEA through the plugin Renmy Runtime - Salesforce IDE. The user opens the Salesforce DX project their developers keep in version control, which supplies the triggers, flows and Validation Rules. They then load a CSV in the plugin’s Data Loader, map its columns to object fields, and flag unreadable cells before anything runs. Pressing Simulate processes the rows in batches of 200 inside a transaction that is rolled back, and reports which changes would be made and which rows would be refused, with the platform’s own error messages. The user fixes the file and simulates again as often as needed, and only then uses Upload to Org to send the same file to a chosen org, with a confirmation that names the org and row count. The example is an invoice update in which three rows fail a Validation Rule and three dates cannot be read.

The article also describes a Workbench for editing individual records with automation switched on, and a Save as Fixture option that turns rows into test data for developers. It is explicit about the limits: the rehearsal cannot see automation that exists only in the org until it is retrieved, and for updates the referenced records must also exist locally, where Clone Org Data can copy a slice of the org down. The org remains the final authority. The article also says the rehearsal does not contact an org and keeps source, schema and data on the local machine, and that the Free tier covers the Data Loader and Simulate. It describes the Pro tier as free during the public beta, with a listed price of $19 a month afterwards. It presents the tool as suited to admins with no coding skills, though a developer’s project checkout is needed.

Read the original at dev.to (opens in a new tab)

Worth reading?

Handling Flow errors with Fault paths, logging and notifications (opens in a new tab)

You will learn why a Flow can fail without anyone noticing, and five practices for using Fault Paths to log, notify and test failures.

Why read this

The advice is standard but practical for admins maintaining automation.

  1. Data element fails
  2. Fault Path runs
  3. Log failure record
  4. Notify admin or owner
How a failed Flow element is handled once a Fault Path is in place

A Fault Path is the branch a Flow takes when one of its elements fails, such as a record update blocked by a Validation Rule, a create that trips a duplicate rule, or a lookup that returns nothing. Without one, a Screen Flow shows the user a generic error, while a Record-Triggered Flow rolls back quietly and tells no one. The author argues that failures are easy to miss for this reason and that a missing branch is usually the cause.

The article gives five practices. Add a Fault Path to every data element, since failures often come from changes made elsewhere, such as a new Validation Rule or a permission change. Log each failure to a Custom Object, capturing the Flow name, element, record ID and the $Flow.FaultMessage value. Pair the log with a notification to an admin group or record owner so failures are seen the same day. Decide for each Flow whether a failure should stop the process or let it continue and flag the record for follow-up. Finally, test the failure paths in Flow Builder’s debug mode by feeding in data that violates a rule before each deployment.

The author also notes that a Flow can fail for different reasons depending on whether it runs in system or user context, because of Sharing Rules, field-level security or missing permissions. If a Flow fails only for some users, the run context should be checked first.

Read the original at dev.to (opens in a new tab)

Worth reading?

Send Custom Notifications in Salesforce using Flow Builder without writing Apex (opens in a new tab)

You will learn how to configure Notification Builder and build a Flow that pushes targeted alerts to desktop and mobile users.

Why read this

The guide covers recipient targeting, deep linking, and best practices to avoid notification spam.

The article explains how to implement Custom Notifications in Salesforce using Flow Builder instead of Apex. It begins by outlining the prerequisite setup in Notification Builder, where administrators define a notification type and select delivery channels such as desktop or mobile.

It then walks through creating a Record-Triggered Flow with entry criteria to control when alerts fire. The guide details how to use the Send Custom Notification action element, wire up the notification type ID, construct dynamic titles and bodies with formula resources, and populate recipient collections using Get Records. It also explains how to set a target ID to enable deep linking directly to the relevant record.

A practical scenario demonstrates using a scheduled Flow to alert managers about stalled high-value opportunities. The author concludes with implementation tips, emphasizing concise titles, aggressive filtering to prevent spam, verifying sharing settings for non-admin testers, and reserving mobile push notifications for urgent escalations.

Read the original at dev.to (opens in a new tab)

Worth reading?

Decouple dynamic business rules from Salesforce Flow using reference tables (opens in a new tab)

You will learn how to move static routing logic out of Flow elements into external reference tables, reducing deployment risk and enabling non-technical staff to manage updates.

The article argues against hardcoding business rules directly inside Flow decision nodes or Formula Fields, explaining that this practice creates maintenance debt and increases deployment risks. Instead, it recommends externalizing ever-changing logic into reference tables stored as either Custom Objects or Custom Metadata Types.

A detailed comparison outlines when to choose each storage method, noting that Custom Objects are better for frequently updated operational data managed by business users, while Custom Metadata Types suit static configuration moved through deployment pipelines. The author walks through building a territory assignment engine using a Custom Object to route Opportunities based on postal codes.

Key implementation details include optimizing the Flow for fast field updates, using a Get Records element with a CONTAINS filter, and sorting results by last modified date to handle overlapping rules safely. The piece also warns about partial string matching pitfalls and suggests padding delimiters to prevent incorrect matches.

Read the original at Salesforce Break (opens in a new tab)

Worth reading?