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 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?

How LWR differs from Aura for Experience Cloud sites and what migration involves (opens in a new tab)

You will learn how Lightning Web Runtime delivers pages differently from Aura, where the performance gains come from and where they do not, and what an Aura-to-LWR migration usually involves.

Why read this

The piece helps you decide whether a new or existing site should move to LWR.

Aura

  • Components delivered dynamically
  • No republish for component changes
  • Broader existing template set

LWR

  • Static, cacheable resources
  • CDN can serve eligible files
  • Republish to expose component changes
LWR publishes cacheable resources, while Aura delivers components dynamically

Lightning Web Runtime (LWR) is the newer runtime behind Experience Cloud templates such as Build Your Own (LWR) and Microsite (LWR). Components are built with Lightning Web Components, and the site publishes prepared, cacheable resources that can be served through a content delivery network. Aura delivers components dynamically, so LWR can load faster, but the article stresses that speed is not guaranteed. Large images, unnecessary API calls and poorly designed custom components still slow pages, and integration changes may matter more than the storefront technology.

The main practical differences are in publishing and component support. Aura sites can pick up component code changes without republishing, while LWR sites must be republished for updated components to reach visitors. Standard LWR templates use LWC only, and LWR offers fewer templates and components than Aura, so some Aura features have no direct equivalent. Salesforce recommends LWR for new B2B Commerce storefronts and encourages migration from Aura-based B2B stores.

Migrating an Aura site usually means replacing Aura components with LWC, while many existing LWCs can be reused with few changes. The article advises inventorying components and dependencies, transferring storefront configuration, and testing the full user journey. It also recommends recording baseline performance with tools such as Lighthouse, WebPageTest and Core Web Vitals before and after migration.

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?

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?

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?

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?