The independent daily for Salesforce admins, developers and architects

Curated by Abhinav (opens in a new tab)

Must-read

Choosing replacements for Salesforce to Salesforce before its Spring '27 retirement (opens in a new tab)

You will know how Salesforce to Salesforce works, what its retirement means for cross-org sharing, and how to choose among Experience Cloud, Partner Connect, Salesforce Connect, Data 360 and MuleSoft as replacements.

Why read this

You will also see the steps to inventory existing connections and plan a controlled cutover. The piece is aimed at architects and admins who inherit orgs that share data with partners or other orgs.

  1. Inventory every connection in each org
  2. Retire connections no longer needed
  3. Gather business requirements for the rest
  4. Choose a partner or platform option
  5. Plan a controlled implementation
The first step in replacing S2S is inventorying every connection in each org

Salesforce to Salesforce (S2S) is a declarative, point-to-point integration that shares records between two Salesforce orgs without code or middleware. The publishing org chooses what to share, the subscribing org maps it to its own fields, and forwarded records are sent asynchronously with retries and errors logged in the Connection History. Authentication relies on a mutual invitation, so no credentials are managed. Salesforce is retiring S2S with the Spring ’27 release, so teams need a new strategy, and the article suggests using the retirement as a chance to close gaps the current setup leaves open.

The first step is an inventory of every connection in each org. Record what is shared, how records are forwarded and accepted, and who owns each connection, along with the automation, assignment rules and logic that depend on it. Retire connections no longer needed, then gather business requirements for the rest. For partner scenarios, Experience Cloud is the choice when partners can work in your org on records you own, with Default External Access set to Private and access granted through partner roles and Sharing Rules. Partner Cloud adds onboarding, tiers and channel revenue management on top of that site, at the cost of licenses and program design. Partner Connect (Beta) suits partners that need their own synced copy, but it supports only accounts, contacts, leads, opportunities and cases as of Winter ’27, and not formula, multiselect or most lookup fields. MuleSoft can replicate records as an alternative for production.

When no partner-facing option fits, the article works through platform options in order of how much data must move. Salesforce Connect’s cross-org adapter reads or writes records in place as external objects but suits only small, on-demand operations. Data 360 offers a shared view through Data Cloud One or Data 360 to Data 360 sharing, though neither creates or updates CRM records. MuleSoft for Flow or Anypoint Platform handles replicated records where each org keeps its own copy. A custom build, using Apex, REST, Change Data Capture or Bulk API 2.0, is a last resort and takes on duplicate handling, backfill, deletes and credential management.

Finally, the article recommends a controlled implementation. Agree timelines and field ownership with the other org’s owner. Identify every flow, trigger, report and integration that touches the moved data, since automation also runs on records the new integration writes. Test duplicate prevention and failure cases in a sandbox with pass criteria set in advance, and finish production cutover several weeks before the instance’s Spring ’27 upgrade date, without running S2S and the replacement side by side.

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

Worth reading?

Recommended

Salesforce integrations fail on quota and data model, not protocol (opens in a new tab)

You will learn how the org-wide daily API allocation is calculated and why batching is a design decision rather than a tuning step.

Why read this

You will also see the Apex governor limit trap that breaks batch writes, and the external ID and upsert pattern that makes retries safe.

  • 5000: Contacts written one record per call
  • 25: Calls needed via sObject Collections at 200 per request
  • 100: SOQL query ceiling per synchronous transaction
Batching cuts the calls needed to write 5,000 Contacts by a factor of 200

The article argues that Salesforce integrations rarely fail on authentication or protocol. They fail on the daily API request allocation, which is shared across every consumer in an org, and on the data model choices that are costly to reverse once records exist. It walks through the main APIs, noting that REST and SOAP are both current, that Bulk API 2.0 is a different asynchronous programming model, and that Composite and sObject Collections cut call volume sharply because each counts as one call against the allocation.

The piece then covers the constraints that shape the architecture. The allocation is set by edition and license count, and requests fail with REQUEST_LIMIT_EXCEEDED once it is exhausted, with no grace on trial and Developer Edition orgs. Batching is presented as a design decision: a 5,000 record job costs 5,000 calls one at a time but 25 through sObject Collections. Caching reference data is also suggested. Governor limits are explained as applying to customer Apex that runs when an inbound write fires triggers, and an unbulkified trigger can exceed the 100 query ceiling on a 200 record batch.

Finally, the article addresses authentication, the Lead, Contact, Account and Person Account decisions, external IDs for idempotent upserts, partial-success handling, dead letter stores and reconciliation, and sandbox and API version pinning. It also discusses when middleware is justified and the UK GDPR obligations around controllers, processors and transfers. The cost ranges and vendor-agnostic claims are the author’s own estimates and are not independently verified.

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

Worth reading?

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?

Salesforce Services on Hyperforce now runs on Google Cloud and has first certifications (opens in a new tab)

You will learn that Salesforce Services on Hyperforce has now moved onto Google Cloud infrastructure and passed its first round of security assessments and certifications.

Why read this

You will also see which standards were covered and what Salesforce says comes next.

Salesforce has announced that Salesforce Services on Hyperforce now runs on Google Cloud infrastructure. The environment has completed its first round of security compliance assessments and certifications, covering SOC 1, SOC 2 and SOC 3, PCI DSS, ISO 27001, ISO 27017, ISO 27018 and NEN 7510. Salesforce says customers keep the Salesforce experience they already know, with the same security and compliance baseline as its other Hyperforce environments.

The post explains what each certification is meant to give customers. The SOC reports cover the controls behind the services, PCI DSS covers safeguards for payment card data, the ISO standards address information security, cloud security and personal data privacy, and NEN 7510 addresses information security in healthcare. Salesforce presents these as independent checks that customers can use to see how their data is protected.

Salesforce describes this as the start of an effort to achieve certification parity across its Salesforce Services environments. It says it will keep commissioning independent assessments so that customers can build on Hyperforce on Google Cloud with the same confidence they have elsewhere. The post points readers to the Salesforce Compliance site for the full reports and to a help article for which orgs sit in which location and which Hyperforce regions are available.

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

Worth reading?

A blameless postmortem template for Salesforce incidents caused internally (opens in a new tab)

You will get a reusable postmortem template for Salesforce incidents, with the org queries to rebuild the timeline and a method for finding where warnings were lost.

  1. Build the timeline from org records
  2. Search tickets and chat for earlier warnings
  3. Ask each person individually what they saw
  4. Record contributing factors by role, not name
  5. Assign each change an owner and a due date
The order in which a blameless postmortem is built, as the article describes it

The author argues that when a Salesforce production incident happens, the first question is often who deployed, which discourages people from speaking up. A blameless postmortem instead asks how the process let the problem through and whether anyone saw it coming. The piece offers a template with sections for the incident summary, timeline, what the team knew beforehand, contributing factors, and a changes table with owners and due dates. Two rules keep it blameless: names appear only in the timeline, never in contributing factors, and every action needs an owner and a date.

To build the timeline from the org, the article points to Setup Audit Trail, which can be queried with SOQL on SetupAuditTrail for the last seven days or exported with the Salesforce CLI. It also suggests checking Setup > Deployment Status for recent deployments and their initiators, and Flow and Apex error emails for exact timestamps and failing elements. If nobody receives those error emails, the author says that gap itself belongs in the changes table.

