Records change here all day — orders, contacts, prices, status.
And they change here too — the same records, edited by another team.
Kept in sync. Both ways.
Two-way sync across two or more systems — with change tracking on each side, explicit conflict resolution when the same record is edited twice, and operator tools to inspect and replay. Not a one-way ETL that quietly overwrites the truth.
When both sides change the same record.
This decision — not the field mapping — is what makes a sync system. Every field gets one of these rules, agreed up front and inspectable later.
- 01
Source-of-truth wins
One system is declared the owner of a field; its value always overrides the other.
When to use it — billing amounts, account status, anything with a single authoritative system.
- 02
Last-write-wins
The most recent edit, by timestamp, is the one that survives the collision.
When to use it — fast-moving, low-stakes fields like a status note or a last-contacted date.
- 03
Field-level merge
Edits to different fields of the same record are both kept; only true overlaps need a decision.
When to use it — rich records where two teams touch different parts of the same customer.
- 04
Queue for a human
Genuinely ambiguous collisions are held and surfaced to an operator to decide, not guessed.
When to use it — irreversible or high-value changes where a wrong auto-merge is expensive.
One-way ETL keeps breaking because reality goes both ways.
A one-way pipeline assumes the data only ever changes in one place. It never does. You copy customers from the CRM into your product, someone fixes a phone number in the product, and the next run quietly overwrites it with the stale CRM value — so a person re-keys it by hand, forever. The export isn't the problem; pretending the data flows one direction is. We capture changes from each system, decide collisions with explicit rules, and write the result back both ways — so the systems agree instead of fighting.
Detect change
A webhook, change feed, or modified-since cursor flags exactly what moved — on either side.
Resolve conflict
The agreed rule decides the outcome when the same record changed in both systems.
Apply
The resolved value is written to the other system idempotently, with our own writes tagged to stop loops.
Record
Every change, decision, and write is logged so it can be inspected and replayed later.
Change capture from each system
We listen to every system that holds the data — webhooks and change-data-capture where they exist, efficient incremental pulls where they don't — so each side reports what changed instead of being re-read from scratch.
Conflict-resolution rules
Per-field, explicit rules — source-of-truth, last-write-wins, field-level merge, or a human queue — agreed before launch and visible in the record history, so a collision has a known, defensible outcome.
Replay & inspection tools
An operator view to look up any record's full history — what changed, which rule fired, what got written — and replay a single change or a whole window after a fix, without re-running the entire sync.
Health dashboard
One place to see the state of every connection: throughput, error rate, queued conflicts, and whether each side is keeping up — so 'is sync healthy?' is something you can look at, not feel.
Cost & lag monitoring
Per-connection visibility into API spend, call volume, and propagation lag, with alerts when a system falls behind or starts getting expensive — so you tune it on purpose, not after a surprise bill.
Two systems, one agreed truth.
Changes flow both ways, collisions resolve by rule, and every decision is on the record.
The work behind two systems that stay agreed.
Map ownership
For every shared field, decide which system owns it and how each side changes it today.
Choose the rules
Pick a resolution rule per field — source-of-truth, last-write, merge, or human queue.
Build the sync layer
Change capture, idempotent writes, echo suppression, replay, and monitoring around both sides.
Backfill & reconcile
Align history, prove the collision cases, and run it under real load until the diff is clean.
Operate & alert
Hand over the dashboard, the conflict queue, and alerts on lag and cost so it stays trustworthy.
Questions teams ask first.
Two systems that keep disagreeing?
Tell us which systems are out of sync and where the data hurts. We'll map who owns what, agree the conflict rules, and build two-way sync with replay, a health dashboard, and lag and cost monitoring — so they finally agree.