You will know how to choose verification methods, phase an MFA rollout to avoid a backlash, handle integration and exception accounts, and prepare recovery procedures before users get locked out.
Pick verification method
Pilot with administrators
Fix friction over one week
Roll out profile by profile
Review enrollment monthly
A staged MFA rollout runs from a pilot to profile-by-profile enablement
The article opens by framing MFA as a requirement for Salesforce sign-in, since a password alone no longer protects customer data in an org. It then sets out a five-part plan for the admin running the rollout. The first step is choosing a verification method: the Salesforce Authenticator app as the smooth default, a third-party TOTP app, or a physical security key, with keys recommended for System Administrators and users with broad data access.
The second step is staging the rollout. The author suggests enabling MFA under Setup, Identity Verification, starting with System Administrators and a small pilot group, running the pilot for a week, fixing friction such as missed enrollment emails or shared devices, and then rolling out profile by profile rather than all at once.
The third and fourth steps cover exceptions and non-human access. Users who cannot use a phone app, such as shared service accounts or kiosk logins, should use a security key or hardware token with a documented owner and review date. API-only and integration users should rely on OAuth flows or locked-down integration users, and the Login History report should be reviewed monthly for logins that bypassed MFA.
The final step is preparing users for recovery, since a new phone lockout is the most common support ticket. The author recommends a one-page guide and admin reset of MFA registration from the user’s record. The article closes by treating MFA as ongoing work, with monthly enrollment checks and quarterly exception reviews.
You will learn how each of the three platforms rotates leads between reps, including the Salesforce formula and assignment rule setup and the common reasons assignment rules fail to fire.
Why read this
You will also see how availability, weighting and rule order differ between them.
Salesforce
No round robin switch built in
Autonumber, formula and rule entries
Edit formula when team changes
HubSpot
Rotate record to owner action
Load balanced, round robin, random
Assign to available users only
Salesforce and HubSpot round robin setups differ in what the platform provides
Round robin lead assignment hands each new lead to the next rep in a fixed order, which suits teams where reps sell the same thing and leads are broadly alike. The article sets it against weighted, load-balanced and rules-based approaches, and notes that real setups usually combine rules to pick a team with a rotation inside it. It lists four common cases where a plain rotation breaks down: leads from existing accounts, uneven lead quality, reps who are away, and reps who own territories.
In Salesforce there is no round robin switch. The article walks through the build: an Autonumber field, a Round Robin ID formula using MOD over the number of reps, and one Assignment Rule entry per rep, with a catch-all entry at the bottom. Each time a rep joins or leaves, the formula and entries must be changed by hand. The article then lists why rules often appear not to fire, such as API calls missing the AssignmentRuleHeader, Data Loader imports without the rule ID, the Lightning checkbox setting, and Flows using the Run Immediately path.
HubSpot uses the Rotate record to owner workflow action, available on Sales Hub and Service Hub Professional and Enterprise, with options for round robin, load balanced and random, and an option to skip users who are set to Away. Its first assignment is random, counts are kept per action, and changing owners resets the counts. Pipedrive offers automatic assignment on Professional and higher plans, where each rule keeps its own rotation, there are no caps or weights, and a rep on leave must be removed from rules by hand.
A comparison table sets the three platforms side by side, covering built-in support, plan requirements, handling of absent reps, and how imports and API traffic are treated. The article then describes Operelio, a tool that applies routing before a lead reaches the CRM, and its routing rules, round robin and CRM checks.
By Andreea Doroftei · Salesforce BenYou will also know that Standard Omni-Channel was retired in Summer '26 and that existing configurations carried over.
You will learn what Enhanced Omni-Channel requires, how queue-based, skill-based and external routing differ, and the main steps to enable routing and test it.
Why read this
You will also know that Standard Omni-Channel was retired in Summer '26 and that existing configurations carried over.
Turn on Enhanced Omni-Channel Routing
Choose queue-based or skill-based routing
Configure queues or skills and agents
Define routing configurations
Test with a sample case
The order of steps for a first-time Enhanced Omni-Channel setup
Standard Omni-Channel was retired in Summer ’26, and Salesforce upgraded orgs automatically during the rollout. Enhanced Omni-Channel, generally available since 2023, takes work items such as Cases, Leads, chats, messaging sessions and voice calls and routes them to reps based on availability, skills, capacity and priority. Existing routing configurations, queues, skills and routing rules were carried over. The feature requires a Service Cloud license or one of several add-on licenses, and it works only in Lightning Experience.
To enable it, go to Setup, then Feature Settings, then Service, then Omni-Channel Settings, and turn on Enhanced Omni-Channel Routing. The article describes three routing options: queue-based routing for smaller teams and simpler product lines, skill-based routing for complex cases that need specific expertise, and external routing for keeping logic in a third-party tool that connects through APIs. Enhanced Omni-Channel adds destinations including a queue, a skill, a specific rep and an Agentforce Service Agent.
Queue-based setup can be started with the guided flow under Omni-Channel Setup, which covers creating a queue, assigning agents and setting workload, followed by defining routing configurations. Skill-based setup is more involved: enable Omni-Channel and Field Service settings, create Skills, create active Service Resource records for agents with skill levels and dates, define Skills-Based Routing Rules through skill mapping sets, and confirm the routing configurations use those skills.
The article closes by describing the agent experience: the Omni-Channel Utility Bar item in the Service Console, where agents log in as available and receive incoming work with an audio notification. Its advice is to start with the simplest setup that covers the team, test with a sample Case, and add precision later.
You will learn how to reconcile source and target row counts for each object using Data Loader's success and error files, and how to find children with blank parent lookups or missing children per parent using SOQL.
Why read this
The examples are illustrative and were tested in LibreOffice Calc.
Count success and error rows
Compare with source and target COUNT()
Count children with blank parent
Compare children per parent
Reconciliation sequence for a finished load, from object counts to per-parent checks
After a Data Loader or Bulk API job finishes, a load can be short on rows or leave parent lookups blank even when every child is accepted. The article suggests reconciling counts per object using the job’s success and error files, along with the JobInfo fields numberRecordsProcessed and numberRecordsFailed when the Bulk API is used. It then compares those numbers with a SOQL COUNT() on the target object, and shows spreadsheet formulas to check that success plus error matches the source and that the target matches the success file.
The second step checks whether parents resolved. A SOQL COUNT() with a WHERE clause on a blank lookup field shows how many children have no parent, and a relationship query reads the parent name to inspect those rows. The author notes that a blank lookup may be legitimate on an optional field, so these rows should be treated as a review list rather than a failure.
The third step compares child counts per parent between source and target, using GROUP BY with COUNT on a shared external key, since record Ids usually change between orgs. A parent can look correct overall yet be short because some of its children were rejected. The example shows one parent with two children in the source and none in the target, flagged for review.
The article closes by noting that matching counts do not prove each child is attached to the intended parent, and that SOQL can only count records the user can see. It also advises removing personal fields before sharing exports. The piece ends with a promotion for a paid export review service, which is not part of the technique.
You will know how Salesforce Lead Assignment Rules evaluate entries, why a catch-all Queue matters, and the main ways to get round-robin distribution.
Why read this
You will also have a short checklist for testing before activation.
Lead is created with assignment flag set
Entries checked top to bottom
First matching entry sets the owner
No match: lead goes to catch-all queue
How a new lead is routed through assignment rule entries
Lead Assignment Rules route each new Lead to an owner as soon as it is created, which removes the slow and inconsistent manual triage that many teams rely on. The rule is a list of entries evaluated top to bottom, each with criteria and an owner that is a User or a Queue. The first entry whose criteria match wins, so the most specific entries must sit above the broader ones or they will never fire.
The article points out a common trap: rules only run when the record is created with the “Assign using active assignment rule” flag. The web-to-lead form, the API and Data Loader set this by default, but a manual record created in the UI does not unless the user ticks the box. It recommends structuring entries by territory first, then Lead Source, then score or company size, rather than writing one large entry per rep.
Every rule should end with a catch-all entry that sends unmatched Leads to a Queue rather than a named person, since a Queue is visible to the whole team and keeps working when someone is away. A growing catch-all Queue is a sign that criteria are missing a segment. Standard Lead Assignment Rules do not provide round-robin, so the options are a Queue that team members pull from, an autolaunched Flow that stamps a rotating owner using a counter field, or a third-party tool. The author suggests a Queue for most small teams because it is easier to audit, and notes that a Flow assigning owners should run in system context so creating-user permissions do not block it.
Before activating, create a test Lead for each entry and one that matches nothing, confirm each lands with the right owner, and check the web-to-lead path specifically. The article advises trialling the rule in a Sandbox against a week of real traffic before changing production.
You will know how to find Contacts with no Account using SOQL or a report, why such Contacts are private by default, and how to triage them before attaching any of them to an Account.
Query Contacts where AccountId is null
Compare count with source system
Label each row attach, private or investigate
Attach only reviewed Attach rows
Re-run null query and spot-check
Triage steps for orphan Contacts after a load
After a migration, a Contact can keep all its field values and still have a blank AccountId. That is an orphan, which differs from a wrong-parent Contact whose AccountId points at the wrong company. The article notes that Salesforce Help says Contacts not linked to an Account are private, visible only to the owner and to administrators with View All Data or Modify All Data, and not governed by Contact Sharing Rules. It lists example causes such as Accounts loaded after Contacts or a failed parent lookup on insert, while stressing that a blank AccountId is one finding to be assessed rather than a diagnosis.
The query is a SOQL statement filtering on AccountId = null, optionally combined with an External ID field to narrow to migration-loaded records, and a count can be compared with the source system’s count of Contacts without an account. The same set can be produced from a Data Loader export or a standard report. The author recommends a triage step that labels each row as attach, leave private or investigate, never attaching the whole list automatically, matching on Contact Id, and re-running the null query after updates.
The piece closes with its limits: intentional private Contacts are normal, a null check cannot detect a wrong parent, and users without View All Data may under-count what they can see. It also promotes a paid CSV comparison tool for wrong-parent checks.
You will learn how to choose between the Data Import Wizard and Data Loader, what the most common import error messages mean and how to fix them, and why duplicate-rule matches and skipped automation can make a successful import look wrong.
Data Import Wizard
Runs in the browser from Setup
Up to 50,000 records per load
Objects the wizard lists in Setup
Results in Recent Import Jobs
Data Loader
Desktop app, Java 17 or later
Up to 150 million with Bulk API 2.0
All objects, including Custom Objects
Success and error CSV files per run
The Data Import Wizard and Data Loader differ in where they run and how far they scale
The article starts by separating the two import routes. The Data Import Wizard runs in the browser from Setup, suits smaller loads under 50,000 records on supported objects, and is the easier starting point. Data Loader is a desktop application that needs Java 17 or later, covers all objects including Custom Objects, supports upserts, deletes and scheduled command-line loads, and is the route to take when a file outgrows the wizard.
Most failures come from the file rather than the tool. The article walks through the usual causes: a missing required field such as Last Name, values that do not match a picklist exactly, inconsistent date formats, and values longer than the field allows. It explains that duplicate errors can fire against existing Contacts or Accounts because standard matching rules compare names and contact details by similarity, so the record to update may already exist under another Record Type. It also notes that automation can be skipped unless the trigger-workflow option is ticked, and that existing triggers or Validation Rules can reject mixed batches, which a split-by-value approach can work around. Import jobs run from a queue, so admins check Recent Import Jobs and Bulk Data Load Jobs for status and failure reasons, and users should check List Views, ownership and failed rows before re-importing.
The piece also covers fields missing from the mapping list because of page layout or field-level security, the permission needed to import Custom Objects, and the limits of imports, which cannot merge existing duplicates or change matching rules. The closing sections promote the author’s own tools, which the reader should weigh accordingly.
You will learn how to create and save Flow test scenarios, add assertions and mock external action outputs, and why these tests are not yet enforced at deployment.
Why read this
The piece also notes that FlowTest is a separate metadata type to include when deploying.
Save Test Scenario with inputs
Enable Automated Test Scenario
Add assertions and mock outputs
Run All for coverage and results
How a saved Test Scenario runs automatically with assertions
Salesforce’s Winter ’27 release introduced Flow Test Mode, a dedicated testing canvas for Autolaunched and Record-Triggered Flows that is currently in beta. It is enabled through the Process Automation Settings page in Setup, and the author recommends trying it in a sandbox first. Within the new canvas, builders can debug by record Id or name, test primitive collection variables by separating values with semicolons, and save reusable Test Scenarios with labels, descriptions and run options such as rollback mode. Scenarios can be run manually or set to automatic, with assertions checking expected results, such as whether an element was visited or a field has a given value, and with the choice of which flow versions to test. Mock outputs let builders supply fabricated responses for external action elements, so tests can run without calling the endpoint and can force success or fault paths.
The author highlights practical uses: rerunning a scenario that reproduces a bug until it is fixed, using saved assertions for regression testing after org changes while watching coverage and results, and testing integrations without configuring live connections. He also explains deployment: FlowTest is its own metadata type, separate from the flow, so tests must be packaged and deployed individually. Currently a flow can be deployed without its tests, making them a nice-to-have rather than an enforced requirement as Apex tests are, and the author hopes enforcement will come once the feature reaches general availability.
The piece concludes that Flow Test Mode still falls well short of Apex testing, which requires at least 75% coverage before production deployment and cannot be bypassed, while flows can currently be built directly in production. Mock outputs are a point-and-click analogue of Apex’s HttpCalloutMock approach, and the Test Discovery API can run Apex and flow tests together. Overall, the author sees the feature as a significant and promising step for Flow, though it is still in beta.
You will learn what each of Record Types, Profiles and Permission Sets is for, and how to decide which one fits a given requirement.
Why read this
The article also explains why Record Types are not a security control.
Record Type
Different business processes
Controls picklist values per process
Not a security control
Permission Set
Grants additional access
Assigned to selected users
Field and object permissions
Each tool solves a different problem, so match the requirement to the right one
This Salesforce Ben article helps admins decide between Record Types, Profiles and Permission Sets when a new requirement arrives. It explains that Record Types support different business processes for the same object, controlling available picklist values through Sales Processes and working with Page Layouts. It stresses that Record Types are not a security mechanism, since assigning one does not govern which records or fields a user can see or edit, and that restricting Record Types does not block access to existing records using other types.
Profiles, which every user has exactly one of, are described as the baseline for a user’s experience, covering login hours, IP ranges, password and session settings, default apps, default Record Types and Page Layouts. Permission Sets add access on top of that baseline, and a user can hold several of them; Permission Set Groups bundle commonly paired sets together. The article notes Permission Sets generally grant rather than remove access, and that a muting Permission Set inside a group only suppresses permissions from other sets in that same group, not those from the Profile or outside the group.
A decision table maps requirements to starting tools, and the article warns that one requirement may need several tools working together. It walks through worked examples: sales-process picklists suit Record Types, a handful of users needing a feature suits a Permission Set, and hiding fields from a Page Layout does not secure them, so field-level security is needed. It closes with five anti-patterns to avoid, including creating a Profile per department, using Record Types for security, duplicating Profiles in Permission Sets, ignoring Record Types in layout design, and letting Permission Sets sprawl, along with a set of questions to ask before configuring. The article also notes that Salesforce’s retirement of Profile-based permissions was cancelled in June 2026, while it still recommends a permission-set-led approach.
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.
Automated Flow stage
Interactive Screen Flow stage
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.
You will learn how to snapshot dependent picklist values per Record Type from the UI API and run a local preflight that flags CSV rows whose controlling and dependent values do not fit the intended target configuration.
Why read this
The piece is clear that findings are review prompts, not proof of import rejection.
Save per-record-type dependent picklist response
Preserve exact API values in the CSV
Run local preflight against saved metadata
Review each non-match row with its owner
The preflight runs in four stages before any row is trusted
The article argues that dependent picklist checks must be made on the pair of controlling and dependent values for the target Record Type, since a value valid in one Record Type may not be valid in another, and checking each column against a global list misses this. It recommends saving the dependent field response from the UI API object-info endpoint for each intended target Record Type, recording the org, API version and access scope, and keeping API values rather than translated labels.
A Python 3 standard-library script is provided that reads the saved metadata and a CSV, then assigns each row a status such as CONFIG_MATCH, COMBINATION_NOT_AVAILABLE, VALUE_NOT_AVAILABLE_FOR_TYPE, UNKNOWN_CONTROLLER or REVIEW_BLANK. The worked example with invented fields shows one match and five rows for review, and the script deliberately treats malformed or incomplete metadata as a review case rather than a pass.
The author is explicit about limits: the snapshot reflects UI-available combinations for the reader’s access, not full server validation, and required fields, Validation Rules, Flows, field-level security and import-path behavior still need separate review. The approach is scoped to a single confirmed controlling and dependent single-select pair.
You will learn what Builder Central does beyond Setup with Agentforce, how its metadata visualizations and preview orgs protect your org, and the steps to enable the beta.
Describe the app or agent in plain language
Answer clarifying questions
Review metadata and test in preview org
Deploy to sandbox via Lifecycle Center
Builder Central takes a solution from plain-language idea to sandbox deployment
Builder Central is a new no-code experience in beta that lets admins build and deploy apps and agents from plain-language prompts. It works as one hub for work that would otherwise be spread across Setup and several builders, and it draws on the org’s existing data model, configuration, security and permissions so that what it creates fits the business and inherits access controls.
The article distinguishes it from Setup with Agentforce, which makes direct, simple administration changes such as creating a field. Builder Central targets larger builds like full data models, flows and agents. It asks clarifying questions before building, deploys through Lifecycle Center, and complements Flow Builder, Lightning App Builder and Agentforce Builder rather than replacing them.
To keep orgs safe, it offers interactive metadata visualizations for reviewing generated components and ephemeral preview orgs, temporary clones of a sandbox, where solutions can be tested before anything is published. To start, admins grant the Access Builder Central user permission, enable the beta feature and activate the Metadata Experts MCP Server in Setup, ideally in a Developer or Developer Pro sandbox.
You will learn how national e-invoicing rules in Germany, Belgium and France differ and what each means for Salesforce invoice data, configuration and exchange channels.
Why read this
The article also outlines a readiness checklist for a multi-entity org.
ZUGFeRD
XML embedded in the PDF
Human-readable PDF included
XRechnung
Structured XML file
No PDF included as part of format
Germany's ZUGFeRD and XRechnung formats differ in how they carry structured data
The article argues that a Salesforce team cannot treat European e-invoicing as one rule set. Each legal entity and transaction must first be checked against the applicable country’s deadlines, structured format and exchange method. Germany’s ZUGFeRD and XRechnung, which have transition periods running through 2026 and 2027, are contrasted with Belgium’s mandatory Peppol-based structured invoicing from January 2026 and France’s phased platform-based model starting in September 2026.
For the Salesforce implementation, the author recommends mapping the regulatory scope, defining the required output and exchange method, auditing that the needed seller, customer, tax, line-item and reference data exists at generation time, and adding controls with Validation Rules, Flow or Apex. The lifecycle should also cover receiving incoming e-invoices and handling corrections.
The piece then shows how the Finblick application on AgentExchange supports these needs with Legal Entity records, Matching Rules tied to Tax Rules, ZUGFeRD and XRechnung generation from the Invoice record, and Credit Notes for corrections. It closes by recommending testing across entity, country, VAT and correction combinations, and ongoing review as national rules change.
You will learn what Salesforce Go is, which editions and permissions it needs, and how Feature Sets, Features and feature monitoring work in its setup dashboard.
Why read this
It is a practical orientation for admins adopting it.
Turn on the feature
Configure the setup steps
Monitor it once completed
Enabling a feature from Salesforce Go follows three stages
Salesforce Go began as Sales Cloud Go to help Sales Cloud admins enable new features, and its scope now covers all Salesforce feature setup. It is found in the Setup menu, and it is available to users with the View Setup and Configuration permission in several editions with Service Cloud. Additional permissions may still be needed depending on the feature being enabled.
The dashboard groups cards into Agents, Features and Feature Sets, and each Feature Set bundles the features that work toward one outcome, such as the Capture & Auto-Qualify Leads set. Each feature links to Salesforce Help, and includes snapshots, videos and a Copy Details option for sharing with stakeholders. The author walks through turning on Sales Engagement from the dashboard, then configuring access with a Manage button or a Go to Setup button where the task lies elsewhere.
Once a feature is marked Completed, Salesforce Go can also be used to monitor it, manage its configuration, assign permissions and track license consumption where applicable.
You will learn what Salesforce Health Insights does, its two pillars of Product Adoption and Implementation Health, and who can access it in the Winter '27 release.
Why read this
The piece stays at the level of an overview and does not explain how to configure it.
Scan org configuration and usage
Evaluate against benchmarks
Rank findings by severity
Deliver next best actions
How Salesforce Health Insights turns an org scan into next actions
Salesforce Health Insights is a Salesforce-native solution that scans an org, evaluates it against benchmarks, and turns the findings into prioritized next best actions. The article presents it as a way to replace a manual org health review, which it says can take up to three weeks, with an on-demand scan that returns ranked results in near real time. The recommendations are built from the org’s own configuration, feature set and usage patterns, and ranked by criticality and the effort needed to fix them.
The tool has two pillars. Product Adoption shows which licensed capabilities are owned, which are used, and where there is room to grow, including license utilization over the past 30 days. Implementation Health delivers severity-ranked insights across Security and Process Automation, with recommendations meant to reduce exposure and prevent automation failures. The article also describes a headless delivery model, with a conversational view inside Salesforce and access through Slackbot outside it.
According to the article, Salesforce Health Insights is available with the Winter ’27 release for Signature Success Plan customers on Core products at no extra cost, and is found by searching for it in the App Launcher. The piece is a product announcement written by Salesforce and gives no detailed configuration steps or measured results.
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.
You will learn how to define an Apex row type, return it from an invocable action and bind it to a Screen Flow Data Table with a Unique Identifier, avoiding helper objects.
Why read this
You will also learn the current limit that inline editing is not yet supported.
Define row class with @AuraEnabled fields
Return list from invocable action
Store output in Apex-typed collection variable
Bind to Data Table with Unique Identifier
How an Apex collection reaches a Screen Flow Data Table
Since Winter ’26 (API 65.0 and later), a Screen Flow Data Table can take a collection of an Apex-defined type as its Source Collection. Choosing a field as the Unique Identifier lets the table treat each item as a record, so users can select rows and the flow can reuse them. Display and selection work now, but inline editing for these collections is still pending.
The article contrasts this with older workarounds: creating a Custom Object that mirrors the Apex class, inserting and deleting temporary records, using a Transform element, or building a custom Lightning Web Component. Each works but leaves extra metadata to maintain. The walkthrough shows a sample FxRate class with @AuraEnabled fields, an invocable GetFxRates action that wraps the list in a result class, and the flow wiring that stores the output in a collection variable and feeds it to the table.
The author advises choosing a stable, unique key such as a record Id, an ISO currency code or a business key as the Unique Identifier, and generating one in Apex if the source has none. The pattern suits currency or stock quotes from an external API, financial calculations resolved in Apex, and batch results that should not be persisted.
You will learn a four-step pre-build method for mapping and mocking up Lightning pages and Screen Flows with stakeholders, and when to choose Dynamic Forms over a Screen Flow.
Why read this
You will also see how to turn the approved prototype into a field dictionary and Gherkin acceptance criteria.
Map the process swimlane
Prototype the record page in SLDS
Test visibility and edge cases live
Export data dictionary and Gherkin
The four steps from discovery to a spec ready for sandbox configuration
The author opens with a familiar failure: a discovery workshop produces a requirement that is then built in a Developer Sandbox over two days, only to be reworked after a playback call. He argues that the gap is stakeholders not being able to picture how a written user story becomes a real Lightning page or Screen Flow until they see it, and that generic tools fall short. Written stories, Figma or Miro canvases, and prototyping in a sandbox each fail for Salesforce in different ways, so the prototype should stay within SLDS constraints.
The method starts with mapping the process swimlane using Universal Process Notation, identifying the trigger, decision gateways, and whether the user needs a guided wizard or persistent fields with conditional visibility. A rule of thumb is given: use Dynamic Forms with Path guidance for ongoing single-record updates with a few conditional fields, and a Guided Screen Flow for multi-step wizards, related child record creation or verification before advancing a stage. The prototype is then reviewed across four zones of the Lightning page: the Highlights Panel, Path stages with guidance text, two-column detail sections, and sidebar Related Lists.
The author then recommends testing conditional visibility and edge cases live, including negative paths, persona-based editability, and console density. Finally, the approved prototype is converted into a field-level data dictionary and Given/When/Then acceptance criteria before any sandbox configuration begins. The approach is presented as a 15-minute pre-sandbox routine, though the article is aimed mainly at admins and business analysts.
You will know when a value needs a roll-up summary, a Formula Field, or a Flow or Apex alternative, based on relationship type and the shape of the calculation.
Why read this
The piece ends with a short decision checklist.
Roll-up summary
Aggregates child records
Master-detail only
Recalculates on child change
No lookup relationships
Formula Field
Uses one record's fields
Lookup or master-detail
Recalculates on each view
Never stale at read time
Roll-up summaries and Formula Fields differ in what they calculate and where they work
The article distinguishes roll-up summary fields from Formula Fields. A roll-up summary sits on a parent record and aggregates its child records through count, sum, min or max. It works only on master-detail relationships and recalculates when a child changes. A Formula Field calculates from a single record’s own fields and related parent fields, recalculating each time the record is viewed, and works on both lookup and master-detail relationships.
Roll-ups suit jobs such as counting open cases on an account or summing opportunity amounts, and they stay accurate without extra queries or flows. Their limits are basic filter criteria, no more than one relationship level, and no support for lookup relationships. Formulas suit record-level logic such as age fields, name concatenation or flags driven by a few fields. The trap is formulas that reach across many objects, which become hard to read and can slow List Views and reports on large data volumes.
The article closes with a checklist: many children into one parent number points to a roll-up, a value derived from the record itself points to a formula, a lookup relationship needs Flow or similar tooling, and complex filtering or cross-object aggregation needs Flow or Apex.
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.
Map the CSV onto an object
Simulate rows in a rolled-back transaction
Fix refused rows and simulate again
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.
You will learn how Builder Central plans and builds a Custom Object, List View and Permission Set from a plain-language prompt, what it leaves for the Admin to finish, and how it fits beside Lightning App Builder and Flow Builder.
Describe the app in a prompt
Review the project plan
Build in a separate workspace
Publish to the org
Assign the Permission Set
The order in which Builder Central moved the Bulk Delivery Management app from prompt to live use
The author tested Builder Central, a beta conversational workspace for planning, building, previewing and deploying Salesforce apps and agents from plain language. He described a spreadsheet replacement app in one prompt, naming a Custom Object and its fields, and Builder Central first produced a project plan for review before building anything in its own separate workspace.
After the initial build it suggested extra customization, such as a List View, which he accepted. He published the app, asked Builder Central to assign the Permission Set to his user, and then opened the app from the App Launcher. The build took about 12 minutes in real time, though he sped up parts of the video.
The result was not complete: the record page did not show all fields, so he adjusted it in Lightning App Builder. He argues the change matters less for saving time than for shortening the loop between requirements meetings and a working prototype, while Admins still own permissions, automation, user experience and testing. He recommends trying it in a sandbox, recreating an existing app conversationally, and checking the beta limitations.
You will learn why matching field values is not enough to verify a migration, and how to test each Contact's parent Account through a stable external key, using either pandas or Google Sheets formulas.
Source Contact to its source Account ID
Source Account ID to its stable key
Target Contact to its target Account ID
Compare the two Account keys
The check follows each Contact's parent Account through the stable key to the target org
A Contact can keep its name and email after a migration and still be attached to the wrong Account. Comparing field values will not catch this, and record IDs usually change between orgs, so they cannot be compared directly either. The article proposes a stable key, such as an External ID field, that identifies the same Account in both exports. The check follows the Contact’s source Account to its key, then confirms that the target Contact’s Account has the same key.
The article works through a small set of invented example CSVs. A pandas script merges the Contacts, maps each parent through the keys, and flags a WRONG_PARENT result for one Contact whose target Account points to the wrong record. The same logic is then rebuilt as Google Sheets formulas using INDEX and MATCH, with uniqueness checks on the keys and an EXACT comparison because MATCH is case-insensitive.
The author notes practical cautions for real exports. Lookups that return errors should be investigated rather than hidden with IFERROR, and the ranges must be widened for larger files. The check only verifies the relationships in the files loaded, so it does not certify a whole migration.
You will know five design choices to settle before activating a Scheduled Flow: run window, repeat-safety, batch sizing, failure handling and run context.
Why read this
The article is a practical checklist rather than new platform information.
Pick a quiet run window
Make repeat runs safe
Size batches for volume
Catch failures loudly
Confirm the run context
The five timing decisions to settle before activating a Scheduled Flow, in order
The author argues that a Scheduled Flow should be designed around timing, since nobody watches it run. The run window should avoid overnight integrations, data loads and backups that might lock the same records, so admins should check scheduled Apex jobs and ask integration owners before choosing a start time.
Because a daily Scheduled Flow re-evaluates its entry criteria on every run, records that still qualify will be processed again. The article recommends a flag field, a date stamp or a processed checkbox so that updates happening once are not repeated, and it treats batch sizing as a deliberate design decision, warning that a Flow tested on fifty records can hit governor limits at fifty thousand.
The piece also covers failure handling, which is quieter than for Record-Triggered Flows, and run context, since Scheduled Flows run in system context by default and bypass Sharing Rules and field-level security. It closes by suggesting a monthly review of every active Scheduled Flow as business rules and fields change.
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.
Data element fails
Fault Path runs
Log failure record
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.
Readers will learn six ready-to-use Validation Rule formulas that prevent common data entry mistakes, along with best practices for writing clear field-level error messages.
User enters or edits a record
Validation Rule formula is evaluated
Bad data is blocked with a clear error
Error appears at the field level
How a Validation Rule stops bad data before it is saved, using the article's approach
The article outlines six Validation Rule patterns designed to catch frequent user errors without requiring Apex or Flow. These include preventing Closed Won Opportunities from missing amounts or close dates, blocking Cases with backdated open dates beyond a seven day window, and ensuring close dates never precede creation dates.
Additional patterns address picklist state management by stopping records from reverting to New once closed, unless a custom bypass permission is granted. The piece also requires a reason field when priority changes to High status, and locks amount fields during approval reviews to prevent revenue leakage.
Beyond the formulas, the author emphasizes error message hygiene. Rules should be named clearly, descriptions filled out for audits, and errors placed at the field level rather than the page header. Messages must instruct users on the correct action instead of simply stating an invalid value. The author notes that while Validation Rules stop immediate data issues, field level required attributes or Flow notifications may be better alternatives for certain workflows.
You will learn how to connect your Salesforce org to Slack and configure the Slackbot UI system permission so users can access the agent directly in Lightning Experience.
Connect Salesforce org to Slack workspace
Create a Permission Set for Slackbot
Enable the Slackbot UI system permission
Assign the Permission Set to users
The setup sequence for giving users access to Slackbot in Salesforce Lightning
The article outlines the configuration steps required to make Slackbot available inside Salesforce Lightning Experience. Before any user-facing features can be enabled, administrators must link their Salesforce org to a Slack workspace through the Manage Slack Connection setting and accept the pending request.
Access is controlled via a dedicated system permission called Slackbot UI. Administrators create a Custom Permission Set, navigate to System Permissions, check the box for the Slackbot UI capability, and save the changes. The Permission Set is then assigned to individual users or groups who require access.
Best practices emphasize validating the connection in a Sandbox first, using a dedicated Permission Set for easier auditing, and setting assignment expiration dates for pilot phases. The guide also notes that using Slackbot may require Flex Credits approval from a Salesforce administrator, and recommends verifying that the agent respects existing object and field-level security before full deployment.
By Yumi Ibrahimzade · Salesforce TimeThe guide explains the manual entry workaround and advises validating the behavior in your own org before deploying to production.
You will learn how to send emails through Salesforce Flow using an Organization-Wide Email Address configured exclusively as a default no-reply sender.
Why read this
The guide explains the manual entry workaround and advises validating the behavior in your own org before deploying to production.
Add an Action element and select Send Email
Set Sender Type to OrgWideEmailAddress
Type the address into Sender Email Address
Or pass a Text resource holding the address
How to send a Flow email from a Default No-Reply Address without changing its purpose
Salesforce Flow hides Organization-Wide Email Addresses that are configured strictly as default no-reply senders. While changing the address purpose to allow user selection works, it modifies existing configurations that may rely on the restricted setting.
The recommended approach bypasses the dropdown menu entirely by typing the exact email address directly into the Sender Email Address field. A Text resource holding the address can also be passed to the same field. Salesforce documentation supports using Text resources to supply Organization-Wide Email Addresses, which makes this method functionally sound.
The author notes that this behavior acts as a tested workaround rather than an officially documented exception for default no-reply addresses. Readers should verify the flow in a test environment to ensure consistent email delivery before implementing it in live business processes.
You will learn how to distinguish between email formatting checks and actual deliverability verification, and how to build a reliable workflow using Custom Fields, flows, and external APIs.
Why read this
The piece outlines trigger points, error handling, and monitoring metrics to maintain CRM data quality.
The article distinguishes between email validation, which enforces syntax through a Validation Rule, and email verification, which confirms domain existence, mail server configuration, and mailbox deliverability. Standard format checks cannot prevent bounces or identify disposable addresses.
It recommends placing verification at record creation, during field updates, or through bulk cleanup processes. A practical workflow involves creating a Custom Field, defining trigger events, calling an external verification service via API or managed package, and applying business rules to route verified, invalid, or risky addresses accordingly.
Developers are advised to handle inconclusive results gracefully, avoid redundant processing, maintain audit trails, and respect consent and privacy requirements. The author notes that while custom integrations offer flexibility, native applications can reduce maintenance overhead, and ongoing monitoring of bounce rates and verification metrics ensures the workflow actually improves data quality.
Readers will learn the confirmed deadlines for mandatory multi-factor authentication and phishing-resistant requirements, along with how Salesforce plans to handle extension requests for non-compliant accounts.
Salesforce has clarified its ongoing multi-factor authentication rollout after conflicting messages caused confusion among customers. The company reaffirmed that mandatory multi-factor authentication remains required for all users by June 2026, with production enforcement beginning on July 20. Administrators and users with elevated permissions must use phishing-resistant methods.
Recent reports suggested enforcement might be delayed indefinitely or pushed past late October, but Salesforce explicitly stated there are no open-ended postponements. The platform is currently collaborating directly with a small group of customers who previously received extensions and require additional time to complete their security configurations.
A tool expected by mid-October will allow organizations to request ninety-day extensions for non-compliant users. Salesforce notes that over ninety percent of customers have already adopted the required controls and will contact any remaining accounts directly to ensure compliance within the next six to eight months.
Readers will learn which Winter '26 updates improve daily admin workflows, including multi-column List View sorting, enhanced Flow debugging, and localized report labels.
Winter '26 release
List Views
Flow Builder
Reporting and dashboards
Main update categories in the Winter '26 Salesforce release
The Winter ’26 release introduces several quality of life improvements for administrators, starting with List Views. Users can now sort records by up to five columns simultaneously, each set to ascending or descending order. Configuring this stays persistent until manually reset. Field pickers within List View controls also support type ahead search, allowing admins to quickly locate fields by typing characters and using keyboard shortcuts.
Flow Builder receives substantial updates to streamline automation design and management. Decision elements can now leverage Generative AI to analyze unstructured data and route records based on tone or urgency. Flows can automatically trigger when files attach to records, and newly created records can be referenced immediately without additional query elements. Debugging becomes easier with a resizable side panel and card based results that jump directly to canvas elements. Administrators can also compare flow versions side by side to track changes across autolaunched, scheduled, and record triggered types.
Reporting and dashboard capabilities expand with localization and security features. Labels for reports and dashboards can now be translated through the Translation Workbench, covering widget titles and footers. Exported reports include a beta option to block spreadsheet formula interpretation, preventing accidental execution of malicious strings. Dashboard charts in Lightning Experience will soon support reference lines, mirroring functionality previously limited to report charts. The author recommends testing these updates in a sandbox before production deployment.
Readers will learn the exact steps to configure the Sales Cloud for Slack integration and route a Screen Flow into a Slack channel or direct message without leaving their messaging app.
The article outlines a method for running a Salesforce Screen Flow inside Slack by leveraging the Sales Cloud for Slack application. It begins with the prerequisite one-time connection between the Salesforce org and a Slack workspace, followed by assigning a Permission Set that includes system permissions for managing Slack app organization connections and user mappings.
Administrators must enable the Sales Cloud for Slack feature in Setup and install the corresponding app in their Slack directory. Once connected, creators can design a standard Screen Flow in Flow Builder and activate a hidden advanced setting labeled Make available in Slack during the save process.
To actually trigger the flow, a second autolaunched or Record-Triggered Flow acts as an invoker. This parent flow uses an action element to call the enabled Screen Flow, passing a Slack conversation identifier to determine whether the interactive button appears in a public channel or a private direct message. The piece concludes by noting that Salesforce automatically generates a background action for each enabled flow and advises clear button labeling for end users.
Readers will learn how to configure mass Screen Flow actions in List View layouts, restrict List View sharing without granting broad permissions, and enable Field History Tracking on the User object.
Delivered IdeaExchange Features
Flow Quick Actions in List Views
Manage Shared List Views Permission
Inline Editing on List Views
Field History Tracking for Users
Restart Superbadge Progress
Five long-requested IdeaExchange ideas finally shipped in recent releases
The latest IdeaExchange updates highlight several features delivered in Winter ’27 and Summer ’26 that resolve long-standing administrative limitations. Administrators can now execute Screen Flow actions against multiple records selected in List View layouts or Related Lists by passing record identifiers into a text collection variable, eliminating the need for custom components or workarounds.
A new Manage Shared List Views permission replaces the broad Manage Public List Views requirement, allowing targeted sharing without exposing all public views across the organization. Winter ’27 also removes the restriction preventing inline editing in List Views containing multiple record types, though administrators must manually activate the setting in User Interface Settings and test it carefully due to varying Validation Rules and picklist values.
Field History Tracking is now available for the User object, monitoring up to twenty fields such as profile, role, and manager changes for eighteen months. The article also notes that Trailhead Superbadges can now be restarted after completion, supporting skill reinforcement rather than single-use certification, while additional roadmap items like dark mode and Opportunity restriction rules remain in development.
By Andy Engin Utkan · Salesforce BreakThe piece explains how this change reduces visual clutter, optimizes governor limits, and enables in-memory sorting and filtering.
You will learn how the new Collection Filter Criteria Resource moves collection filtering out of the Flow canvas and into reusable resources.
Why read this
The piece explains how this change reduces visual clutter, optimizes governor limits, and enables in-memory sorting and filtering.
Collection Filter Criteria
Configured via Manager tab
Returns only first match
Eliminates extra Loop steps
Supports child relationships
Collection Filter and Sort
Placed directly on canvas
Returns full record collection
Requires additional Loop steps
Standard element configuration
Comparison of the new Collection Filter Criteria resource against existing Flow elements
Introduces the Collection Filter Criteria Resource as a Winter ’27 preview feature that shifts collection filtering from canvas elements to the resource manager. It replaces the traditional Collection Filter node, allowing administrators to define dynamic filter conditions and sort orders directly in memory without triggering additional SOQL queries or DML operations.
Explains the practical benefits, including cleaner Flow Builder canvases and optimized transaction limits. Multiple distinct filter views can now point to a single source collection, eliminating sequential logic and reducing visual complexity while speeding up execution across screen and autolaunched flows.
Covers advanced integration with Apex defined variables, noting that future updates will allow filtering based on child relationships within custom data structures. This capability aims to remove unnecessary loops during collection processing and hints at upcoming list and map functionality resembling native Apex collections.
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.
By Rohan Mehta · dev.toThe piece outlines best practices for temporary access scenarios and highlights important considerations for compliance and user communication.
You will learn how to configure automatic expiration dates on Permission Set assignments and manage them individually or in bulk.
Why read this
The piece outlines best practices for temporary access scenarios and highlights important considerations for compliance and user communication.
Old Method
Manually remove permissions later
Trust memory or calendar reminders
Use deprecated session-based activation
New Automation
Set expiration on Permission Set assignments
Choose fixed dates or relative day counts
Automatically lapse access for clean audits
Contrasting manual permission revocation with automatic expiration dates
Salesforce now allows administrators to set expiration dates directly on Permission Set assignments, eliminating the need for manual revocation of temporary access.
Administrators can configure expirations when adding individual assignments or use the Manage Assignment Expiration action in Setup for bulk updates. The system supports both fixed calendar dates and relative day counts for recurring temporary needs.
The feature benefits contractors, project teams, and compliance audits by ensuring access lapses automatically. The author warns that expiration happens silently, recommends automating recurring assignments with Flow, and notes that this model replaces the deprecated session-based activation approach.
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.
By Adam White · Salesforce Admins BlogYou will also understand upcoming capabilities like element mocking, test coverage tracking, and Agentforce powered troubleshooting.
You will learn how to enable and use the new Test Mode beta to save, reuse, and automate Flow validation without leaving the builder.
Why read this
You will also understand upcoming capabilities like element mocking, test coverage tracking, and Agentforce powered troubleshooting.
Traditional Approach
Debug button only for troubleshooting
Testing and debugging require separate actions
Manual checks lack reusable configurations
Cluttered design canvas during validation
Test Mode Workspace
Dedicated view replaces Debug button
Merges debugging and automated testing
Saves runs as reusable manual test scenarios
Converts manual tests to regression tests with assertions
How Test Mode consolidates Flow debugging and automated testing
Salesforce has released a beta version of Test Mode, a dedicated workspace that replaces the traditional Debug button in Flow Builder. This update merges debugging and automated testing into a single interface, requiring administrators to enable the feature through Process Automation Settings before it becomes available for Record-triggered and autolaunched flows.
The new workspace allows builders to save execution runs as reusable manual test scenarios. These saved configurations preserve triggering records, input variables, and mocked outputs. Administrators can now supply static record identifiers for poorly searchable objects and populate primitive collections directly in the test panel. Once validated, these manual scenarios can be transformed into permanent regression tests by attaching expected results.
Test Mode also introduces element mocking, which simulates outputs for subflows and external actions to keep testing isolated from live endpoints. The roadmap includes Winter ’27 enhancements such as visual test coverage tracking on the canvas and Agentforce powered capabilities. These future features will synthesize transaction context to diagnose cross automation failures and automatically generate comprehensive test scenarios with isolated data silos.
You will learn how to query the Recently Viewed object, merge its results with parent records using the Transform element, and sort the combined data for display in a Screen Flow.
Why read this
This approach replaces the missing native sorting capability in Flow Builder.
The article addresses the limitation of Flow Builder when trying to replicate the standard Recently Viewed List View, noting that direct sorting by view date is unavailable through standard Get Records elements. It introduces the Recently Viewed object as the underlying source that tracks records accessed by each user without requiring explicit user filtering.
The author demonstrates a six-step process starting with a Get Records element to fetch Recently Viewed entries filtered by the Account type. A Transform element extracts the record identifiers, which are then used in a second Get Records element to retrieve full Account data.
Because the original view date field resides outside the Account collection, another Transform element joins the two datasets using the record identifier as the key. The merged collection is subsequently ordered by the Last Viewed Date field using a Collection Sort element before being rendered in a Data Table component.
You will learn how to create tag categories, assign multiple tags to records, and filter your automation inventory using the dedicated Automation App interface.
Why read this
This approach replaces reliance on naming conventions and long Setup menus for faster flow management.
The Winter ’27 release introduces Flow Tags to help administrators manage rapidly growing automation inventories. This feature provides a flexible categorization method that moves beyond relying solely on flow names or folder structures.
Users must navigate to the Automation App to establish Tag Categories such as Business Area or Purpose. Once categories exist, administrators can add reusable tags and apply them to individual flows through row-level actions or directly within Flow Builder during the save process.
The primary value emerges when searching the platform. Administrators can display a Tags column in List Views, filter results by single or combined labels, and open any tag record to see a Related List of associated automations. This entire workflow operates exclusively within the Automation App and does not function from the standard Setup menu.
Readers will learn how to use the new Group Element in Flow Builder to visually organize related components and collapse sections for better navigation.
Why read this
The feature simplifies maintenance without altering execution logic.
Complex Flows often become difficult to navigate as they grow in size and handle multiple processes. Salesforce has introduced a Group element that lets administrators place related components inside a single container directly on the canvas. This visual organization makes it easier to locate specific logic and understand the overall structure.
Users can collapse these containers to hide detailed steps and reduce screen clutter while working on other areas. Expanding the group restores the full view when review or editing is required. The arrangement exists solely for layout purposes and does not modify how the automation runs.
The element supports standard editing operations such as cut, copy, paste, and ungroup. These tools allow teams to quickly restructure diagrams or duplicate entire logical blocks when replicating similar processes elsewhere in the same automation.
A step-by-step setup for the Winter '27 feature that passes the records a user selects in a List View or Related List into a Screen Flow.
Build Screen Flow with ids variable
Create Flow action on the object
Add to List View Button Layout
Add to Dynamic Related List – Single
Setup for running a Screen Flow on selected records
Starting in Winter ’27, users can select several records in a List View or a Related List and hand them to a Screen Flow that opens in a modal. The article treats it as an overlooked part of a large release because it lets admins build mass actions without code.
The setup has one detail that is easy to miss. The flow needs a text collection variable named ids, in lowercase, marked as available for input. The selected record Ids arrive in that variable. The example flow gets the matching Contacts, shows them in an editable Data Table on a screen, and writes the edits back with an Update Records element, with fault paths on the data elements.
To expose it, create an action of type Flow on the object and add it to the List View Button Layout under the Lightning Experience List View actions. For Related Lists, create the same kind of action, then add it to a Dynamic Related List – Single component on the parent’s Lightning Record Page.