The section on what the team knew before is presented as the most important part. The author recommends searching tickets, pull request comments and chat threads, then asking people individually whether they noticed a concern and whether they raised it. Where a warning was raised but lost, the document should say so plainly, since it shows where the process drops warnings. The article closes with tips for running the review meeting, such as having the most senior person speak last.

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

Worth reading?

Recommended

Salesforce response to a compromised Optimizely script on its websites (opens in a new tab)

You will learn how the Optimizely compromise reached Salesforce web properties, what Salesforce has disabled, and which third-party scripts to audit in your own Experience Cloud, Commerce Cloud and Marketing Cloud pages.

  1. 16 Nov 2026: Exposure window, about 04:00 to 21:00 UTC
  2. 16 Nov 2026: Researcher reports 188 compromised files
  3. 17 Nov 2026: Optimizely confirms the malicious code
  4. Now: Admins audit for Optimizely snippets
The incident ran from the November 16 exposure window through Salesforce's response and the actions it recommends

On November 16, 2026, an attacker exploited a vulnerability in Optimizely, a third-party experimentation platform, and inserted malicious JavaScript into some customer projects. The injected code sat in the Project JavaScript field, which runs on every page. Because the files were still served from Optimizely’s trusted content delivery network, browsers and many security tools treated them as legitimate. Security researcher Scott Helm reported 188 compromised files across 178 organizations, Salesforce among them.

Salesforce says unauthorized changes were made to Optimizely scripts used on certain of its websites, and that those scripts could load malicious code in visitors’ browsers. As a precaution, it disabled Optimizely scripts across preview and production instances, and they will stay off until Optimizely’s remediation is verified, with no timeline to re-enable. Salesforce states it has no evidence the incident affected Salesforce-platform or subscription services. It is following its vulnerability response processes, monitoring for malicious activity, and will notify affected customers if it finds unauthorized access to their data.

The post says the exposure window ran from about 04:00 to 21:00 UTC on November 16. Optimizely says the vulnerability is closed and the injected code has been removed. Its statement points to the account signup flow as the route in.

If you build or host web applications on Salesforce platforms, you are affected only if your own team embedded Optimizely Web Experimentation scripts in them. Salesforce recommends that admins audit Experience Cloud sites, Commerce Cloud storefronts and Marketing Cloud landing pages for Optimizely snippets. Where a customer-facing site used an affected project on November 16, review application logs and watch for payment-form tampering and unusual session activity, such as logins or token use from unfamiliar locations.

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

Worth reading?

Optimizely compromise injected malicious scripts into Salesforce sites (opens in a new tab)

You will learn how a third-party script vendor was used to inject malicious JavaScript into 178 sites, including several Salesforce domains, and what to audit on your own Salesforce-powered sites in response.

  1. Attackers add code to Project JavaScript field
  2. Optimizely CDN passes code to site visitors
  3. Visitors' browsers run the injected script
  4. Script swaps crypto addresses, takes card data
How malicious code reached visitors through Optimizely's delivery network

Malicious JavaScript was injected into Optimizely’s Web experimentation platform and served to visitors of 178 organizations on November 16, including Salesforce. The code was designed to swap cryptocurrency addresses for the attacker’s own, collect payment card information, and target iOS devices with additional exploit chains. Salesforce says its own systems were not compromised, but it disabled Optimizely scripts across preview and production instances as a precaution while it investigates.

The attackers reportedly placed code in a “Project JavaScript” field in customer Optimizely accounts, which the vendor’s content delivery network then passed on to visitors. It is not yet clear how the attackers gained write access to those accounts. Optimizely has said it fixed the vulnerability, removed the injected code from affected projects, and added security measures. Equifax has stopped using Optimizely altogether.

The affected Salesforce domains named in the research were evergage.com, exacttarget.com, pardot.com and salesforce-scrt.com, along with four others not named. The article treats the incident as a lesson in supply chain risk: a secure platform can still be brought down by a vendor script running on its pages. It suggests auditing the third-party scripts on Experience Cloud and Commerce Cloud storefronts, removing any that are no longer used, and investigating any that nobody in the organization can account for.

For end users, the article recommends updating iOS devices to 18.7.3 or later, or to iOS 26.3 or later, depending on what the device supports.

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

Worth reading?

Design the permission model before the screens in occupational health cases (opens in a new tab)

You will see how to split an occupational health case across objects so an employer sees fitness outcomes but never clinical detail.

Why read this

You will also see why governed picklists, data-driven thresholds and an external community help with privacy and audit.

Occupational health case

  • Case
  • Encounter
  • Exposure event
  • Restriction
  • Surveillance result
  • Employer account
A single case is split into separate objects so each role sees only its own slice

The article frames occupational health case management as a permission problem. Five roles touch each case, and the employer may learn whether a worker can lift or drive but not why. Spreadsheets and shared drives fail because they cannot enforce who sees what or show afterwards who looked.

The author argues against a single large record. The case should be split into objects for the encounter, exposure event, restriction, surveillance result, employer account and worker record, with a junction object where the employer of record differs from the work site. Restrictions carry start and end dates and a review owner, so expiry becomes a tracked state. Record types and field-level security then separate employer-visible outcomes from clinical detail.

Free text classification is treated as a privacy risk as well as a reporting problem, because a diagnosis typed into a notes field escapes every Sharing Rule. Governed picklists close that gap. Regulated rules such as blood lead level monitoring thresholds and testing frequency should live as records rather than code, so regulatory changes become configuration edits and reports draw on the same data as the rules. Correspondence is logged as case activity, and documents carry version history, classification and retention rules.

For employers and referring clinicians, the article recommends an external community rather than a hidden-field copy of the internal app, which also avoids consuming internal user licences. Migration is where legacy duplicates and inconsistent classifications surface, so it should be rehearsed in a full sandbox and validated against historical caseloads. The closing advice is to settle the permission model first, since it is the expensive part to retrofit.

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

Worth reading?

Recommended

Write a metric contract before giving an AI agent access to CRM and ERP data (opens in a new tab)

You will learn why the same business metric can differ across Salesforce and an ERP, and how a versioned metric contract naming one source of truth and owner per number prepares data for an AI agent.

Won opportunities

  • Sums Amount on Opportunity
  • Filters on IsWon and CloseDate
  • Measures closed deals this month

Activated orders

  • Sums TotalAmount on Order
  • Filters on Status and EffectiveDate
  • Measures orders effective this month
Two valid queries for the same business question can return different totals

A sales manager asking for one figure often gets three answers: the CRM, the ERP and a spreadsheet each record a different moment of the same sale. The author says this is common in mid-sized companies running Salesforce beside a separate ERP, and that an AI agent given access without resolving it will simply pick one number.

The piece illustrates the problem with two valid SOQL queries for sales this month: one summing won Opportunities by close date, the other summing activated Orders by effective date. Both are correct and can return different totals on the same day, while invoicing in the ERP follows its own date logic.

The proposed fix is a metric contract, a short versioned YAML file. For each metric it names the question, the definition, the source of truth, the object and filter, the amount field, an owner, what the metric is not, and any metrics it reconciles with along with the expected gap. The example pairs a sales_this_month metric on the Order object with an invoiced_this_month metric held in the ERP.

The author’s practical rules are to give the agent the contract as context rather than only database access, to flag metrics that depend on spreadsheets as candidates for removal, and to review the contract when processes change, as one would review code. The article also notes that a single data source avoids much reconciliation work, and it promotes the author’s own ERP product built natively on Salesforce.

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

