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?

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?

Five timing decisions that determine whether a Scheduled Flow runs reliably (opens in a new tab)

You will know five design choices to settle before activating a Scheduled Flow: run window, repeat-safety, batch sizing, failure handling and run context.

Why read this

The article is a practical checklist rather than new platform information.

  1. Pick a quiet run window
  2. Make repeat runs safe
  3. Size batches for volume
  4. Catch failures loudly
  5. Confirm the run context
The five timing decisions to settle before activating a Scheduled Flow, in order

The author argues that a Scheduled Flow should be designed around timing, since nobody watches it run. The run window should avoid overnight integrations, data loads and backups that might lock the same records, so admins should check scheduled Apex jobs and ask integration owners before choosing a start time.

Because a daily Scheduled Flow re-evaluates its entry criteria on every run, records that still qualify will be processed again. The article recommends a flag field, a date stamp or a processed checkbox so that updates happening once are not repeated, and it treats batch sizing as a deliberate design decision, warning that a Flow tested on fifty records can hit governor limits at fifty thousand.

The piece also covers failure handling, which is quieter than for Record-Triggered Flows, and run context, since Scheduled Flows run in system context by default and bypass Sharing Rules and field-level security. It closes by suggesting a monthly review of every active Scheduled Flow as business rules and fields change.

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

Worth reading?