Project history split across two accounts
Last year's onboarding sits under one account record and this year's renewal project under its twin. Neither view shows the whole customer, and the account team plans from half the story.
TaskRay has no deduplication of its own. Its projects and tasks point at Salesforce accounts, opportunities and contacts, so when those records are duplicated, project history splits in two, onboarding automation can build the same project twice, and capacity and pipeline reports count one customer as several. Twopir Consulting designs the matching logic, agrees which record survives, merges in a safe sequence and switches on prevention. One customer, one record, with every TaskRay project still attached.
Trusted by 500+ organizations — including software, services and professional firms that run delivery and customer records in Salesforce with Twopir Consulting.
What We Deduplicate With
TaskRay projects carry Account and Opportunity lookups by default, and admins often add Contact or Case lookups on top. Every one of those links inherits whatever duplicates already sit in Salesforce. These are the six symptoms delivery and operations teams notice first.
Last year's onboarding sits under one account record and this year's renewal project under its twin. Neither view shows the whole customer, and the account team plans from half the story.
Where a custom lookup ties projects or tasks to contacts, a duplicated contact means emails, approvals and external collaboration go to a stale record while the real person waits.
When a Closed Won opportunity starts the project build, a duplicate opportunity for the same deal builds a second project from the same template, with its own owners, tasks and due dates.
If a flow's start criteria can be met more than once for one opportunity, a stage moved back and forth, a second flow or a manual stitch on top of the automated one creates a twin project nobody asked for.
TaskRay reports run on native Salesforce reports and dashboards. Twin projects double the estimated hours in capacity views, and duplicate accounts split customer counts, time logged and onboarding metrics.
Salesforce documents that duplicate rules do not run for Quick Create, manual merges or undeleted records, and that edits only trigger a rule when an edited field is in its matching rule. Duplicates arrive through the gaps.
TaskRay Salesforce deduplication is the work of finding and merging the duplicate Salesforce records that TaskRay projects and tasks depend on, resolving duplicate TaskRay projects, and preventing both from coming back. It covers matching logic for each object, rules for which record and which values survive, a merge sequence that keeps TaskRay links pointing at the right customer, sandbox testing, and prevention at every point where records enter the org.
It helps to be precise about who does what. TaskRay is a project management app built natively on Salesforce: its projects, task groups and tasks are ordinary Salesforce data, and it has no duplicate matching or merging of its own. Salesforce supplies matching rules, duplicate rules, duplicate jobs and record merge. A dedicated app such as Duplicate Check or Validity DemandTools adds bulk and custom-object deduplication when the native tools run out. Twopir Consulting designs and runs the deduplication across all three, with TaskRay's data model in mind. How TaskRay links to other objects is documented in TaskRay's guide to integrating with other objects.
We help growing and mid-market companies solve complex CRM, integration, and business system challenges, and the same method scales to enterprise orgs with larger backlogs. Deduplication is one part of TaskRay data quality: our TaskRay data quality audit finds and documents the problems, our TaskRay data cleansing service fixes inaccurate and incomplete values, and our TaskRay data quality consulting sets the standards and governance. This page covers duplicates only. New to TaskRay itself? Start with our TaskRay project management solutions.
Exact matching finds what is identical and misses "Acme Inc." against "ACME Incorporated". Fuzzy matching catches both and also catches two genuinely different companies. We choose per object and per field, then prove the choice against your own data before any merge runs.
| Object | Match keys we start from | Exact or fuzzy, and what to watch |
|---|---|---|
| Account | Normalised company name with website domain, then billing address or phone as a tie-breaker. | Fuzzy on name, exact on domain. Watch subsidiaries, franchise locations and account hierarchies that look like duplicates and are not. |
| Contact | Email address first, then first and last name within the same account. | Exact on email, fuzzy on names. Watch shared inboxes, personal versus work addresses, and contacts linked to Experience Cloud users. |
| Opportunity | Account, close date window, amount and products, plus record type. | Exact on account after it is deduplicated. Salesforce's standard merge covers accounts, contacts and leads, so an opportunity twin is resolved by decision, not a merge button. |
| TaskRay project | The related opportunity and account, the source template and the created date. | Exact. Duplicate jobs can find duplicates on custom objects but cannot merge them, so twin projects are consolidated by a reviewed plan. |
| Lead (where used) | Email and company, matched against existing contacts as well as other leads. | Cross-object rules stop a returning customer becoming a new lead, and later a second account at conversion. |
Native matching rules have limits worth designing around: exact and fuzzy methods cannot be mixed in one matching rule, fuzzy matching supports Latin characters only, and an object can carry up to five active duplicate rules with up to three matching rules each. Where your data outgrows those limits, that is the point to consider a dedicated app, covered below.
A merge is a decision about the master record and about every field that differs. We write those decisions down with sales, customer success and delivery leads before any merge runs, because they cannot be made one record at a time across thousands of pairs.
| Rule | What we decide | Why it matters for TaskRay |
|---|---|---|
| Master record | Which record wins a pair: the one with active TaskRay projects, the most recent activity, the key-account owner, or the integration's system of record. | The surviving account becomes the anchor for every project and task. Picking the one delivery already works from avoids surprising project teams. |
| Field values | For each field that differs: keep the master's value, the most recently updated value, or the non-blank value. | Fields used in project formulas, trickled-down values and report filters must end up with the value delivery relies on. |
| Ownership and teams | Who owns the merged record, and how account teams combine. | Ownership and sharing decide who can see linked projects, especially in a private sharing model. |
| System fields | Accept that Salesforce keeps Created By and Created Date from the oldest record and retains hidden fields from the master. | Reports that age customers by created date change after a merge. We flag them before, not after. |
| History and files | What must be preserved: Salesforce keeps Chatter feeds from the master only, while files are retained on the merged record. | Project conversations held in the losing record's feed are exported or noted before the merge. |
| Audit trail | A mapping of every losing record ID to its survivor, kept outside Salesforce. | Losing records go to the Recycle Bin. The ID map lets integrations, imports and support re-point anything still holding an old ID. |
Salesforce documents that items related to merged duplicates are related to the surviving record, with some exceptions, and that losing records move to the Recycle Bin. That is the rule; these are the TaskRay places where we check it held.
TaskRay projects and tasks carry an Account lookup by default. After a merge we confirm both levels point at the survivor, including tasks whose account value was trickled down from the project.
Links to contacts, cases or custom objects are admin-built lookups on projects or tasks. We list every one in your org and include it in the test plan, because each shows up in related lists, reports and formulas.
Projects built from Closed Won opportunities stay related to the opportunity that started them. When two opportunities are reconciled, we decide which project survives and make sure the flow cannot rebuild the other.
TaskRay's packaged reports and your own copies are native Salesforce reports. Filters on account names or record IDs, and dashboards built on them, are checked before and after so the numbers move for the right reason.
Salesforce applies sharing rules and the master's manual sharing to a merged account. In a private sharing model, TaskRay project teams also control access, so we confirm the right people still see the right projects.
Some TaskRay collaboration options run on Experience Cloud. Salesforce sets extra merge rules for accounts with site users, such as choosing the account with site users as master, so we plan those pairs separately.
Removing a twin project removes its estimated hours from capacity and utilisation views. We tell resource managers which projects are going before the numbers change.
Billing, support or marketing systems that stored a losing record's ID need re-pointing. The ID map from survivorship drives that update, so nothing writes back to a record in the Recycle Bin.
Salesforce's own duplicate management is the right first layer, and many orgs never need more. A dedicated app earns its licence when the backlog, the objects involved or the audit requirement go past what native tools document. We recommend from the data, not from a reseller margin.
| Need | Salesforce native | Dedicated app (Duplicate Check, DemandTools) |
|---|---|---|
| Stop new duplicates at entry | Matching rules plus duplicate rules that warn or block, with different behaviour by profile. | Real-time prevention, including records created through imports and web forms. |
| Clear an existing backlog | Duplicate jobs list duplicate record sets, in Performance and Unlimited editions only; merges run up to three records at a time. | Bulk find and merge with master and field rules, suited to thousands of pairs. |
| Custom objects, including TaskRay projects | Duplicate jobs can find custom-object duplicates but cannot merge them. | Find and merge on custom objects, and cross-object matching such as leads against contacts. |
| Fuzzy matching beyond the basics | Exact or fuzzy per matching rule, not both; fuzzy for Latin characters only. | Wider options, such as cleaned company names, phonetic and domain matching. |
| Proof and undo | Losing records in the Recycle Bin; your own ID map and exports. | Run history and restore files, including undo merge in DemandTools. |
We implement both apps: see our Duplicate Check implementation services, our Validity DemandTools services and our guide to Salesforce data quality with Validity DemandTools. When native rules are enough, we will say so and configure them instead.
Order matters because records hang off each other. Accounts are merged before contacts so contacts land on the surviving account, opportunities follow, and TaskRay projects come last, once everything they point at is settled. The length of the project depends on the backlog and the number of objects, which we size in step one.
We count duplicates by object and by source, and flag every pair that has TaskRay projects, tasks or time logged against it. Those pairs get the most care.
DeliverableDuplicate baseline with TaskRay exposure
Match keys per object, master-record and field rules, the tool decision, and the exceptions list, agreed with the people who own the data.
DeliverableSigned-off matching and survivorship rules
The full merge runs in a sandbox with representative data, and every TaskRay check in the test plan is run against the result.
DeliverablePassed test plan and tuned rules
Production merges in batches, accounts first, then contacts, each batch checked against the ID map before the next one starts.
DeliverableMerged accounts and contacts, ID map
Opportunity twins reconciled by decision, then duplicate TaskRay projects consolidated: one project carries the work, the other is archived or removed.
DeliverableOne opportunity and one project per deal
Duplicate rules, import routes and project automation are tightened before we call the work finished, and your admins get the runbook.
DeliverablePrevention live, admin runbook
Losing records go to the Recycle Bin, but the relationships, reports and automations around them do not rewind on their own. So every merge pattern is proved in a sandbox first, against a test plan written for TaskRay.
| Test scenario | What it has to prove |
|---|---|
| Account pair with projects on both sides | Every project and task from both records now points at the survivor, and the account shows the complete project history. |
| Contact on a custom project lookup | The lookup, related list and any formula using it all resolve to the surviving contact. |
| Twin opportunity on a stitching flow | One project remains, and updating or re-closing the surviving opportunity does not build another. |
| Sharing and project teams | Users who could see a project before the merge still can, and nobody gains access they should not have. |
| Reports and dashboards | Customer counts, capacity and onboarding metrics change by exactly the duplicates removed. |
| Duplicate rules after the cleanup | A deliberately duplicated test record is warned or blocked through each entry route you use. |
A cleanup without prevention is a cleanup you buy again. These six controls close the routes duplicates use to reach the records TaskRay depends on.
Warn or block when a user creates or edits a likely duplicate, with different behaviour for different profiles where that suits the team.
A rule only runs on an edit when an edited field is in its matching rule, and only works when the user can see the fields it uses.
Records added through data import tools or the API do not show duplicate alerts, so imports are matched against existing records before they load.
Project-creation flows check whether the opportunity already has a project before they stitch, so a re-fired trigger cannot build a twin.
Marketing, billing and support systems that write to Salesforce match on an agreed key instead of creating a new account each time.
A duplicate report or scheduled job tells you when the rate creeps back up, long before project history splits again.
Ownership, stewardship and data standards across the whole org are the job of our TaskRay data quality consulting service. Here we build the controls; there we run the programme that keeps them working.
Duplicates in a TaskRay org rarely come from one cause. These are the patterns we look for in discovery, and how each one is found, resolved and kept from returning.
A rep creates the account, then onboarding creates another from a kickoff form, and projects follow the second one.
A closed opportunity is reopened and closed again, and the project flow builds a second onboarding project.
Projects moved in from a tool outside Salesforce brought customer records with them that already existed.
Event lists and web forms add the same people again, and project emails go to the wrong record.
A billing or support system creates a new account whenever it cannot find a match, every sync cycle.
Resource managers see people over capacity on paper because twin projects double the planned hours.
TaskRay support helps with the product, and points customers to a Salesforce consultant for hands-on build work. Deduplication is exactly that kind of work: it touches data, automation, sharing and reports at once.
Projects, tasks, trickled-down lookups, custom links and stitching flows are in the test plan from day one, not discovered after a merge.
Duplicate rules, merges and automation have to coexist with the flows, validation rules, integrations and sharing model already in your org. We review those interactions before anything runs.
We configure native duplicate management and implement dedicated apps. The recommendation follows your backlog, edition and objects, including the recommendation to buy nothing.
Every merge pattern runs in a sandbox against a written test plan, and production merges run in batches with an ID map, so you always know what happened to each record.
The engagement ends with rules, import routes and automation your admins can maintain. When you want us to stay, ongoing Salesforce support is a standing offer.
No. TaskRay is a project management app built natively on Salesforce, and its projects, task groups and tasks are stored as ordinary Salesforce data. It does not include duplicate matching or merging. Duplicates are handled with Salesforce's matching rules, duplicate rules, duplicate jobs and record merge, or with a dedicated app such as Duplicate Check or Validity DemandTools.
Salesforce documents that items related to duplicate records are related to the merged record, with some exceptions, and that the losing accounts move to the Recycle Bin. TaskRay projects and tasks link to accounts through lookup fields, so we rehearse each merge pattern in a sandbox and confirm that project and task lookups, trickled-down values, project teams and reports all point at the surviving account before anything runs in production.
Not with Salesforce's standard merge, which covers accounts, contacts and leads. TaskRay projects are custom-object records, and Salesforce duplicate jobs can find custom-object duplicates but cannot merge them. We decide with your delivery leads which project carries the work, consolidate anything that exists only on the twin, archive or remove the twin, and fix the automation that created it.
Start with native matching and duplicate rules to stop new duplicates on accounts, contacts and leads. A dedicated app earns its licence when you have a backlog of thousands of records, need to merge more than three records at a time, need to deduplicate custom objects, or need run history and undo. Duplicate jobs are only available in Performance and Unlimited editions, which also shapes the choice.
Accounts first, so contacts land on the surviving account, then contacts, then opportunities, and TaskRay projects last, once everything they point at is settled. Each step runs in batches against an ID map of losing and surviving records, and prevention is switched on before the work is called finished.
With survivorship rules agreed before any merge runs: which record is the master, and for each differing field whether to keep the master's value, the most recent value or the non-blank value. In a TaskRay org the record that already carries active projects is usually the strongest master candidate. Salesforce keeps Created By and Created Date from the oldest record regardless, so reports that age customers are checked too.
By closing every entry route: duplicate rules that warn or block at entry, matching rules that include the fields users actually edit, imports matched against existing records before they load, integrations that match on agreed keys, project-creation flows that check for an existing project before they stitch, and a duplicate report someone reviews. Ongoing data standards and stewardship are the job of our TaskRay data quality consulting service.
A first conversation covers where duplicates come from in your org, which objects TaskRay links to, your Salesforce edition and the tools you already own: enough to say whether native rules will do, what the merge sequence looks like, and what it would take. No obligation to proceed.
Talk to a Salesforce architect who works with TaskRay data