Worth reading?

Choosing between Custom Metadata Types and Custom Settings for org configuration (opens in a new tab)

You will learn which configuration store fits deployment-time values, which fits per-user or runtime state, and how to migrate between them.

Why read this

The article gives a clear decision rule that you can apply when designing new configuration.

Custom Settings

  • Records are data, not metadata
  • Not in change sets or packages
  • Hierarchy cascade: org, profile, user
  • Count against data storage

Custom Metadata Types

  • Stored as metadata
  • Deploy with change sets and packages
  • Referenced from formulas and Flows
  • Apex cannot edit them at runtime
Custom Settings and Custom Metadata Types differ in how they deploy and in what they can do at runtime

Salesforce orgs need to store configuration that code reads, such as feature flags, endpoint URLs and thresholds. The article contrasts the two classic options, Custom Settings and Custom Metadata Types, and notes that choosing the wrong one tends to cause problems later, often during deployment.

Custom Settings hold org-specific data in two forms: List settings, which are sets of records, and Hierarchy settings, which cascade values from org to profile to user. The cascade is their main advantage, since it allows per-user or per-profile values without code. Their records are data rather than metadata, so they do not travel with change sets or packages, must be recreated in each sandbox and in production, are invisible to the Metadata API, and count against data storage.

Custom Metadata Types store configuration as metadata that deploys with change sets, unlocked packages and the Metadata API. They can be referenced from formulas, Flows, Apex and Validation Rules, and they support protected records in managed packages. Their limits are that Apex cannot create or edit them at runtime, and they have no per-user or per-profile cascade, so one value applies to everyone in the org.

The article’s rule is to ask whether the value changes at runtime or only at deployment. Runtime state such as counters or timestamps belongs in Custom Settings or a Custom Object, while deployment-time configuration belongs in Custom Metadata Types. Per-user or per-profile values call for Hierarchy Custom Settings. Many orgs combine both, using Custom Metadata Types for stable configuration and a Custom Setting or Custom Object for live state.

For migration, the author recommends creating the Custom Metadata Type with the same fields, recreating the records as metadata, and updating references, noting that the getInstance() call changes to the mdt syntax. Migrate one setting at a time, keep the old one until the new one is proven, and check that test classes still cover the code so the 75% deployment gate is not breached.

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

Worth reading?

Must-read

Threat actors are using the ARTEX framework against Salesforce orgs; here is how to defend (opens in a new tab)

You will learn how an AI-driven attack against Salesforce environments behaves, what Salesforce Threat Intelligence has observed, and which controls to put in place now.

  1. Use stolen application credentials
  2. Relay traffic through Apex and Named Credentials
  3. Inspect existing Apex and integration settings
  4. Deploy custom Apex and REST endpoints
  5. Enumerate users, profiles and Permission Sets
  6. Retry code-execution and integration paths
How the ARTEX-assisted campaign moved through a Salesforce org, from access to persistence

Salesforce Threat Intelligence reports that several threat actors are using ARTEX, an open-source, multi-agent offensive framework originally built for autonomous penetration testing. A malicious operator supplies a target and an objective, and AI agents coordinate the intrusion, combining known attack techniques with continuous planning, parallel execution and on-the-fly code generation. The framework’s GitHub repository was taken down, but community forks still circulate, and the authors treat ARTEX as an accessible capability rather than a tool tied to one actor. Other vendors report its use by a state-aligned actor against Microsoft 365 tenants and by financially motivated groups against financial organizations.

Salesforce observed a campaign that used stolen application credentials and trusted integration sessions against customer environments. The company states that the activity did not stem from a flaw in the Salesforce platform and that affected customers were notified directly. The observed behavior included using Salesforce as a relay through Apex and abused Named Credentials, inspecting existing Apex and integration settings before deploying custom Apex, REST endpoints and Visualforce components, and testing the compromised account’s effective permissions by enumerating users, profiles and Permission Sets. The attackers kept retrying code-execution and integration paths, including anonymous Apex, and audit logs showed rapid, dynamic automation that Salesforce reads as an agentic-like operator.

The recommended defenses are phishing-resistant MFA for all users, with Salesforce already enforcing it for admins and MFA for all users, User Email Domain Restrictions, short-lived context-bound OAuth tokens, and step-up authentication for sensitive actions such as bulk export and permission changes. Also recommended are IP allowlisting for users and Connected Apps, behavioral detection of full attack sequences, Event Monitoring streamed to a SIEM, regular scanning of repositories for exposed secrets, and a response plan able to disable an integration, revoke tokens and reset credentials within hours.

Read the original at Salesforce 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?

Recommended

Design a Salesforce security model around user personas (opens in a new tab)

You will learn how to map business personas to a User Field, a Custom Metadata Type, a Permission Set Group and Apex automation, so access stays consistent as features are added.

Why read this

The piece also explains when to use functional versus persona-based Permission Sets and why Profiles should be kept minimal.

  1. Persona set on User record
  2. Custom Metadata Type maps persona
  3. Permission Set Group for persona
  4. Permission Sets grant access
  5. Apex assigns access on save
How a persona assigns a user's access, from the User record through to Apex

The article argues that Salesforce security models often become a fragmented patchwork, and that features can fail on release because users lack the access they need. Its remedy is to build the security model around personas: groups of users who share a functional role and baseline access. The business defines which persona needs which access (create, read, edit, delete) for a feature, and IT implements that access consistently, so the same framework can serve later releases. Shared understanding between IT and the business is treated as essential to making this work.

The approach rests on five pieces. A persona picklist on the User record, whose edits are tightly restricted to administrators, stores each user’s persona. A Custom Metadata Type acts as a maintainable mapping table from each persona to its profile, role, public groups and Permission Set Group, and automation fails if a persona lacks a mapping record. Each persona gets one Permission Set Group, which has no access of its own, so changing a persona’s access means changing its Permission Sets. Those Permission Sets can be organized either by functional capability, which suits features spanning many objects such as Field Service, or by persona, which suits cases with few personas and complex functions, such as a Partner Relationship Management Experience Cloud site. Temporary cross-role duties are handled through an approved exception process, such as an ITSM workflow, while permanent combined roles should become new personas.

The article also recommends keeping profiles minimal: each user gets a custom “Minimum Access” profile, one per license type, with most permissions moved to Permission Sets, since profiles are still needed only for edge cases such as page layouts, login hours and IP ranges. Assignment is automated with Apex through the organization’s trigger framework, which the author prefers over Flows for consistent performance at scale. For teams not ready for the full design, the author suggests starting with Permission Set Groups for the personas a feature and its successors will need, assigned manually at first, and adding the persona field and automation later. The article frames this as a way to meet the Salesforce Well-Architected Framework’s goals of scalability and predictability.

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

Worth reading?

Must-read

Metadata Grounding lets coding agents search your org's Metadata by intent (opens in a new tab)

You will learn how the Metadata Grounding MCP Server indexes org metadata, how to connect it, and how to use describe, search and query so agents reuse existing components instead of rebuilding them.

  1. describe_metadata: list types and schemas
  2. search_metadata: find items by intent
  3. query_metadata: read the full record
The three Metadata Grounding tools run in order, so the agent checks the org before writing code

