The independent daily for Salesforce admins, developers and architects

Curated by Abhinav (opens in a new tab)

Recommended

Resuming a Salesforce CDC consumer from a durable replay checkpoint (opens in a new tab)

You will learn how to store Pub/Sub API replay IDs beside mirrored data, resume a gRPC subscription from them, and make replayed events harmless with an idempotent apply step.

Why read this

The reader also gets the 72-hour retention constraint that shapes the design.

  1. Begin transaction
  2. Decode each event and skip seen keys
  3. Apply fresh changes
  4. Save latest replay ID
  5. Commit or roll back
Each batch is applied and checkpointed in one transaction

A Change Data Capture consumer that restarts from the wrong position either drops record updates or replays several days of them. The article’s fix is a durable checkpoint: it stores replay IDs, resumes a gRPC subscription from them, and makes replays harmless. The worked example is a worker subscribing to the OpportunityChangeEvent channel and mirroring each change into Postgres, using Node.js, the Pub/Sub API and the pub_sub proto file from the Salesforce repository.

The design has three parts. The first is a checkpoint table holding one replay ID per channel, stored as bytes because Salesforce treats replay IDs as opaque, alongside a table of applied transaction keys so that replayed events become no-ops. The second is a subscription that resumes with the CUSTOM replay preset and the saved bytes, using LATEST only on the first run, with a fixed request count to keep memory flat and the stream paused while the database is awaited so that order is preserved.

The third part applies changes idempotently and checkpoints in the same transaction. Each event’s schema is fetched once and cached, its Avro payload is decoded, and it is inserted into the applied-keys table; only fresh keys are applied. The latest replay ID is saved even on empty keep-alive replies so quiet channels do not age out. The article notes the time limit: change events are kept for 72 hours, so the applied-keys table can be pruned after that period. It also points out the trade-off against the older CometD route, which costs gRPC setup and Avro decoding in exchange for flow control and replay tightening.

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

Worth reading?

Must-read

Building a Salesforce–NetSuite sync in Python that proves the two systems agree (opens in a new tab)

You will see how to enforce field ownership in code, make Salesforce and NetSuite writes retry-safe with external ID upserts, stay inside NetSuite's concurrency limit, and run a reconciliation report that catches drift.

Why read this

The worked code is Python with httpx and psycopg, not Apex.

  1. Source record changes and is enqueued
  2. Worker claims due rows under a lease
  3. Upsert by external ID to the other system
  4. Success marks the version as sent
  5. Retryable error backs off and retries
  6. Ambiguous match parks for review
Each change moves through the queue, from enqueue to upsert, with retry or review on failure

A software services client ran an off-the-shelf Salesforce–NetSuite connector for years, and the data drifted: customer names, invoice statuses and billing contacts stopped agreeing, and a sales rep’s edit once overwrote a legal billing name in NetSuite. The author argues that most CRM-to-ERP integrations fail by drifting rather than crashing, and rebuilds the integration around explicit field ownership, external IDs and a reconciliation report.

Field ownership is kept as data. NetSuite owned legal entity, billing terms, invoice balances and payment status, while Salesforce owned segmentation, Opportunities and account-manager assignments. Each outbound payload is built only from fields the source system owns, and mirrored fields are read-only in Salesforce. Records are matched through external IDs on both sides, and a cross-reference table holds the linkage, with a needs_review status for ambiguous matches.

Writes go through a queue holding one desired state per record with a version number, so repeated edits produce a single write. Workers claim rows with a lease, and writes are upserts by external ID, so a retry after a timeout does not create duplicates. The code shows how NetSuite and Salesforce each respond to upserts and to errors such as 429 and 300. Concurrency is capped with semaphores because NetSuite limits concurrent requests per account across all connectors. Invoice changes are pulled with SuiteQL using a keyset checkpoint, and a nightly reconciliation classifies each invoice as matched, stale, missing or wrongly linked.

The parallel run of the new integration against the old one exposed overwrites, wrong bill-to links and missed status updates. Invoice status went from a lag of 24 to 48 hours to normally 10 to 15 minutes, and the finance spreadsheet was retired once the daily report explained every remaining difference.

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

Worth reading?

Recommended

Route a voice agent's Salesforce calls through a small endpoint you control (opens in a new tab)

