The independent daily for Salesforce admins, developers and architects

Curated by Abhinav (opens in a new tab)

Platform App Builder exam refresh puts more weight on Flow and Agentforce (opens in a new tab)

You will learn what the August 2026 refresh of the Platform App Builder exam changed, including the heavier Flow focus and the new Agentforce coverage, and how to adjust your study plan accordingly.

  • 63%: Previous pass rate
  • 73%: Pass rate after the refresh
  • 32%: Share of exam for Business Logic and Process Automation
The exam refresh moved the pass rate up by ten percentage points

The Certified Platform App Builder exam was refreshed on August 21, aligned to the Summer ’26 release, and its pass rate moved from 63% to 73%. According to a podcast interview with Salesforce’s Alexis Kingma, the largest change is depth on Flow. Candidates are now asked to choose the right flow type for a scenario, troubleshoot a broken flow, and maintain and monitor flows over time, rather than simply show they can build one.

Agentforce is also included, but framed as one automation tool within the app builder’s toolkit rather than as a specialist topic. Candidates should recognize when it is an option and when reaching for it makes sense. Salesforce said the passing score was set using the Angoff method, in which a panel of experts estimates how many minimally qualified candidates would answer each question correctly. A higher passing score therefore means the panel expected a borderline candidate to get more questions right, which the author reads as a higher bar for the role.

The author advises budgeting time for Flow troubleshooting and monitoring, studying Agentforce under the Business Logic and Process Automation section (32% of the exam), using the Trailhead trail as a guide to likely topics, and reading the verbs in the exam guide objectives closely, since “create and configure” implies hands-on skill while “describe” implies conceptual knowledge.

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

Worth reading?

How Agentforce uses deterministic layers to keep agents accountable and safe (opens in a new tab)

Readers will learn how Agentforce separates language reasoning from business actions by routing decisions through Flow, Apex, and Agent Fabric.

Why read this

The piece also outlines the tools available for auditing, testing, and maintaining human oversight over autonomous agents.

Agentforce divides agent operations into two distinct layers to balance capability with control. A generative layer handles natural language processing and reasoning, while a deterministic layer manages all consequential actions.

Consequential decisions are routed through established Salesforce automation and development tools like Flow, Apex, and Agent Fabric. This ensures every action adheres to predefined business policies, permissions, and escalation paths rather than relying solely on model predictions.

The system maintains accountability through the Atlas Reasoning Engine, which requires agents to justify their steps, and a comprehensive audit trail that logs both agent and human activity. Continuous evaluation is supported by the Testing Center for bias detection and the Trust Layer for input and output safety.

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

Worth reading?

Must-read

Custom Metadata Types as one deployable home for values across Salesforce and Agentforce (opens in a new tab)

You will see how one Custom Metadata Type can feed formulas, Validation Rules, Flow, Apex and Agentforce actions, and where those references stop working.

Typed into each tool

  • Thresholds in formulas
  • Defaults in Flows
  • Feature switches in Apex classes
  • Each change means finding every use

Custom Metadata Types

  • One deployable home for values
  • Travels through source control
  • One record per region plus Default
  • Read via $CustomMetadata reference
One deployable home replaces values typed into each formula, Flow or Apex class

The article argues that developers often hard-code business values such as thresholds, defaults, feature switches and mappings into formulas, Flows and Apex without noticing, which makes later changes hard to trace. Custom Metadata Types offer a central, deployable home for these values. Unlike Custom Settings or Custom Objects, which hold data, Custom Metadata holds configuration that ships with application code through source control and CI/CD. The author illustrates this with a Deal_Policy__mdt type holding a shared maximum discount and regional records for large-deal amount, default discount and approval threshold, selected by region name.

The piece then maps where references work. Formula Fields, Validation Rules and field defaults can use a three-part reference (type, record name, field), but the formula must name a fixed record, so it cannot pick a region from opportunity data. Long text area fields cannot be referenced, and the formula editor does not list Custom Metadata fields for defaults, though typing the reference still works. Flow can query the type with Get Records, match a region, and fall back to the Default record, and it can also use the literal reference. Apex uses getInstance with a similar fallback. Custom Permissions are kept separate, since they govern what a user may do while Custom Metadata governs the values.

Agentforce cannot read $CustomMetadata references directly, so the workaround is an invocable Apex action that loads the policy and returns the values, which the Agent Script maps into variables before answering. Lightning App Builder component visibility does not accept Custom Metadata references. On record pages a Formula Field can bridge the value, though that adds a field, and App and Home pages must read the data in Apex, through @wire, or via Dynamic Interactions.

To assess impact, the article recommends Setup’s Where is this used? option or a Tooling API query of MetadataComponentDependency, which lists the Apex classes and Validation Rules that depend on a field. It also notes that an attempt to build an LWC editor that showed these dependencies from Apex was complicated by the authentication setup REST calls require. Finally, it outlines platform limits: 200 types per org (350 with certified managed packages), 100 fields per type, and a 10 million character budget where each text area reserves 255 characters regardless of use. Process Builder allows 15 Custom Metadata formula references per process. The author concludes that teams should treat business values as configuration, centralize them, and keep track of where each reference works and where it does not.

Read the original at Andy in the Cloud (opens in a new tab)

Worth reading?