Coding agents working on a Salesforce org often build new components because they only see the part of the org that has been retrieved into a local project. The Metadata Grounding MCP Server (Beta) addresses this by searching a pre-indexed catalog of the whole org’s metadata, so an agent can check what already exists before writing code. It is one of three pieces in the Headless Toolkit, alongside Skills, which teach patterns, and the Headless 360 MCP Server, which lets the agent act. Metadata Grounding answers the question of what is currently in the org. It is read-only, runs as the authenticated user so it returns only what that user may access, and covers more than 70 core metadata types, though not Data 360 metadata.

The server exposes three tools: describe_metadata lists available types and their schemas, search_metadata finds components by natural-language intent with optional type and subtype filters, and query_metadata returns the full record for a result. The recommended workflow is describe, then search, then query. Behind it, Salesforce Catalog extracts metadata from the org, stores it in a Data 360 data lake object mapped to a Catalog data model, and indexes it with a hybrid of vector and keyword search. Catalog updates supported types incrementally and runs a full refresh every 24 hours, so very recent deployments may take time to appear.

The article illustrates two uses in Pronto, a sample food delivery org. In the first, a vague bug report about a non-working menu category was traced to an Apex controller and a Lightning Web Component found by describing the symptom, with the type filter narrowing noisy results. In the second, an agent found an existing Apex class with a summarize-reviews action and extended it rather than building a duplicate. The article advises adding a project rule telling agents to search the org first. It also covers setup: an org with a supported Data 360 edition, Salesforce Catalog enabled, and admin activation of the server, with the server available either standalone for any MCP client or inside the Headless 360 MCP Server, which will later be renamed the Salesforce MCP Server. Caveats include that search only finds candidates, which should be confirmed by query; the server does not return source code; and usage is metered in production but not in pre-production orgs. Planned additions are AI-generated metadata descriptions and a Metadata Graph for dependency analysis.

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

Worth reading?

Must-read

Restricting Shopper API traffic to Managed Runtime with eCDN rules (opens in a new tab)

You will learn how to lock SCAPI traffic to Managed Runtime with the SCAPI Identity Header, allow other integrations, harden SLAS, and rate limit AI crawlers using eCDN fields and rule expressions.

  1. Enable SCAPI Request Identification per instance
  2. Add a block rule for the instance's path
  3. Place the rule after the Salesforce allow rule
  4. Start in Log mode, then switch to Block
How to restrict Shopper API traffic to Managed Runtime, rolled out in stages

Bots increasingly call the B2C Commerce API directly, bypassing storefronts, and AI crawlers and shopping agents add search and LLM costs and skew analytics. The October 2026 release lets you manage the SCAPI zone in Business Manager and the CDN API, accept Shopper API traffic only from Managed Runtime through the new SCAPI Identity Header, and identify AI traffic on any eCDN zone with verified-bot fields. The SCAPI zone is provisioned automatically and shared across Development, Staging and Production, managed from Production. Some controls such as WAF managed rulesets, mTLS, TLS 1.3 settings and HSTS are not available.

To restrict traffic, enable the Managed Runtime SCAPI Request Identification feature per instance, then add a firewall rule that blocks Shopper API paths for that instance’s org-specific path segment, placed after the locked Salesforce allow rule. Start with Log, then switch to Block. Other integrations such as a custom BFF can be allowed with their own rules carrying a separate shared secret header that must stay server-side. For SLAS, Strict Client Auth requires a client secret header on login and authorize requests, though Composable Storefront and Storefront Next do not send it yet, so it should be enabled only for private clients called from your own server code. SLAS also throttles refresh-token exchanges to 3 per 60 seconds.

For AI traffic, the Known Bot and Verified Bot Category fields sort verified bots into 17 categories. The post recommends rate limiting AI Crawler and AI Search traffic on expensive endpoints such as product search rather than blocking it, with thresholds tuned from logs and Log mode run first. Spoofed or unverified automation needs behavioral detection from a bot management partner or Bot Management in front of eCDN.

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

Worth reading?

A small owned trigger framework built around an explicit handler contract (opens in a new tab)

You will learn how to structure an Apex trigger framework with a single dispatcher, a recursion guard that tracks record IDs, layered bypass controls via Custom Metadata and a permission, and user-mode selectors with a savepoint-based unit of work.

Why read this

The author also explains why they chose an owned baseline over a third-party framework.

  1. Check bypass layers
  2. Confirm trigger context
  3. Check recursion guard
  4. Mark records as handled
  5. Call context hook
The trigger lifecycle checks run in a fixed order before the context hook is called

The author argues that Salesforce trigger frameworks usually fail on their contract rather than their code: when a handler runs, when it is skipped, what happens on re-entry, and who may bypass it. Their baseline is deliberately small, with a one-line trigger that delegates to a dispatcher. The lifecycle checks bypass settings first, confirms the code is running inside a trigger, resolves the context, verifies the SObject type, checks the recursion guard, marks records as handled, and then calls the context hook. Handlers only override the contexts they need and delegate rules to domain classes.

The recursion guard tracks which record IDs a named handler has already processed in the transaction, instead of using a static boolean. This avoids both blocking legitimate second passes for different records and re-entry from after-triggers. Bypass works in three layers: a runtime bypass for tests and controlled operations, an Is_Active__c flag on Custom Metadata to disable a handler without deployment, and a Custom Permission for integration users during data loads. Metadata is read once per transaction. The surrounding layers keep business logic out of the trigger, with selectors running in user mode and a unit of work that commits DML in a fixed order inside a savepoint.

The author reports that static checks and a check-only compile against an org caught configuration issues, and that the test suite exposed a null dereference outside trigger context and a wrong assumption about scheduled job execution in tests. The article closes by listing next steps, including removing defaults from test factories and enforcing the Permission Set in the deploy pipeline.

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

Worth reading?

Must-read

Scaling Experience Cloud Person Accounts past the 50,000 ownership limit (opens in a new tab)

You will learn how the 50,000 account-ownership limit and the external role allocation differ for role-based Experience Cloud licenses, and what options exist for a 200,000-customer Person Account portal.

Why read this

The reader will also see why license choice should be settled before deployment.

Single internal owner

  • All 200,000 accounts under one user
  • Hits the 50,000 ownership limit
  • Support increase request not approved

Person Account Owner Power User

  • One eligible power user owns more accounts
  • Power user must sit at top of role hierarchy
  • Set up with deferred sharing disabled
Two ways to handle the 50,000 account-ownership limit for Person Accounts

The author describes a production problem on an e-commerce Experience Cloud portal meant to onboard about 200,000 customers. The portal used Person Accounts and the Customer Community Plus Login license, which requires an external user role. When user creation hit a 50,000 account-ownership constraint, Salesforce Support declined the requested increase, leaving the site live in production but unable to proceed with the planned onboarding. The piece stresses that this 50,000 ownership limit, the org-wide external role allocation (documented default of 50,000 for role-based external licenses) and total external user capacity are separate constraints, and that creating 200,000 users does not necessarily consume 200,000 roles.

The article sets out four options. The first is the PersonAccountOwnerPowerUser setup object, which lets an eligible internal user at the top of the role hierarchy own more than 50,000 qualifying portal accounts; it carries restrictions on the role and on deferred sharing, and does not change role allocation or other license limits. The second is spreading ownership across several internal users, which reduces per-owner load but adds sharing, reporting and maintenance complexity. The third is checking whether Customer Community, a high-volume non-role-based license, would meet the business needs, after assessing sharing, reporting, Apex and cost differences. The fourth is requesting a limit increase from Salesforce Support, which is not guaranteed and should not be the only plan.

