Skip to content
Faisal Mahmud TusherDigital marketing, SEO & analytics
with Faisal Tusher

CRM & Marketing Automation › Troubleshooting

CRM Values Changing Back After a Sync

Why a corrected CRM value reverts overnight: two systems writing one field, a workflow overwriting corrections, imports that write on match and last-edit-wins.
Troubleshootingintermediate17 min readUpdated

First, read the record's history for who wrote the field and when

Open one record that reverted and read its field history before touching any setting. The tutorial on auditing CRM fields finds every writer of a field from the change history on a sample of records, and the same history is where this record's writer and its time are found. The two lines that matter are the correction and the write that undid it. The second line names the writer, or at least the user it ran as, and its time says which kind of writer to suspect: a change at the same hour each night points at a scheduled sync or a nightly workflow, a change on the same day each month points at an import, a change that recurs since a cutover date points at a migration, and a change seconds after the correction points at a workflow triggered by the correction itself.

Check first that you are reading one record. A value that seems to flip can be two records for the same person, each holding a different value, which the diagnosis for duplicate contacts in the CRM traces to its entry point and which is a deduplication job rather than a sync one. If the history shows one record and two writers, this page applies.

Then ask who should own the field. The guide to syncing the CRM and the marketing platform writes the sync as a contract with one owning system, one accountable team and one direction per synced field, and uses the RACI matrix to write it, because that framework insists on exactly one accountable role per row. A field that two systems may write has no owner, and its value is whatever was saved last. Reading the history against that table turns the symptom into a lookup: either the field has an owner and something else wrote it, which is a fault to fix, or it has no owner, which is a decision to make.

Two cases deserve naming before the table. Corrections made by the person, or by a colleague on their behalf, are values the syncing guide says no sync may overwrite, because accuracy is one of the GDPR's principles as the glossary entry states it, and people have a right to have their data corrected. And consent reverting from objected to subscribed is the clearest case of all: the syncing guide's rule for consent fields is that the most restrictive value wins, whichever system recorded it and whenever, and the ICO's direct marketing guidance, as that guide cites it, is the authority for honouring an opt-out promptly in every tool. When the reverted field is a consent field and a message has already gone out, the diagnosis for unsubscribed contacts still receiving email works back from the message to the rule that let it through, and this page hands the consent case to it.

Diagnosis table

Diagnosis

SymptomCheckLikely causeFix
The value reverts after each scheduled sync, in the direction of the other system's valueThe field ownership table, and whether both systems may write the fieldBoth systems are allowed to write the field, so its value is whatever was saved lastGive the field one owning system; make the other side read-only or give it a request field
A hand-made correction reverts within minutes, or on the next run of a workflowThe workflow run history for the record and which field the workflow writesA standardising or scoring workflow writes over a value a person corrected by handWrite only the clean field, trigger only on the raw field and skip records with a manual value
Stage, source or owner reverts on existing records on the day a list was loadedThe import log, its batch tag and its rule on a matchAn import set to overwrite on match resets stage, source or owner on existing recordsFill empty fields only; restore affected records from the pre-import export
Whole records revert, or a value lands in the wrong field after a field was renamedThe connector's documented append or replace behaviour and its field mappingThe connector appends or replaces whole records, or a renamed field maps to the wrong targetMatch the connector's behaviour to the field's rule and repair the mapping
Two fields hold the same thing and only one reverts, or the history names a writer nobody listedThe field dictionary's writers for the field, and the change history on a sampleA field with two names, or an undocumented field another system still writesMerge the fields, name one writer and retire the other in stages
Reverting began at a migration cutover and restores values the old system heldWhether the old system is still live, still connected, or still feeding a loadA migration that let the new system's load write over history the old system still sendsFreeze the old system, make it read-only and repoint every integration

Fix, verify and prevent each cause

Both systems write the field

The syncing guide names lifecycle stage as the field most often written by both sides, because a scoring workflow in the marketing platform is built to advance it while sales moves it in the CRM, and the stage set by sales reverts overnight. Its answer is to pick one writer: the CRM owns the fields sales and the pipeline depend on, the marketing platform owns the engagement fields it observes and the score it calculates, and if the marketing platform needs to promote a lead it sets its own request field and a CRM workflow applies the change under the CRM's rules, so the stage history stays in one place. Most-recent-edit wins is the rule that produces flip-flopping, because each system's next save counts as the most recent edit.

