Answers

What is a record merge?

Dedupe tells you two rows describe the same thing. Delete throws one away. A record merge is the careful middle: pick a winner, reconcile every field, carry the children across, and keep the paper trail intact.

Short answer

A record merge is the CRM action of combining two or more duplicate records into one authoritative record. The merge picks a surviving row, chooses field-level winners (keep the most recent email, the longest title, the earliest created date), reassigns every child record (activities, opportunities, notes, tasks, emails) from the losers onto the survivor, and writes a lineage entry so the audit trail still points back to the merged-away IDs. Merging is different from deletion, which destroys data, and different from deduplication, which only identifies the duplicates.

Key points

What matters most.

The six ideas every RevOps team should understand before letting anyone click Merge in the CRM: what survives, what moves, what breaks, and what the audit log has to prove.

Definition

Two rows become one authoritative row.

A record merge takes two or more rows the CRM has decided describe the same real-world entity, picks one as the survivor, reconciles the field values across all of them, and moves every related child record onto the survivor. The loser IDs are retired but not forgotten, because the lineage log keeps pointing to them.

Field-level winners

Pick the best value per field.

A merge is not pick-one-row-and-copy. It is a field-by-field decision. Keep the most recent email, the longest title, the earliest created date, the highest lifetime value, the populated phone over the blank one. Good merge UX surfaces every differing field side by side and lets a human override the default rule when it matters.

Child reassignment

Activities, deals, notes travel.

Every related record (open and closed opportunities, tasks, calls, emails, notes, files, campaign memberships, custom child objects) must reparent from the losing records to the surviving record before the losers retire. Lose a child record in the merge and you have quietly destroyed sales history, not cleaned the base.

Lineage audit

The old IDs still resolve.

Merging retires the losing IDs, but external systems (marketing automation, data warehouse, support, finance) still reference them. The lineage log maps every retired ID to the surviving ID so links keep resolving, and records every field decision with user, timestamp, and old-value-vs-new-value. Without lineage, a merge is a silent data loss.

Merge is not delete

Nothing worth keeping is thrown away.

Deletion destroys a record and (depending on the system) its children. A merge is the opposite: the data from the losing rows is reconciled into the survivor, the children follow, and the audit trail persists. Teams that reach for Delete when they meant Merge erase sales history, break pipeline reports, and lose compliance evidence.

Merge is not dedupe

Dedupe finds, merge resolves.

Deduplication is detection: the matching engine says these two accounts, or these three contacts, are the same real-world entity. Merging is the action that resolves the duplicate set into a single authoritative record. A dedupe program without a merge workflow produces nothing but a long list of problems; a merge workflow without dedupe never runs.

How a merge actually runs

The six steps between duplicate and golden record.

A healthy merge is a sequence, not a button. The system identifies the duplicate set, proposes a survivor, surfaces field conflicts for review, reparents the children, retires the losers behind a lineage map, and writes the audit log. Each step has rules, each step has failure modes, and skipping any one of them is how teams end up with a merge that looks clean in the UI and silently breaks reporting for the next quarter.

Step 1 - Identify

The duplicate set.

A merge starts from a confirmed duplicate set: two or more records the dedupe engine (or a human review) has decided describe the same entity. The set carries a match confidence score, the matched fields (email, domain, phone, external ID), and the trigger (ad hoc, batch sweep, import conflict). No merge runs without a set.

Step 2 - Pick survivor

Oldest, most engaged, or user choice.

The CRM proposes a surviving record based on tenant rules: earliest created, most activities, highest lifetime value, or has-an-owner. Common defaults choose the oldest record to preserve historical context, but the user who runs the merge can override. The survivor is the row whose ID lives on and whose primary audit history continues.

Step 3 - Resolve fields

Side by side, winner per row.

The merge UI lays every differing field side by side across all records in the set. Default rules fill in: most-recent email, longest title, earliest created date, populated over blank. A human reviews, overrides anywhere the default rule missed context, and confirms the merged field set. This is the single step most non-RevOps merges skip and most RevOps merges guard carefully.

Step 4 - Reparent children

Every related record follows.

Open opportunities, closed opportunities, tasks, calls, emails, notes, files, campaign memberships, custom child objects, inbound form submissions, support tickets, invoice lines: all of them repoint from the losing records onto the survivor. Reparenting runs in a transaction so a mid-flight failure leaves the base consistent, not half-merged with orphaned children.