The author then lists common mistakes, such as treating 50K as the total user limit, ignoring Person Account ownership in early design, choosing a license only because it supports roles, relying on support exceptions, and neglecting data isolation when owners or roles change. A pre-production checklist covers volume forecasting, license confirmation, limit validation, ownership and sharing strategy, customer data isolation, restartable bulk provisioning, early validation with Salesforce, and a fallback plan. The core lesson is that licensing, ownership, role allocation, sharing and provisioning must be settled in the initial design rather than discovered during production rollout.

Read the original at SalesforceCodex (opens in a new tab)

Worth reading?

Recommended

Trigger Lib: a role-based Apex trigger framework built around governor limits (opens in a new tab)

You will learn how Trigger Lib splits trigger logic into populators, validators, writers and dispatchers, how orchestrators and Custom Metadata Types register handlers, and how its add-on interfaces bulkify queries and batch DML.

Trigger Lib handler roles

  • Populator
  • Validator
  • Writer
  • Dispatcher
Trigger Lib has four handler roles, each with one job in a trigger context

The article introduces Trigger Lib, an open-source Apex trigger framework from the Apex Fluently collection, written by an author who argues that Flows are impractical and that Apex triggers are the best automation option, provided they are organized well. The author’s main complaint is that existing trigger frameworks rarely help teams manage governor limits, which become a serious risk when AI-generated code and other automations share a transaction. Trigger Lib is deliberately not metadata-driven. It can be started with an orchestrator class that lists handlers, or with runFromMetadata() for handlers registered in Custom Metadata Types, and Custom Metadata is then used only to switch handlers off.

Handlers are split into four roles: Populators set field values in before insert and update, Validators reject invalid records in before contexts, Writers queue DML on a shared Unit of Work in after contexts and before delete, and Dispatchers start Queueable jobs or publish events in after contexts. Each role has a qualifying method and an action method, and SOQL and DML are blocked in the per-record methods. Add-on interfaces such as ParentQuery, PriorParentQuery, RelatedQuery, OwnUnitOfWork, Bypassable, RecursionGuard, Finalizer and ContinueOnError extend these roles, for example to bulk-load parents and related records or to let a failing handler be logged without failing the save.

The author analyzed 919 SOQL queries from three projects and found that parent and config queries made up most of the total, which is why the framework bulk-loads parents once per chunk and recommends static variables for configuration data. Writers commit through DML Lib, which orders inserts by dependency and performs one DML per operation and object type at the end of the run. The article is cut off during its discussion of the Logger interface, so the logging details are not covered.

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

Worth reading?

Recommended

Salesforce Headless 360 exposes the platform to agents through APIs and MCP (opens in a new tab)

You will learn what Salesforce Headless 360 offers through its three access paths, why governance has to move from the UI to the schema, and how to start a controlled pilot with a Hosted MCP Server.

  1. Pick one workflow
  2. Audit the schema
  3. Connect a sandbox client
  4. Define agent identity and limits
  5. Test, trace and measure
A five-step plan for a first Headless 360 pilot

Salesforce Headless 360 is an architecture that exposes Salesforce capabilities through APIs, Model Context Protocol (MCP) tools and CLI commands, so AI agents, apps and developer tools can use the platform without a browser. Announced at TDX 2026, it keeps the data, workflows and business logic built over 25 years, and the company now also calls the offering Headless Toolkit. Salesforce cites more than 60 MCP tools, 30 preconfigured coding skills, 4,000 APIs and 220 CLI commands, and states that Lightning and the browser remain available for human users.

The piece explains three access paths. APIs serve developers and integration platforms that read and write records. MCP tools let AI clients such as Claude, ChatGPT and Cursor discover and call capabilities at runtime, with no custom integration code written in advance. CLI commands support scaffolding, testing and deployment through DevOps pipelines. MCP tools are further split between coding agents, which read metadata, generate Apex and deploy, and business agents, which reach Salesforce from Slack or other chat clients. Hosted MCP Servers became generally available in April 2026, and the Headless 360 MCP Server followed in beta in July 2026. Every Hosted MCP call runs as the authenticated user through an External Client App with the mcp_api scope, and the article warns that pricing via Flex Credits may bill for usage, so teams should confirm terms with their account team.

For architects, the central change is that governance moves from the screen to the schema. An agent never sees a page layout, so Validation Rules, sharing models, Apex and approvals must carry the controls. The article proposes a four-layer view of experience, access, execution and data, and lists review questions about rule placement, least-privilege Permission Sets, human-only actions and approval points for high-risk actions. It also covers the Headless Experience Layer and Multi-Framework support for React, and notes that agent testing needs evaluation sets, session tracing and the Agentforce Testing Center. MuleSoft supplies governed access to systems outside Salesforce, while Data 360 supplies unified customer context.

The article suggests starting with one workflow, auditing the schema, connecting a sandbox Hosted MCP Server to one client, defining agent identity and limits, and then testing, tracing and measuring results against the manual process. It treats vendor customer stories as reference points only and advises a pilot to generate real evidence.

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

Worth reading?

How Salesforce uses headless patterns internally, and how to apply them (opens in a new tab)

You will learn how Salesforce applies headless architecture to agents, customer-facing experiences and internal tooling, and the three components it considers necessary for a trusted headless agent.

Why read this

You will also see the reported gains from building on Multi-Framework with React.

  1. Ground in business context via Data 360
  2. Interpret requests and act through tools
  3. Build governance in from the start
The three baseline components Salesforce uses to build a trusted headless agent

Salesforce presents its Headless Toolkit and AIforce as a way to bring platform capabilities, security and business context to any surface where work happens, rather than confining them to a single standard UI. The post follows its “Customer Zero” principle and describes four internal uses: an IT support agent that runs in Slack and a self-service portal on the same Flows and governance, a security and access agent that calls tools exposed by the Salesforce MCP server, a Headless Experience Layer playground for building widgets with mock data, and a React app that monitors a 15,000-engineer internal org.

The post says a trusted headless agent needs three baseline components: grounding in business context through Data 360, the ability to interpret requests and act through tools, and governance built in. It also reports that Builder Central’s frontend was rebuilt in React on Multi-Framework in a two-week sprint, where the previous stack would have taken two to three months, and that the development inner loop dropped from minutes of build and sync time to seconds.

Most of the piece is positioning and promotion, and it gives few concrete measurements or code. The architectural pattern of building logic once and exposing it through several surfaces is the useful takeaway for architects, with the timing claims as Salesforce’s own account.

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

Worth reading?

Recommended

Lessons from building a Flow Version Cleaner on the Tooling API (opens in a new tab)

You will learn how to choose between the Tooling API, Metadata API and Apex Metadata for deleting flow versions, and how to handle authentication, object dependencies and state across asynchronous jobs.

Why read this

The piece also sets out safeguards for destructive metadata automation.

  1. Keep the active flow version
  2. Keep newer versions under review
  3. Keep recent inactive versions as fallback
  4. Delete flow interviews via callouts
  5. Delete remaining obsolete flow versions
The cleaner's flow version decision sequence, from protected versions to safe deletion

