The independent daily for Salesforce admins, developers and architects

Curated by Abhinav (opens in a new tab)

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?

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?