You will learn why a token-renewing middle endpoint suits a voice agent that cannot refresh OAuth tokens itself, how to set up a client credentials External Client App with a locked-down integration user, and how to log call results as Tasks without duplicates.

  1. Agent sends request with bridge key
  2. Endpoint attaches cached Salesforce token
  3. Salesforce returns success or error
  4. Endpoint passes reply back to webhook
  5. Webhook retries temporary failures
How a call result reaches Salesforce through the endpoint

The author treats Salesforce’s reply as the only proof that a call reached the CRM, so any non-success reply should trigger a retry. Because the Salesforce client credentials flow issues short-lived tokens with no refresh token, and the Dograh voice platform stores credentials only as fixed values, the design places a small HTTPS endpoint between the agent and Salesforce. That endpoint holds the Salesforce secret, caches tokens, and checks a fixed bridge key header before doing anything else.

The token logic fetches a token, reuses it, and on a 401 response fetches a fresh one and retries once, so nothing downstream has to handle expiry. For setup, the article recommends starting with an External Client App, since new Connected Apps are restricted from Spring ’26. It advises enabling OAuth and the client credentials flow, running the app as a dedicated integration user with the Minimum Access - API Only Integrations profile, and granting only read on Contacts and Leads plus create on Tasks.

For inbound calls, a pre-call data fetch can search Contacts and Leads by phone number before the agent speaks, matching on the last 10 digits to handle inconsistent formatting. The author warns to keep this fast and to confirm identity with an approved check before using any Salesforce data. After the call, a webhook files a Task on the matched record, with TaskSubtype set to Call at creation since it cannot be changed later. Retries can file duplicates, so the endpoint should track the run_id of filed Tasks and skip repeats. The article closes with testing advice: check View Trace after a live call, and test an unknown caller.

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

Worth reading?

Salesforce disables two Connected Apps over suspicious access token use (opens in a new tab)

You will learn that Salesforce disabled the Talent Rover and GoFundMe Pro Connected Apps and managed packages over suspicious access token use, and what the company said about their status.

Why read this

Read it if your orgs use either integration.

Salesforce disabled integrations with two Connected Apps in the week of November 10, 2025, after identifying suspicious use of access tokens linked to the third-party providers. The first advisory, posted on November 10, covered Talent Rover, a product owned by Bullhorn. Salesforce disabled its Connected Apps and managed packages as a precaution and said the issue did not stem from a vulnerability in the Salesforce platform.

The same day, Salesforce re-enabled the Talent Rover Connected Apps and managed packages after Bullhorn completed security remediation. The second advisory, issued November 11, applied the same measures to the GoFundMe Pro Connected App and its associated managed packages. Salesforce again said the core platform was not at fault.

Salesforce and GoFundMe are investigating the activity together. The GoFundMe Pro integrations will stay unavailable until remediation is complete and GoFundMe has shown they can be restored safely. Salesforce said it will notify affected customers without undue delay if it finds unauthorized access to their data. At the time of writing, GoFundMe Pro remained disabled, and the article notes the earlier Connected App problems of 2025, which led Salesforce to harden Connected App security.

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

Worth reading?

Recommended

Upserting Contacts to Accounts with an External ID in Data Loader (opens in a new tab)

You will learn how to set up a unique External ID on Account, load Accounts before Contacts, and map the source key to relate them without a post-load VLOOKUP.

Why read this

You will also see which reference fields cannot be mapped to External IDs and what still breaks.

  1. Create unique External ID on Account
  2. Back up and test a small subset
  3. Upsert Accounts
  4. Upsert Contacts, mapping Account:External_ID__c
The order of operations for relating Contacts to Accounts by External ID

Relationships in Salesforce are stored as record IDs, so a source system’s Account key in a Contact file cannot be used as AccountId. The walkthrough follows Salesforce Help: create or reuse a unique External ID field on Account, load Accounts first (insert, or upsert for reruns), then upsert Contacts and map the source-key column to the Account:External_ID__c field.

The steps include backing up and testing with a small subset, and the Data Loader wording is quoted from Salesforce Help rather than a live run. The example data is invented and was not loaded into an org. A Contact whose key is missing from the Accounts will fail, and that failure appears in the error file.