The author built an open-source Flow Version Cleaner to prune obsolete flow versions in orgs with hundreds of flows. The tool keeps the active version, keeps newer versions that may be under review, and retains a configurable number of recent inactive versions as a fallback. Requirements were refined during the build, once it became clear that version numbers alone do not show which versions are safe to remove.

The article compares the Apex Metadata namespace, the Metadata API with destructive changes, and the Tooling API. The Tooling API was chosen because it lets each flow version be queried and deleted individually at run time, so one failure does not roll back the whole run. Authentication uses Named Credentials rather than the running user’s session, since session IDs can be null in asynchronous work and should not carry the permissions of whoever started the job. Flow interviews must be deleted before flow versions, and because Apex does not allow a callout after DML in the same transaction, both steps use callouts. Versions owned by managed packages cannot be deleted by subscribers.

For asynchronous work, the author recommends building an explicit payload between jobs, since inner-class fields can arrive null without any error, and using one snapshot of org state for both the decision and the action. Destructive metadata work should run in dry-run mode first, record every candidate, and isolate failures, because deleted metadata cannot be restored from the Recycle Bin.

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

Worth reading?

Seven architecture decisions for a Salesforce-Jira integration (opens in a new tab)

You will learn seven questions to settle before building a Salesforce-Jira integration, covering sync speed, reconciliation, field ownership, native versus middleware versus custom builds, error handling, scaling and governance.

Why read this

The piece treats the choice as a set of trade-offs rather than a product pick.

  1. Rep opens case in Salesforce
  2. Case syncs to Jira as an issue
  3. Developer investigates and resolves
  4. Resolution and Fix Version flow back
  5. Reconciliation corrects any missed updates
The case-to-issue flow between Salesforce and Jira, with the resolution returning to the rep

The article argues that a Salesforce-Jira integration is more than connecting two systems: when they drift apart, customers can see stale information before anyone notices the underlying fault. It presents seven architecture decisions to settle first. The first is how fast updates must move, with real-time event sync for urgent changes and queued asynchronous sync for routine ones, bearing in mind platform limits. The second is correctness: event-driven sync should be paired with scheduled reconciliation that finds mismatches and resends missing updates without duplicates. The third is field ownership, deciding per field which system owns the data so nothing is overwritten, and checking how comments, attachments and rich text map. The fourth is choosing native, middleware or custom builds, each with different trade-offs in limits, reporting, data residency, setup effort, maintenance and security. The fifth is error handling: limited retries, idempotent keys, alerts, monitoring, per-record history, and checking how each sync direction fails. The sixth is scale, planning for more users, projects and case spikes through batching, queues and awareness of memory limits. The seventh is where AI fits and who governs it, with AI assisting on suggestions and lookups while the sync itself stays deterministic and governed by named owners and human approval where needed.

Beyond these seven, the piece suggests three further checks before choosing an integration: the total cost of ownership over time, including who maintains it when Salesforce or Jira change; what support, SLA and escalation exist after go-live; and whether security teams can accept the credential handling and marketplace review. A decision matrix maps common situations to suitable routes, showing that most teams combine approaches rather than picking a single product.

The article concludes that there is no universal answer and that the right choice depends on workflows, integration needs and how much ownership a team wants to take on. It closes by asking every option the same key questions about missed events, field ownership, duplicate-free retries, alerting and maintenance. It also promotes Sinergify, a Salesforce-native Jira connector built around reconciliation-backed two-way sync, as one option for teams that prefer not to build and maintain this foundation themselves.

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

Worth reading?

Architecting HCP and HCO 360 data models and integrations in Life Sciences Cloud (opens in a new tab)

Readers will learn how to design the reference architecture, data model, and integration sequence required to implement HCP and HCO 360 profiles in Life Sciences Cloud.

Why read this

They will also understand best practices for managing affiliations, resolving duplicates, and aligning field territories.

This guide explains how to design and implement HCP 360 (healthcare professionals) and HCO 360 (healthcare organizations) in Salesforce Life Sciences Cloud. It starts from the problem that a single doctor can appear across several hospitals and in multiple systems such as CRM, marketing platforms, and external healthcare databases, leaving sales reps with inconsistent or incorrect information. HCP 360 gives a connected view of an individual professional’s details, workplaces, contact data, territory, and interaction history, while HCO 360 gives account managers a view of an organization’s location, departments, affiliated professionals, parent group, and engagement history.

The article recommends a reference architecture before any configuration begins. External data providers supply identifiers, specialties and addresses; master data management decides how records are matched and which system owns each attribute; Life Sciences Cloud runs customer engagement; and Salesforce Data 360 can unify sources for analytics and segmentation without automatically replacing the master data system. The data model should reuse standard Life Sciences Cloud entities such as provider, provider organization, affiliation, identifier, specialty, and territory before any Custom Objects are added. Affiliations must support multiple roles, dates and history, and HCO hierarchies must be kept distinct from professional affiliations.

For duplicates, the guide sets out a five-step process: standardize data, match on reliable identifiers, compare supporting attributes, send uncertain matches to a data steward, and keep source-system references. It warns against merging on name alone. For integration, it recommends loading HCOs first, then HCPs, then affiliations, then territory alignment, and finally validating counts, duplicates and relationships, using bulk processing and retry and error logging. The article also covers territory design beyond geography, keeping consent management separate from record-level security, and building HCP and HCO 360 pages on standard features first. Common mistakes include unnecessary Custom Objects, unclear data ownership, copying too much external data, overwriting affiliation history, and building interfaces before data quality is fixed. A pre-go-live checklist and an FAQ close the piece.

Read the original at SalesforceCodex (opens in a new tab)

Worth reading?

Salesforce updates architecture diagram templates to reflect Agentforce and Data 360 (opens in a new tab)

You will learn how to select the correct diagram type for your audience and apply Salesforce updated template libraries to accurately represent current platform capabilities.

Salesforce architects spend much of their time communicating design decisions, and a clear architecture diagram gives teams a shared reference point that replaces long meeting notes and chat threads. Salesforce refreshed its Reference Diagrams, Architecture Gallery templates and Lucidchart shape libraries in June so they reflect Agentforce and Data 360, the renamed Data Cloud. The Cards library now includes preformatted Agentforce components, product names are updated, and new templates cover multi-cloud work coordinated by Agentforce, event-driven agent triggers and data flows with AI decisioning. Font sizes and border contrast were also improved for large-screen reviews, and some interaction process flow diagrams tied to Decision Guides and Fundamentals content were retired. The refresh did not change Salesforce’s five core diagram types, its Lucidchart partnership or its overall approach.

The five core types each answer a different question, so the choice should start with the audience. Capability maps show what business capabilities a solution must provide, without technical detail, and suit executives. Roadmaps add a time dimension for phased delivery and can show technical dependencies in business terms. System landscapes show the systems, products and connections in an estate, which helps with discovery and impact analysis. Solution architectures show how systems communicate and integrate, including authentication and data movement, and are the diagrams implementation teams use most. Interaction process flows show the numbered sequence of steps, agent actions and handoffs over time.

Most substantial projects use several of these diagrams, and they should tell a consistent story across each other. Architects are advised to start from a template in the Reference Architecture Gallery rather than a blank canvas, then adapt it to their scenario. For Agentforce designs, the article recommends splitting concerns across multiple diagrams rather than overloading one, and making human-in-the-loop points and data grounding visible to security, governance and business readers. Diagrams are not a substitute for entity relationship diagrams when data modeling is significant. The article closes by stressing that a good diagram makes the right information easy to understand for its particular audience, not that it contains the most detail.

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