Step 5 - Retire losers

IDs preserved, rows soft-deleted.

The losing records retire. In most CRMs this is a soft delete: the row is marked merged, the ID still exists in the database, lookups by that ID resolve to the surviving record through the lineage map. External systems that cached the old ID keep working. The row never returns to the active list view, and search excludes it unless an admin asks.

Step 6 - Write lineage

Audit log, redirect, and callback.

The merge writes an audit log entry that records every field decision, the retired IDs, the surviving ID, the user, and the timestamp. A redirect entry maps each retired ID to the survivor for API lookups. Any downstream integration that subscribed to the record-merged event fires its callback so the data warehouse, marketing automation, and support tool can repoint too.

Field-level winner rules

The defaults that make merges predictable.

A good merge program publishes its field-winner rules so nobody has to argue them in the moment. The rules are opinionated, they are overridable per merge, and they are the same across contacts, accounts, deals, and leads so a sales rep learns one mental model. Every rule has an escape hatch for the field where the default is wrong, and every merge records the chosen value against the alternatives so the next audit can tell what happened.

Most recent

For fields that drift.

Email, phone, title, mobile, company name, website. These fields change as the person or company evolves. The most-recent-value rule favors the row with the newest updated-at timestamp on that specific field, not the newest row overall. A rep correction last week beats a batch enrichment from six months ago, even if the enriched row is otherwise fresher.

Longest value

For truncated text.

Title, company name, address, description. Shorter values usually mean a form that only accepted thirty characters, or an import that dropped the full string. The longest-value rule picks the fullest version the base has seen. A good UI shows the difference inline so the human reviewer can downgrade to the shorter value when the longer one is wrong.

Earliest created

For audit anchors.

Created date, first-contacted date, first-converted date, source. These fields anchor the record in history and must survive the merge intact. The earliest-value rule picks the oldest date across the duplicate set so pipeline attribution and cohort reporting stay honest. Overwriting the created date to today is one of the most expensive merge mistakes a team can make.

Populated over blank

Fill the gap.

Across the duplicate set, if one record has a value for a field and the others are blank, the populated value wins by default. The rule is harmless when only one row has data, but combined with other rules (most-recent, longest) it is how a merge produces a complete record from several partial ones. The human review catches the rare case where the blank was correct.

Sum or max

For numeric aggregates.

Lifetime value, total revenue, deal count, activity count, points balance. These fields usually sum across the duplicate set because the two rows represented the same entity and the activity should roll up. For gauges like health score or scoring tier, max wins. The rule depends on the field; the merge system should know which fields sum and which take max.

Keep both

For multi-value fields.

Tags, lists, campaign memberships, industries, product interest. Multi-value fields do not pick a winner; they union across the duplicate set. If one row is tagged webinar-attendee and the other is tagged demo-requested, the merged record carries both. The dedupe engine should never force a choice between tags that both earned their place on the record.

What the audit trail must prove

Lineage, redirects, and reversibility.

Merging is the one data operation that most needs a receipt and that most teams forget to design for. The audit trail is how a RevOps lead debugs a scoring drift, how a sales manager explains why last quarter's pipeline moved, how a compliance officer answers a right-to-know request, and how an admin reverses a bad merge before it causes a quarter of pain. A merge without an audit trail is a silent data loss event that just happens to produce a cleaner-looking list view.

Field decisions

Old value, new value, winner.

Every field that differed across the duplicate set records its decision: the value on each losing row, the value on the surviving row, the rule that picked the winner, and whether a human overrode the default. The log is how a scoring surprise six weeks later can be traced back to the merge that moved the industry field from Software to Consulting.

Retired IDs

The losers still resolve.

The losing record IDs are preserved and mapped to the surviving ID. API lookups by a retired ID return the survivor with a header or payload field flagging the redirect, so downstream systems can repoint their caches. Without the redirect map, every integration that cached a loser ID silently fails until a human notices.

Child reassignment log

Every child, every move.

The audit records every child record that moved from a loser to the survivor: object type, child ID, original parent, new parent, timestamp. If a sales manager asks whether a specific opportunity history survived the merge, the log answers in one query. Reparenting without a log is the fastest way for a team to lose faith in merge as a workflow.

Who and when

User, timestamp, source.