Fix: add the field to the ownership table with one owning system, one accountable team and one direction, make the other system's copy read-only, and where the other system has a genuine reason to request a change, give it a request field that a workflow in the owning system reads.

Verify: set the value in the owning system, wait for the next scheduled sync and the next run of every workflow that touches the record, and confirm the value holds; then set the request field in the other system and confirm the owning workflow applies it once.

Prevent: keep the ownership table beside the automation inventory, name fields so the writing system is visible, and treat a new synced field, or a new writer of an existing one, as a reviewable change rather than a connector setting.

A workflow overwrites a correction

The tutorial on standardising CRM field values builds workflows that clean country, role and company values as records arrive, and it names the fault that turns a helpful workflow into a second writer: a standardising rule that overwrites a manual correction, or triggers itself on its own write. Its three guards are the fix. The workflow triggers only on a change to the raw field and writes only to its own clean field, so its own action can never restart it. A condition skips records where a person has set the clean value by hand, so a correction is never undone. And no other workflow or integration writes the clean field; if one must, it becomes the field's owner and this workflow stops writing it. The same guards apply to a scoring workflow that writes a stage or a grade someone has set deliberately.

Fix: read the workflow's run history for the reverted record, add the manual-value skip condition, narrow the trigger to the raw field, and record which values the workflow wrote, with a date, so a workflow value can be told apart from a chosen one.

Verify: set a clean value by hand on a seed record, change its raw field, and confirm the hand-set value survives the run; then change the raw field on a record with no manual value and confirm the workflow still maps it.

Prevent: run seed records through every path before any standardising or scoring workflow is activated or edited, as the tutorial does, with a manual correction among the paths.

An import that overwrites on match

The tutorial on importing contact lists describes the overwrite setting as the one that turns customers into new leads and erases how they first arrived, and it cannot be undone by deleting the import afterwards. Its safe default on a match is that the import may fill empty fields and add the person to the new campaign but never overwrites original source, created date, lifecycle stage, owner or consent, with any exception decided field by field before the load. A monthly supplier list, a partner spreadsheet or a bulk update loaded with the overwrite setting restores an old contact name, an old owner or an old stage on every record it matches, on the same day each time it runs.

Fix: find the records the load changed by its batch tag and the import date, restore the affected fields from the export taken before the load, and switch the import's rule to fill-empty-only unless a written decision says otherwise for a named field.

Verify: load a small sample containing known existing customers through the corrected rule and confirm their stage, source, owner and consent are unchanged.

Prevent: run every import and bulk update through the tutorial's steps, with the sample load before the full load, a batch tag on every row and the overwrite decision recorded on the import, so the next person running it inherits the rule rather than the default.

A connector that replaces, or maps a renamed field wrongly

Some reverts are not about ownership but about how the connection moves data. The data flow and integrations guide lists the patterns: many destination tools treat an upload as a replacement for the list or record it matches while others append, so a sync that replaces an append-only field wipes what was there, and one that appends to a field that should be replaced grows it forever. Schema drift is the quieter version: a source renames a parameter, adds a field or changes a type, and every downstream mapping breaks or silently fills a column with nothing, so the renamed field's value lands in the wrong target or the old target keeps an old value. The guide's defence is to read the destination's documented behaviour before the first sync and to keep a versioned contract between the systems.

Fix: read the connector's documented append-or-replace behaviour against the rule each affected field needs, repair the mapping for any field that was renamed or retyped, and re-run the sync for the affected records.

Verify: change a seed value in the owning system, run the sync and confirm the value arrives in the right target field with the rest of the record intact; then rename a test field in a sandbox and confirm the mapping fails loudly rather than silently.

Prevent: keep the integration register current, recording for every connection which pattern it follows, the identifier it keys on, the fields it maps and the check that shows it failing, and add a freshness, volume and completeness check to each flow so a column that empties after a release is caught the same week.

A field with two names, or an undocumented writer

A CRM that has run for a few years holds several fields for the same thing under different names, created by different teams or integrations, and fields that a retired form tool or a former integration still writes. The tutorial on auditing and documenting CRM fields finds them by listing every field, recording how often each is filled on recent and older records, and finding every writer from the change history on a sample of records, the form mappings, the integration settings and the workflow inventory. A field with several writers needs a written rule about which one wins; a field with no current writer is frozen; and a second industry or source field that an old integration still fills is the kind of writer nobody suspects until the history names it.