Worth reading?

Architecting Salesforce Marketing Cloud requires a data foundation before campaign configuration (opens in a new tab)

Readers will learn how to structure data, identity, and consent architectures before configuring journeys in Marketing Cloud.

Why read this

The piece outlines practical questions to answer during implementation planning to prevent scaling failures.

The article argues that Salesforce Marketing Cloud implementations often fail when treated as simple campaign setups rather than comprehensive data projects. It emphasizes that reliable personalization depends on a foundational layer that handles data trust, identity mapping, consent tracking, and system integration before any journeys are built.

It outlines key architectural decisions that must be made prior to configuration, such as identifying authoritative data sources, selecting shared attributes for decisioning, and determining refresh frequencies. The author warns against indiscriminately loading every available field into Data Extensions, recommending instead a focused dataset that supports cross-journey personalization.

Identity resolution and consent management are highlighted as critical components that require business-led decisions rather than pure platform configuration. While tools like Data 360 can consolidate records, organizations must define trusted identifiers, handle duplicates, and map household relationships. Consent must be modeled across channels, geographies, and purposes to ensure accurate suppression and compliance.

Finally, the piece advises designing integrations around business journeys rather than creating point-to-point connections between systems. It recommends evaluating implementation partners based on their ability to establish governance rules, reusable journey patterns, and clear data ownership, ensuring the platform remains sustainable as campaign volume grows.

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

Worth reading?

Architecting customer portals beyond Experience Cloud licensing and API limits (opens in a new tab)

Readers will learn how to evaluate four portal architectures against Experience Cloud by weighing licensing costs, API budgets, and data synchronization trade-offs.

Why read this

The piece provides a structured set of questions to assess security, visibility, and failure modes for each approach.

The article examines four architectural approaches for building customer portals that do not rely on Experience Cloud licenses. It contrasts running the portal directly on the Salesforce platform using licensed external users or headless identity APIs, connecting to a live Salesforce database through a third party, syncing records to an external database, or migrating customer data entirely to a different system like Microsoft Dataverse.

Each model carries distinct operational trade-offs. On-platform deployments enforce native security and real-time data but require per-user licensing and consume administrative capacity. Off-platform live connections avoid licensing fees but draw heavily from the rolling 24-hour API limit and introduce OAuth token security risks. Synced copies reduce API consumption and provide outage resilience but risk data staleness and write collisions, requiring careful reconciliation policies.

To navigate these options, the author recommends evaluating every vendor against five criteria: where customer data resides, how Salesforce classifies portal visitors, which layer enforces record visibility, the typical API cost per page or acceptable sync lag, and procedures for handling connection failures or token revocation. The analysis concludes that Experience Cloud remains the only true single system of record, while alternatives simply shift architectural responsibilities to API management, data governance, or external security configurations.

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

Worth reading?

Architecting Salesforce orgs for user adoption and phased rollouts (opens in a new tab)

You will learn how to embed adoption criteria into your design phase, optimize Lightning Record Pages and Validation Rules for primary personas, and structure phased rollouts to minimize friction.

The article argues that user adoption failures stem from early architectural choices rather than training gaps. It recommends establishing explicit adoption criteria during the design phase, including identifying primary personas for each object, limiting required fields to initial entry points, and ensuring critical actions require three clicks or fewer. The piece highlights the updated Salesforce Well-Architected Framework, which now emphasizes making design trade-offs visible and documenting their rationale.

To align system workflows with natural user behavior, the author suggests using Dynamic Forms with visibility rules to tailor Lightning Record Pages per role, applying stage-based Validation Rules instead of blanket requirements, and routing approvals without halting progress. Designs should be validated by having representative end users complete common tasks cold, treating any hesitation as a signal to adjust the architecture before configuration begins.

Post-launch success relies on built-in feedback loops and phased rollouts. The author advises capturing adoption signals through Field History Tracking, stage duration reports, and the Lightning Usage App, then shipping corresponding dashboards on day one. Rollouts should avoid big bang deployments by keeping phases independent, using Permission Set Groups for granular feature access, and restricting navigation tabs to only show active waves, thereby containing friction and enabling continuous improvement.

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

Worth reading?

Recommended

Evaluating customer portal architectures by measuring ongoing admin and release overhead (opens in a new tab)

Readers will learn how to evaluate platform versus off-platform portal architectures by comparing their impact on Sharing Rules, API limits, and release testing.

Why read this

The piece provides concrete questions to ask before kickoff so teams understand who owns security and maintenance after launch.

The article outlines three approaches to building customer portals: native Experience Cloud sites, custom off-platform applications using APIs, and third-party pre-built solutions. It argues that the choice should be driven by long-term administrative overhead rather than initial development speed.

Visibility and security behave differently across each path. Platform builds rely on Salesforce Sharing Sets, external roles, and guest user access rules, which can be bypassed by insecure Apex code. Off-platform and pre-built options delegate record filtering to application code or vendor settings, requiring careful control over the integration user permissions.

Ongoing costs diverge significantly after deployment. Native portals consume transaction limits and demand rigorous test coverage during quarterly releases, while external integrations draw heavily from the daily API request pool and must track API version retirements and authentication changes. The author recommends assigning dedicated integration users, requesting written call budgets, and verifying vendor certification timelines before go-live.

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

Worth reading?

Optimizing Apache Spark workloads at scale using telemetry and evidence-based tuning (opens in a new tab)

You will learn how to collect execution telemetry without modifying application code and validate resource sizing changes against runtime and reliability metrics before production rollout.

The Salesforce engineering team addressed inefficient compute allocation across millions of daily Apache Spark jobs by shifting from success-based metrics to evidence-driven resource sizing. They identified that successful job completion often masks unused capacity, pod churn, and unnecessary executor allocations.

To gather comparable measurements without altering customer applications, the team instrumented a shared submission gateway using open-source listener hooks. These listeners exported structured telemetry through Kafka into a curated analytical layer, which standardized metrics for applications, jobs, stages, and executors while explicitly tracking missing data and retry semantics.

The team used the modeled data to distinguish between genuine waste and underlying bottlenecks like shuffle failures or memory pressure. By testing targeted reductions in initial executors and maximum limits, they validated changes against p95 runtime, spill rates, and platform health indicators. The adjustments yielded a thirty-one percent weekly compute cost reduction without degrading performance or increasing failures.

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

Worth reading?

Must-read

Winter ’27 release guides architects through security enforcement and agent scaling (opens in a new tab)

You will learn which authentication methods retire by early 2027 and how to migrate integrations to secure alternatives.

Why read this

The piece also outlines updated platform limits, new Agentforce orchestration patterns, and governance tools that shape long-term org architecture.

Winter ’27 Release

  • Mandatory security enforcements
  • Capacity and automation updates
  • Agentic architecture design
  • Governance and observability
The Winter ’27 release guides architects through four key architectural focus areas

The Winter ’27 guide presents the release as a set of coordinated architecture decisions across security, capacity, agentic design and governance. It recommends starting with operational risk, then judging whether new platform capabilities help existing configurations scale and fit the longer-term architecture roadmap.