The piece lists the main failure causes: blank or non-unique External IDs, child rows loaded before the parent, and Lookup Filters or Validation Rules. It also notes that Polymorphic Fields and a Custom Object’s Owner cannot be mapped to External IDs, and that a successful upsert does not prove the source key was correct.

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

Worth reading?

Building a household intake workflow from FormAssembly into Salesforce (opens in a new tab)

You will see how to model a variable-length child intake as a staging parent with a Master-Detail child Custom Object, and how to avoid the flat-file and metadata-caching faults that break such integrations.

Why read this

The reader gets a worked example of a real external form pipeline.

Denormalized parent

  • Member_1 to Member_10 columns
  • Blank fields sent as nulls
  • Submission rejected

Normalized model

  • Household_Submission__c parent
  • Household_Member__c children
  • Master-Detail relationship
The flat parent layout failed, and normalising to a Master-Detail child model fixed it

The author argues that public intake forms are better handled by a dedicated external form engine than by a Salesforce Experience Cloud site, which needs heavy configuration and guest-user sharing management. They test the new FormAssembly platform, which models data collection as an end-to-end workflow with an AI assistant, Fai, that builds the form from a plain-language specification.

For a household intake where the number of members varies, Fai offered three designs and the author chose fixed member sections with conditional visibility, so that the required sections match the declared household count. The data then goes to a staging Custom Object rather than directly to Contact or Account, to avoid creating duplicates from unverified input.

The article records two pitfalls. Denormalized numbered member columns on the parent produced null payloads that caused the submission to be rejected, so the schema was normalized to a Household_Submission__c parent and a Household_Member__c child joined by Master-Detail. A deleted lookup field also remained in the connector’s cached metadata, and updating the field mapping to the new API name resolved the error.

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

Worth reading?

Recommended

Finding missing and duplicate records after a migration by matching external keys (opens in a new tab)

You will learn a method to reconcile two CSV exports on a shared External ID, using spreadsheet formulas to flag records that are missing, extra, duplicated or have blank or mismatched keys.

Why read this

You will also see why to check parent objects first.

  1. Export source and target with the shared key
  2. Count blank and duplicate keys per sheet
  3. Match each row in both directions
  4. Review missing, extra and duplicate statuses
  5. Repeat per object, parents first
Reconciling source and target exports by external key, in order

After a migration, record counts can look right while hiding records that never arrived, records loaded twice, and records with no source. The article argues that the Salesforce Id cannot be used for matching because it is regenerated on insert, so you need a key present on both sides, such as a legacy ID held in an External ID field like Legacy_ID__c.

The method uses two exports and a spreadsheet. Keys are first checked for blanks and duplicates with a case-sensitive EXACT-based count, since COUNTIF ignores case. A status formula on each sheet then labels each row as OK, Missing in target, Extra in target, Duplicate key, Blank key or similar, which is checked in both directions so that a duplicate in the target shows up only when both sides are compared.

The author recommends running this per object, starting with Accounts and then Contacts and Opportunities, because a missing parent explains gaps underneath it. The method does not compare field values or verify parent relationships; the article points to separate posts for those checks and mentions a paid tool it sells.

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

Worth reading?

Must-read

Migrating HubSpot to Salesforce: External IDs, upsert, and load order (opens in a new tab)

Readers will learn how to structure a reliable HubSpot to Salesforce data migration using External IDs, proper load ordering, and Bulk API, including strategies for handling hierarchies, deltas, and validation.

  1. Cleanse data and map picklists
  2. Dry run in sandbox with disabled automations
  3. Load records following dependency order
  4. Enable read only mode and run delta load
  5. Verify record counts and relationship integrity
Phased migration process from HubSpot to Salesforce

The article addresses the complexity of moving historical records and relationships from HubSpot to Salesforce, emphasizing that simple export import fails due to differing data models. It establishes the External ID field as the foundation for tracking records, enabling idempotent upserts, and linking related objects without relying on Salesforce generated identifiers.

It outlines a strict dependency sequence for loading records, starting with Users and Accounts before moving to Contacts, Opportunities, and Activities. Special attention is given to Account hierarchies, recommending a two pass approach to avoid parent child reference errors. The piece includes a Python example using the Bulk API to demonstrate upserting an Opportunity by matching its Account via an External ID rather than a native Salesforce identifier.