The audit records who ran the merge (the acting user or the automation that triggered it), when it ran, from which workflow (manual review, batch job, import conflict resolver), and the match confidence of the duplicate set. The provenance answers the inevitable who-did-this question and separates deliberate human merges from policy-driven automation.

Reversibility

Unmerge within a window.

A good merge system supports unmerge for a bounded window (usually thirty to ninety days). Unmerge restores the losing records to active status, moves the children back to their original parents based on the reassignment log, and reverts the field values on the survivor to the pre-merge state. Beyond the window, the merge is permanent and the lineage is still queryable.

Downstream callbacks

Marketing, warehouse, support follow.

The merge fires a record-merged event that integrated systems subscribe to: the marketing automation unsubscribes the loser emails and consolidates engagement history onto the survivor, the data warehouse rewrites the fact tables to the surviving ID, the support tool reassigns open tickets. Without the event, each downstream system drifts out of sync and the merge delivers less than half its value.

Merge with a trail, not a shrug.

Strkr runs field-level merge on contacts, accounts, deals, and leads with every child record reparented in a transaction, every retired ID preserved in a lineage map, and an audit entry that records the user, the field decisions, and the match confidence. Unmerge is a single click inside the review window. The feature pages show exactly what ships today.

People also ask

Related questions.

What is the difference between a record merge and a delete?

A delete removes a record and (depending on the system) its child records from the active base. The data is gone or hidden, and any related history goes with it. A record merge preserves the data: the losing record retires, its field values reconcile into the survivor, every child record reparents onto the survivor, and the lineage log keeps the retired IDs resolvable. Teams reach for Delete when they meant Merge and silently destroy sales history every time.

What is the difference between a record merge and a deduplication?

Deduplication is detection: the matching engine scores pairs or clusters of records to decide which ones describe the same real-world entity. The output is a list of duplicate sets with a confidence score. A record merge is the action that resolves one of those sets into a single authoritative record. Dedupe without a merge workflow produces nothing but a backlog; a merge workflow without dedupe never has anything to run on.

How does a CRM pick which record survives a merge?

The default rule varies by system. Common defaults pick the oldest record (to preserve the earliest created date and audit history), the record with the most activity, the record with an assigned owner over one without, or the record with the highest lifetime value. The user running the merge can override the default, and the surviving ID is logged with the override reason so the audit trail can tell the difference between policy and manual choice.

What happens to related records (activities, opportunities, notes) during a merge?

Every related child record reparents from the losing records onto the surviving record before the merge completes. Open and closed opportunities, tasks, calls, emails, notes, files, campaign memberships, custom child objects, and support tickets all repoint to the survivor in a single transaction. A merge that leaves child records on the retired IDs has corrupted the base, not cleaned it, and should fail and roll back rather than commit.

What is field-level merge?

Field-level merge means the CRM reconciles each field independently across the duplicate set rather than copying one row wholesale. The merge might pick the email from one record, the title from another, the industry from a third. Default rules (most recent, longest value, earliest created, populated over blank) propose a winner per field, and the user can override. This is the only merge model that produces a complete record from partial duplicates.

Can a record merge be undone?

Yes, within a bounded window on most modern CRMs. Unmerge restores the losing records to active status, moves the reassigned child records back to their original parents using the reassignment log, and reverts the survivor's field values to the pre-merge state. The window is usually thirty to ninety days. After the window closes the merge is permanent, but the lineage log remains queryable so retired IDs still resolve.

What is a merge audit trail?

The merge audit trail is the log the system writes alongside every merge. It records the duplicate set, the surviving ID, every field decision with old-value and new-value and the rule that picked the winner, every child record that reparented, the user and timestamp, and the match confidence of the set. The audit trail is how RevOps debugs scoring drift, how compliance answers a right-to-know, and how admins reverse a bad merge inside the unmerge window.

Should a sales rep be allowed to merge records?

It depends on the record type and the governance model. Most teams let reps merge contacts under accounts they own, with field-level review required, because the rep has the context to pick the right title or phone. Most teams restrict account and deal merges to a RevOps or admin role, because the downstream impact on pipeline reporting and territory assignment is harder to see. The permission model should be explicit and the audit trail should name the merging user either way.

Try it free. Bring your team next week.

No sales call, no migration consultant, no four-month implementation. Enter your card, get 14 days of the full Pro tier, cancel any time before day 14 with zero charge. Spin up a workspace, import your CSV, and have something useful before lunch.