Fix: find every writer of the reverting field and of any field that duplicates it, merge the duplicates into one field by mapping and moving the values, change every form, import template and integration that wrote the old one, and retire it in stages: hide it, stop every writer, watch for anything that breaks, archive, then delete.

Verify: the field dictionary names one writer for the field, and the change history on a sample of records shows only that writer after the change.

Prevent: keep the field dictionary with writers, readers, owner and purpose for every field, name fields written by integrations so the writing system is visible, and make the rule for adding a field ask for its writer and reader before it is created.

A migration still writing history

The tutorial on moving to a new CRM describes the losses a migration causes without losing a record: fields that should be written once, such as original source and the created date, are written again by the import, and owners, stages and consent flags land where the map put them. When the field that reverted is original source, so that every lead now reads import, the diagnosis for a blank or wrong CRM lead source traces that symptom to its entry points alongside the capture gaps that produce it. The version that keeps happening after cutover is the one this page meets: the old system is still live, still connected to a form or a sync, or still feeding a scheduled load, so every value corrected in the new system is restored from the old one on the next run. The tutorial's order prevents it: announce a freeze on the old system, take the full load, load the changes made since the last export, point forms and integrations at the new system, and make the old system read-only from that point, with the agreed reports run in both systems until they agree.

Fix: find every connection, load and form still pointing at the old system, from the integration register and the old system's own activity, repoint or stop each one, and make the old system read-only; then carry original source and the dates that matter in clearly named fields the import cannot overwrite, and re-apply the corrections that were lost.

Verify: a sample of records holds the corrected values after a full day, and the parallel check of the agreed reports agrees between the two systems.

Prevent: treat the cutover as the one-way door the tutorial describes, with the freeze, the final load of changes and the read-only old system as steps that happen in order, and update the integration register and the field map so they describe the new system rather than the project.

Prevention: one owner per field and a seeded correction that every sync change has to keep

Every cause above is a writer nobody listed. The prevention is a list of writers for every field that matters, one owner per field, and a handful of seeded records whose values prove that nothing else is writing. The syncing guide's ownership table is the first part, and the table below extends it to the writers that are not the sync.

WriterRuleWhat proves itOwner
The marketing platform syncOne owning system and one direction per field; owner wins; most restrictive wins for consentA seeded record with a sales-set stage and an objected consent value that survives every syncWhoever owns the sync
Standardising and scoring workflowsWrite only the clean field; trigger only on the raw field; skip manual valuesA seeded record with a hand-set clean value that survives a raw-field changeEach workflow's inventory owner
Imports and bulk updatesFill empty fields only unless decided field by field; batch tag on every rowA sample load with known existing records that changes none of their protected fieldsWhoever runs the import
Connectors and reverse syncsAppend or replace matched to the field's rule; mappings versionedA seeded value that lands in the right target after each releaseThe integration register's owner
PeopleCorrections marked as manual and never overwrittenThe seeded correction aboveThe field's accountable team
MigrationsFreeze, final load, read-only old system, integrations repointedThe parallel check of agreed reportsThe migration owner

The seeded records are the cheap part. Keep a permanent test contact in both systems with a lifecycle stage set by hand in the CRM, a clean country value set by hand, a hand-corrected contact name and a recorded objection, and read its fields after every change to the sync, to any workflow that writes a shared field, to an import template or to a connector, and once a week regardless. The syncing guide asks for exactly this for consent: a seeded contact that has unsubscribed and objected in both systems, checked after every change to the sync, with its consent record carrying the source and date so the next person can see what was recorded and when. A seeded value that changes back is the earliest warning the business will get, days before a salesperson notices a stage or a customer notices a wrong address. The CRM sync change checklist puts these seeded reads, with one owner and one conflict rule for each field, in front of every change to the sync before it goes live.

Then watch the sync the way the syncing guide watches it: the error queue read on a schedule by a named person with errors grouped by cause and the cause fixed, the counts of synced and suppressed records on each side compared for a gap that grows, and a sample of records each review with the owned fields compared side by side. Values that differ on a field with one owner point at a stuck sync; values that keep changing point at two writers. Write every change to the sync contract, the ownership table, a shared workflow or an import rule in the change log, because a revert that began on a given day is explained by whatever changed that day, and the log is the only place that question has an answer.

Finally, keep the documents that make one owner per field possible. The field dictionary names every writer and reader; the integration register names every connection, its pattern and its identifier; the ownership table names the accountable team for each synced field; and the automation inventory names the owner of each workflow that writes one. The CRM section gathers the sync, import, field-audit and migration guides this page draws on, and the troubleshooting hub is the place to start when it is not yet clear whether the fault sits in a record, a workflow or the sync.