Before migration, the author stresses data cleansing, deduplication rules, and mapping picklist values like pipeline stages. A sandbox dry run is recommended to generate repeatable error reports and to temporarily disable automations such as Flow and Apex triggers that could trigger unwanted side effects during bulk loads.

The final phase uses a delta load strategy to capture changes made after the initial bulk transfer, requiring source system read only mode and timestamp tracking. Post migration validation involves comparing record counts, verifying relationship integrity, reconciling financial totals, and spot checking field values to ensure data accuracy before full team adoption.

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

Worth reading?

Must-read

Salesforce retires the OAuth username password flow and guides migration to client credentials (opens in a new tab)

Readers will learn how to identify integrations still using the retiring authentication method and follow step-by-step instructions to migrate them to supported flows like client credentials or web server with PKCE.

  1. Create an External Client App
  2. Configure the Run As User
  3. Get the Client ID and Client Secret
  4. Update the Authentication Request
  5. Handle Token Expiration
Migration steps to replace the retiring OAuth username-password flow with the client credentials method

Salesforce will retire the OAuth 2.0 Username-Password Flow on February 20, 2027. The flow has an external application send a Salesforce username, password and security token to the token endpoint. Salesforce first announced the change in Spring ’26 and later moved enforcement from Winter ’27 to the Spring ’27 release. The article calls this a breaking change: integrations that still use the flow will fail when they request new access tokens after enforcement, and the failures may go unnoticed, such as a scheduled job that quietly stops updating records. Orgs created in Summer ’26 and later already block the flow, and the article says that an org with no matching release update may already be blocked.

To find affected integrations, the article recommends several checks. Create a Login History view filtered on the OAuth Username-Password login subtype, keeping in mind that history is kept for about six months, so an empty result does not prove that nothing is affected. Review Connected Apps in App Manager, although the Connected Apps OAuth Usage page does not show these integrations. Search middleware, custom code and repositories for grant_type=password, the Resource Owner Password Credentials term and calls to the token endpoint, checking the grant_type value because other flows use the same endpoint. Managed packages and third-party applications also need review, and the article suggests asking vendors whether they use the flow and what update is required.

The replacement depends on the integration. Client Credentials suits server-to-server work, Web Server Flow with PKCE suits applications that act for individual users, and JWT Bearer suits certificate-based server-to-server setups. For Client Credentials, the article describes creating an External Client App with the api scope, enabling the flow, and choosing a Run As user with only the permissions the integration needs. It also warns that a different user may lack the original user’s record access. The token request changes to grant_type=client_credentials without a username or password. Because this flow issues no refresh tokens, the integration should request a new token when the current one expires, not for every call, and should include retry handling.

The PKCE flow sends users to Salesforce to sign in and authorize the app, then exchanges an authorization code and a code verifier for a token, and it can use refresh tokens. JWT Bearer uses a signed assertion checked against a certificate, which means certificates must be managed. The article also notes that legacy Connected Apps lose full support in Summer ’27, and that migrating one to an External Client App does not fix the username-password dependency, because External Client Apps do not support that flow.

To test, the article advises disabling the Allow OAuth Username-Password Flows setting in a sandbox under OAuth and OpenID Connect Settings, then running each integration. Successful connection tests can be misleading because cached sessions may keep working for a while, so each integration should obtain a fresh token through a supported flow. Failures may show an invalid_grant error and an OAuth Username-Password Flow Disabled status in Login History. The article’s main advice is to start the inventory and migration well before the deadline.

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

Worth reading?

Recommended

How to stream Salesforce Platform Events to AWS using Event Relay and EventBridge (opens in a new tab)

You will learn how to configure Salesforce Event Relay to publish custom Platform Events to Amazon EventBridge without middleware.

Why read this

The guide covers channel setup, payload structure, error recovery options, and capacity limits so you can design a reliable integration.

Organizations often rely on expensive middleware to synchronize Salesforce data with AWS applications. This article demonstrates a direct integration path using Salesforce Event Relay and the Amazon EventBridge partner connection, removing the need for third-party platforms. The example tracks Account creation and pushes the details to a DynamoDB table.

