Data Sync Pro · Customer Story
Data Sync Pro at a leading global pharmaceutical solutions organization
Customer Story · Batch Optimization

18 hours of batch processing,
down to under two.

a leading global pharmaceutical solutions organization is paying down years of accumulated Salesforce tech debt with Data Sync Pro — replacing slow, hard-to-maintain Apex batch jobs with configuration. The result: run times cut by up to 95%, errors eliminated, and full audit logging out of the box.

275
Batch Executables converted from Apex batch classes to date
20×
Peak throughput gain on the same dataset
Days → Hours
Build effort per batch job, code to configuration
100%
Compliant — logs, failure alerts and audit trails, out of the box
Slots freed
Scheduled-job slots reclaimed by chaining, easing Salesforce's 100-job cap

Figures as of July 6, 2026.

The challenge

Years of tech debt, hitting governor limits.

The distributor's Salesforce org had accumulated significant technical debt, and batch jobs were among the top contributors. Long-running Apex batches strained the platform, consumed scheduled-job capacity, and — in production — began failing outright against governor limits.

Hours-long runs

Core data-management batches ran for hours — one job took 18 hours to complete — pushing nightly windows and eating into scheduled-job slots before they hit the limit.

Failing in production

A large data-sync job was erroring out in production — hitting platform ceilings on CPU and query count with no clean way to recover the failed run.

CPU TimeoutToo Many SOQL

Hard to audit & maintain

Each Apex batch needed custom logging, custom failure handling, and senior developers to maintain — leaving little evidence for compliance on mass data changes.

The approach

Replace Apex batch classes with DSP Executables.

Rather than incrementally tuning Apex, the team rebuilt each batch job as a Data Sync Pro Executable record — configured through a guided interface, no custom code. The same logic, delivered as configuration, with capabilities that took custom engineering before now available as a checkbox.

Bulk API throughput

Apex: no Bulk API, slow. DSP supports Bulk API — up to 10× faster with larger batch sizes.

Delta retrieve & action

Apex: required custom coding. Process only what changed — enabled via checkboxes, avoiding unnecessary DML.

Bulkified transformations

Apex: hand-bulkified, error-prone. Built-in functions are bulkified by design — no manual bulk logic, no hidden performance traps.

Job chaining

Apex: enforced in every class. Chain jobs in the UI — one click, no code threaded through each batch.

Standard logging

Apex: custom code per job. Batch-level logs with record IDs, exceptions and governor-limit detail — out of the box.

Preview & re-run

Apex: blind runs, no recovery. Preview source data and sample transforms before executing; re-run failed batches with one click.

The results · benchmarked

Same jobs. A different order of magnitude.

Measured on the distributor's own data across the first four optimization waves — prioritizing the slowest, highest-impact jobs. Every job below does exactly what it did before, just rebuilt on DSP.

Lever 01

Bulk API

Switch the engine from row-by-row processing to Salesforce Bulk API — large batch sizes, far fewer transactions.

Lever 02

Incremental Retrieve

Query only the records that actually changed since the last run, instead of re-reading the entire object every time.

Lever 03

Delta Update

Write back only the rows whose values differ — skipping unnecessary DML and the lock contention that comes with it.

Lever 04

Built-in bulkification

DSP's functions are bulkified by design — no hand-written bulk logic to get wrong, removing a common source of slow, limit-breaking Apex.

All configuration, no custom Apex — these levers account for the gains below.

Batch job Records Before After Faster
AggregateFields•••Aggregate field values onto parent records
~900K
18:00:00
1:50:00
90%
UpdateHierarchy•••Update related-record hierarchy
~700K
9:00:00
0:06:00
99%
SyncExternal•••Sync external data back onto records
~600K
6:00:00
0:20:00
95%
RollupValues•••Roll up child-record revenue values to parent
~10K
2:15:00
0:06:00
95%
SetReferences•••Set reference fields from related records
~100K
0:50:00
0:08:00
85%
StagingLoad•••Load processed data from a staging table
~60K
0:30:00
0:05:00
83%
GenerateRecords•••Generate related records from source data
~20K
0:05:00
0:01:30
70%
Why it works

Custom code vs. configuration.

The performance gain is real, but the durable win is everything around the run — logging, recovery, compliance and maintenance — that DSP provides as standard.

Capability
Traditional Apex batch
DSP Executable
Build effort per job
Days — write & test Apex batch classes.
Hours — configure via the guided UI. No code.
Performance
Slow; no Bulk API support.
Bulk API supported — up to 10× faster with larger batch sizes.
Incremental processing
Re-reads the whole object and re-writes every row each run — incremental logic is a custom build.
Retrieve only changed records & write back only differing rows — enabled by checkbox, skipping wasted DML.
Logging
Custom code per job; hard to standardize.
Standard batch-level logs — record IDs, exceptions, governor limits.
Re-run failures
No — failures get missed or force a full re-run.
One click to re-run failed batches from the execution log.
Preview before run
No.
Preview source data & sample the transform first.
Job chaining
Salesforce caps chained batches; teams build fragile workarounds.
Chain Executables into Pipelines — past the 100-job limit, freeing scheduled-job slots.
Scheduling
Rigid Setup forms or cron expressions; hard to see what's scheduled.
Manage scheduled jobs as records — pause, reschedule, reassign. No cron.
Compliance
Little evidence for mass-data-change audits.
Every run is a tracked record — who, what records, when.
Monitoring & alerts
Little visibility into runs; failure notifications are a custom build.
Real-time execution logs with failure notifications — enabled by checkbox.
Maintenance
Hard to maintain; needs senior developers.
Modular, no-code — easy to maintain.

See what DSP can do
in your org.

Bring your slowest batch job. We'll show you how it runs as a Data Sync Pro Executable — and what it would take to retire the Apex behind it.

Request a demo Start free on AgentExchange