The security section focuses on deadlines. Production refresh tokens expire after 30 days of inactivity starting November 4, 2026, which can break low-frequency integrations. The OAuth 2.0 device flow is restricted from November 30, 2026, and the username-password, user-agent and hybrid user-agent flows are retired on February 20, 2027. Salesforce to Salesforce retires in Spring ’27, and cross-org adapter authentication must move to Named Credentials. Connected Apps lose support by Summer ’27, so teams should move to External Client Apps, which are closed by default. The guide advises inventorying integrations, defining each trust boundary, and choosing replacements that will not face further restriction.

The capacity section covers higher limits and their risks. Synchronous Apex heap rises from 6 MB to 10 MB and asynchronous heap from 12 MB to 25 MB, so workarounds may be simplified. Elastic Async Apex Jobs (Beta) now covers batch jobs as well as future and Queueable jobs, with extra capacity capped at the lower of the licensed limit or 2 million jobs, and should be tested in non-production first. Flow improvements may make Apex built around older constraints unnecessary. Retained manual shares on ownership changes can replace recreation logic, but processes that depend on ownership changes removing access need review.

For Agentforce, Multi-Agent Orchestration is generally available and should be treated as a design-time topology decision. The API Catalog should be governed as the control point for the MCP servers and APIs agents can call, and Data 360 hierarchies should be planned as a data-architecture task. Governance tools include Security Health Review, Scale Center, MCP Server Monitoring (Beta) and Security Mesh. Each has edition, license or support-plan limits, and the guide names fallbacks such as Health Check, debug logs and existing observability tools. The guide closes by recommending an architectural decision record for each significant change.

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

Worth reading?

Recommended

Connecting metadata and runtime telemetry to prioritize enterprise org remediation (opens in a new tab)

Readers will learn how Salesforce Engineering correlates configuration metadata with production telemetry to identify and prioritize implementation anti-patterns.

Why read this

The piece outlines the architectural patterns used to standardize hundreds of health signals and expose them through headless APIs.

Salesforce Engineering addressed the challenge of monitoring enterprise org health at scale by moving beyond static reports to an in-app experience called Salesforce Health Insights. The team needed to correlate point-in-time configuration metadata with continuously changing runtime telemetry across systems that lack shared identity models.

To solve this, they built a harmonization layer that reconciles fragmented datasets and maps runtime activity to individual metadata components while accounting for traffic volume and seasonality. This architecture maintains clear boundaries between deterministic findings and external operational context, preserving data origin and freshness information.

The initiative expanded from roughly one hundred initial security signals to over four hundred covering process automation, customization, and agentic readiness. Each signal follows standardized metadata rules and remediation guidance derived from the Salesforce Well-Architected Framework and known system hotspots.

Findings are prioritized using operational context such as application CPU usage and peak business hour traffic to determine criticality and required effort. The system uses a headless schema that emits raw JSON for any user interface or agent, supports an MCP interface, and can deliver summaries directly to Slack channels.

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

Worth reading?

Recommended

Architecting real-time mobile personalization with server-side decisioning and content zones (opens in a new tab)

You will learn how to separate app instrumentation from campaign configuration so marketers can update experiences without app releases.

Why read this

The piece also explains how to maintain consistent identity resolution and dynamic native rendering across iOS, Android, React Native, and Flutter using server-side decisioning.

The team built a unified architecture to deliver real-time mobile personalization across iOS, Android, React Native, and Flutter. They solved platform fragmentation by establishing consistent schemas and event semantics while allowing each technology stack to use its native rendering capabilities. A bridge layer enables React Native and Flutter to access native APIs through iOS and Android, preserving a single SDK interface for developers.

Developers define stable content zones and register approved native components once. Marketers then configure templates, targeting, and component selection through the Salesforce user interface. The platform serves this metadata via a global CDN, and the mobile SDK applies the rules to dynamically render the correct native element without requiring new app builds.

Real-time identity resolution relies on Data 360 to merge anonymous web, email, and mobile interactions into a single profile during authentication. Decisioning runs entirely on the server, so the SDK only receives final experience instructions rather than raw customer data. Teams can validate targeting and layout using a QR code preview flow that injects live profile attributes into the simulator before launch.

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

Worth reading?

Use the account record to anchor identity, access, and onboarding in Experience Cloud (opens in a new tab)

You will learn how to structure Experience Cloud implementations around the account record to automate authentication routing, enforce consistent data access, and simplify multi-organization onboarding without additional deployments.

Introduces the challenge of scaling Experience Cloud portals for multiple independent organizations, each managing its own identity infrastructure and security standards. Relying on separate login paths and manual configurations quickly creates bottlenecks during onboarding.

Proposes using the account record as the central anchor for external user management. The user to contact to account relationship provides a stable context for storing identity provider preferences, authentication configurations, and onboarding status. This design keeps organization scoped policies centralized and easily retrievable.

Details the implementation steps, including configuring Login Discovery to route users based on account level settings instead of presenting multiple login buttons. Data access follows this same model by aligning lookup relationships with appropriate sharing mechanisms like Sharing Sets or standard Sharing Rules. These choices directly impact community license selection and must align with least privilege principles.

Concludes that treating onboarding as a configuration exercise rather than a deployment project allows administrators to bring new organizations online predictably. The approach reduces architectural complexity while maintaining secure, scalable access controls across the portal.

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

Worth reading?

Salesforce updates its Well-Architected Framework with five pillars and an agentic lens (opens in a new tab)

Readers will learn how the updated Well-Architected Framework restructures architectural guidance into five core pillars and applies them to agentic enterprise designs.

Why read this

The piece clarifies the trade-offs architects must balance when integrating autonomous agents alongside traditional Salesforce solutions.

Salesforce has released an updated version of its Well-Architected Framework to address growing architectural complexity and the rise of autonomous agents. The previous three-pillar model focused on trusted, easy, and adaptable solutions, while the new structure expands to five distinct categories.

The revised framework organizes guidance around trust, reliability, operational excellence, resource and cost optimization, and fairness. Each pillar includes a dedicated lens that examines how these principles apply when designing systems where agents can reason and take action across multiple platforms.

The update emphasizes architectural trade-offs, noting that optimizing for one quality often impacts another. Salesforce developed the framework through collaboration with the Office of the Chief Architect and feedback from hundreds of practitioners. The complete guidance is now available on the Architecture Center for immediate use.

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

Worth reading?

Cloud Atlas replaces per-instance rate limits with fleet-wide protection (opens in a new tab)

An inside account of why per-instance rate limits failed for the identity store behind Salesforce authentication, and what replaced them.

Cloud Atlas is the globally distributed identity data store behind a large share of Salesforce logins and token validations, run to five nines of availability. In this interview, the team’s engineering lead explains why overload at that layer is dangerous: slow responses cause upstream services to retry, the retries add traffic to a system already under pressure, and a local bottleneck spreads. Agent-driven and automated workloads have made traffic burstier and harder to predict than human logins.

The old protection was per-instance rate limiting. That held up while infrastructure was static, but with autoscaling each server’s limits went stale whenever instances were added or removed, and each server knew only its own load rather than a customer’s total usage across the fleet. Busy servers rejected requests while capacity sat idle elsewhere, and one tenant’s spike could still starve others.

The redesign protects the service as a whole instead of individual servers. It combines global quota management that needs no central coordinator with load shedding that acts before retries begin to amplify the overload, so a single customer’s surge is isolated rather than shared.

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

Worth reading?