The configuration requires a Named Credential pointing to the target AWS account, a Channel grouping the specific Platform Event type, and an Event Relay linking the two components. Once activated, Salesforce publishes record changes to its internal event bus. The relay reads these messages and forwards them to a dedicated AWS partner event bus, maintaining delivery state to resume after transient failures.

The relayed payload places event fields under a detail node, allowing AWS routing rules to send messages to an SQS queue for buffering before a Lambda function processes them into DynamoDB. The author highlights critical operational parameters, including the seventy-two hour retention window, LATEST versus EARLIEST error recovery modes, daily delivery quotas per edition, and the necessity of designing idempotent consumers to handle duplicate messages during failover.

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

Worth reading?

Connecting Slack to Salesforce for record context and automated alerts (opens in a new tab)

Readers will learn how to use Guided Slack Setup to link a workspace, place the Slack component on record pages, and route Flow notifications to channels.

The article outlines the steps for linking a Slack workspace to a Salesforce org using the native Guided Slack Setup flow. Administrators verify the connection status, authenticate with Slack, and mark each configuration step as complete to maintain a clear rollout trail.

Once the connection is active, the Slack component can be added to Lightning Record Pages through App Builder. This places conversation history directly on layouts for objects like Accounts, allowing team members to view messages and reply without leaving the CRM while preserving record context.

The guide also demonstrates how to send automated alerts to Slack channels by configuring Flow Builder processes that trigger on stage changes or escalations. Users gain the ability to search for records and update fields from within Slack, with modifications syncing back to Salesforce in real time.

Rollout recommendations stress validating permissions with standard profiles, launching with a single object, enforcing consistent channel naming, and tracking adoption rates to optimize component placement and workflow design.

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

Worth reading?

Recommended

Generate custom Salesforce Connect adapters with AI skills and headless registration (opens in a new tab)

You will learn how to use the platform-salesforce-connect-adapter-generate skill to automatically create DataSource classes for any REST API.

Why read this

The piece also explains how to register the external data source programmatically using the Headless 360 MCP Server instead of manual setup steps.

Custom Salesforce Connect Apex adapters require implementing DataSource.Provider and DataSource.Connection interfaces, which traditionally demands significant Apex expertise and careful handling of field types, pagination, and error contracts. The article introduces the platform-salesforce-connect-adapter-generate skill, an open-source capability that grounds coding agents in this exact framework so they produce syntactically correct and contract-compliant code on the first attempt.

Using a natural language prompt, a developer can instruct an agent like Claude Code or Agentforce Vibes to generate both adapter classes, map json fields to correct datasource datatypes, enforce required ExternalId columns, and wire Named Credentials without hardcoding secrets. The post demonstrates this with a public rail api example, showing how the generated Connection class handles query context and returns a properly structured TableResult.

After deploying the Apex classes via the Salesforce CLI, the article explains how the Headless 360 MCP Server exposes configuration operations as programmatic tools. This allows the same agent to create the external data source definition through an api call rather than navigating the Setup wizard. The author notes that Winter ’27 will expand this approach to cover the full lifecycle of external data sources and standard adapter extensibility.

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

Worth reading?

How API-Driven Integration remains essential as AI agents expand into Salesforce (opens in a new tab)

You will learn which three integration APIs form the foundation of Salesforce connectivity and how they support emerging AI agent workflows.

Why read this

The piece also outlines the current certification roadmap and upcoming MuleSoft credential changes.

The video argues that artificial intelligence agents interact with the platform through application programming interfaces rather than user interface clicks, making integration expertise increasingly vital. It identifies three foundational tools that practitioners should master first.

The REST API handles standard create, read, update, delete operations and data queries. The Bulk API processes large scale jobs involving fifty thousand or more records. Platform Events combined with the Pub/Sub API enable reliable publish subscribe messaging between systems.

The Certified Platform Integration Architect certification path serves as a stepping stone toward System Architect and CTA designations. Two MuleSoft credentials will retire on February 1, 2027 while the product line continues to operate. Salesforce now classifies Headless 360 capabilities under Agentforce revenue metrics, reporting annual recurring revenue exceeding one point five billion dollars.

Watch the video at MyTutorialRack on YouTube (opens in a new tab)

Worth reading?