A dental supplies distributor finds the nightly writer (illustrative)

Illustrative example — not a real result

Vexlorrin Dental Supplies

Vexlorrin Dental Supplies, an invented distributor of consumables to dental practices, hears from its sales team that leads marked as sales-qualified are back at marketing-qualified each morning, and from a practice manager that her corrected delivery contact has reverted twice in a month. The operations lead opens the field history on 30 reverted leads. Every one shows the same pattern: the rep sets the stage during the day, and at 02:10 the following morning a user called "marketing sync" writes the old value back. The marketing platform recalculates stage nightly from score and writes it over the CRM, so both systems own the field and the last save wins; 140 leads reverted in the previous month.

The delivery contact is a different writer. Its history shows the correction on the 3rd and the old name restored on the 1st of the next month by a user called "data loader", the account a monthly supplier-list import runs under. The import is set to overwrite on match, and it has restored 212 contact names and 38 owners over the year.

The distributor makes the CRM the only writer of lifecycle stage and gives the marketing platform a request field that a CRM workflow reads and applies once; the nightly reverts stop the next day. It switches the import to fill-empty-only, restores the 212 names and 38 owners from the pre-import export, and adds the overwrite decision to the import's record. It keeps one seeded lead with a hand-set stage and one seeded contact with a hand-corrected name, checked after every change to the sync and on the morning after each monthly load. In the following quarter the seeded records never change, and the sync error queue, now read weekly by one named person, settles at a few items a week.

Common mistakes

  • Changing a setting before reading the history. The history names the writer and the time; the settings only say what each system is allowed to do.
  • Letting most-recent-edit-wins settle a conflict. Each system's next save is the most recent edit, and the value flips on every run.
  • Fixing the record instead of the writer. The correction is restored by hand and the next sync, run or load undoes it again.
  • Treating a consent revert as a sync bug alone. An older subscribed value over a newer objection is a data protection failure; route it to the opt-out diagnosis and tell whoever owns data protection.
  • Running every integration under one shared user. The history says "integration" and cannot say which.
  • Importing with the overwrite setting because it was already on. Stage, source and owner reset on every matched record, and deleting the import does not restore them.
  • Leaving the old CRM live after cutover. Every connection still pointing at it keeps sending the old values.
  • Trusting the fix without a seeded record. The next change to the sync reopens the fault and nobody notices until a salesperson does.

Frequently asked questions

Can I set the sync so the most recent edit always wins, so the latest change sticks?

That setting is usually the cause rather than the cure. Each system's next save counts as the most recent edit, so a value that both systems write flips back and forth with every run, and an older subscribed value can overwrite a newer objection on the next pass. The syncing guide's rule is to give every synced field one owning system and one direction, with the owner winning any conflict, and for consent fields to let the most restrictive value win whichever system recorded it and whenever. If a field genuinely needs input from both sides, give the second system a request field of its own that a workflow in the owning system reads and applies under its rules, so the history stays in one place.

A customer corrected their own details and the sync put the old value back. Is that only a reporting problem?

No. Accuracy is one of the GDPR's principles, and people have a right to have their data corrected, so a stale value written back over a correction means the business is holding inaccurate data that the person has already asked it to fix. The syncing guide treats corrections made by the person, or by a colleague on their behalf, as values no sync may overwrite, and the standardising tutorial applies the same rule to workflows. Fix the writer that restored the old value, re-apply the correction, and tell whoever owns data protection what happened and how many records it affected. This is educational, not legal advice.

The record history just says the change came from the integration. How do I find which system or rule wrote the old value back?

Start with the time. A value that reverts at the same hour every night points at a scheduled sync or a nightly workflow; one that reverts on the same day each month points at an import; one that has reverted since a cutover date points at a migration. Then make the writer visible: the fundamentals guide asks every integration to authenticate as its own named user with the minimum scope it needs, so the audit log names the system rather than a shared account, and a workflow that writes a field should leave a marker or a companion date so its values can be told apart from manual ones. If every connection shares one user, splitting them is the first fix, because until then the history cannot answer the question.

Terms used on this page

Frameworks

Where this page is used

Sources

  1. Regulation (EU) 2016/679 (GDPR) — EUR-Lex
  2. Direct marketing guidance — Information Commissioner's Office (UK)

Related