Most deduplication projects don’t fail because you haven’t turned the right rules on. Instead, they suffer because the rules are either too lax or too strict.
This is a common trap that Salesforce Admins fall into – thinking deduplication is a straightforward case of on or off. While Salesforce provides some helpful tools to detect and manage duplicates, simply having them doesn’t guarantee success.
In truth, the situation is a little more complex…
The Balancing Act of Salesforce Duplication
There’s an important principle that it’s helpful to define right from the outset. Effective Salesforce duplicate management is a balancing act. It’s a constant trade-off between making your rules too strict or not strict enough.
If you go too far in either direction, you risk creating false positives, missed matches, and other issues. This creates several key issues:
- Alert fatigue: Native Salesforce functionality lets you alert users to potential duplicates when data is being entered. But overusing these features can create alert fatigue, leading admins to find cumbersome workarounds.
- False positives: You can also configure rules to ‘block’ duplicate records from being entered into Salesforce. This can create edge cases where legitimate records are blocked because the prescriptive logic doesn’t consider context or business nuance.
- Missed matches: On the other end of the spectrum, leaving rules too loose risks missing genuine duplicates that should be resolved. This makes it difficult for Salesforce users to rely on the data in front of them.
- Integrations: Some API paths, bulk imports, and custom integrations bypass or only partially respect duplicate rules, causing external systems to inject duplicates at scale.
- Accounts: Detection can be particularly difficult for accounts, since variants, subsidiaries, and hierarchies resist straightforward logic. Instead, admins often choose between accepting duplicates or false positives.
In all of these cases, the solution isn’t about simply switching on the right rules or policies in Salesforce. It’s about configuring these policies in a way that balances the risk of user friction and data quality – so you can reduce the number of errors to a minimum.
What Does Effective Deduplication in Salesforce Actually Involve?
Depending on how we configure Salesforce’s deduplication rules, we can tackle many of the issues we just described. To do that, it’s helpful to discuss what functionality is available and how to use it effectively. It’s helpful to consider these to be a series of decisions you should make – rather than simply policies you can turn on or off:
Matching Rules
The most fundamental Salesforce deduplication feature: This determines which fields Salesforce will match and how. It supports exact match and fuzzy match.
Ultimately, the decision here is about sensitivity. If you set your thresholds too tight, you’ll miss real duplicates. Too loose, and you risk creating false positives that frustrate users and slow down data entry.
Either way, it’s helpful to tailor the policies to the specific piece of information you’re inputting. Fuzzy matches work better for names, where variants like ‘Mike’ vs ‘Michael’ are common and (to some extent) predictable. Exact matches can work better for details like phone numbers and email addresses.
Duplicate Rules
These are built on top of matching rules and work alongside them. They decide what action to take when a duplicate is identified. By default, there are three choices – you can block the record, warn the user, or simply log the issue.
Each has its pros and cons. The right answer for you will depend, to some extent, on the size of your dataset and the resources you have at hand to help manage duplicates.
It can be helpful to calibrate this based on how strict the matching rules are. If you’re using fuzzy match, you might want to give users a warning so they can exercise judgment. If you’re using an exact match, a hard block might be the safer default.
Bulk Imports
In theory, Salesforce applies rules across most entry paths. In practice, many bulk imports, APIs, managed packages, and integrations either don’t apply the rules consistently – or even bypass them entirely. This is one of the main reasons why duplicates creep in at scale, even when you’ve configured rules to identify and block them.
At the same time, you can also run into issues when the duplicate rules do work. For instance, you might have block as the default for records being entered manually. But if this applies to bulk imports, you could end up with a huge chunk of missing data – without necessarily knowing about it.
Again, this will ultimately depend on the size of the dataset you’re importing. If your CRM is comparatively small, you can get by with manual merging, either through alert or log. But a bulk import can quickly change the size and scale of your database – so it’s important to review the rules and consider how they might need to change over time.
Duplicate Jobs
All of the tools so far work at the point of data entry. But with duplicate jobs, you can also scan your existing dataset to identify duplicates at scale.
Rather than treating this as a one-time cleanup exercise, the smarter approach is to run jobs periodically. It can be helpful to use the results of this to spot where duplicates are still slipping through – then refine your rules over time.
However, a point to remember: Merging these duplicates remains a manual job. If you’re running a duplicate job on a large dataset, you may want to consider third-party tools like Plauti to help manage these automatically.
Compare and Merge
In Salesforce, there are no native tools to automatically merge records at scale. Whatever your policies include, you’ll need to resolve them manually or consider third-party tools.
However, compare and merge does at least make it somewhat easier to consolidate records. It lets users compare flagged duplicates side-by-side and decide which field values to keep.
The key decision you have to make here is ‘Who does this work – and when?’ There are essentially two options:
- Salesforce user: Here, the end user resolves the conflict when it’s first flagged. This spreads the manual workload evenly and ensures duplicates are resolved as they’re entered. However, it risks data consistency: Each user will resolve the conflict in a slightly different way – and some will be more diligent than others.
- Admin: This works well if you’re choosing to log issues. It creates a more consistent approach, since all duplicates will be resolved by one person who’s already responsible for quality control. However, it creates a huge amount of manual work for one person – and often means duplicates sit around for long periods waiting for the admin to resolve them.
Again, this is a careful balancing act – and the right answer will differ for every organization.
Take Deduplication to the Next Level With Plauti
The tools and policies we’ve discussed in this blog help to reduce friction and improve data quality in Salesforce. But there’s no silver bullet here. And crucially, even these techniques get progressively less effective as your CRM grows. However, you configure the rules, there’s really no way to avoid manual merging with native Salesforce tools.
If you need repeatable deduplication operations, more control, and faster remediation, you’ll have to go beyond these Salesforce features. That’s where Plauti Deduplicate comes in. In fact, our customers have saved 713 hours in two weeks on backlog cleanup, and reclaimed up to five hours a week (per admin) on ongoing deduplication work.
- Merge duplicates at scale: With Plauti, you can configure rules to automatically resolve conflicts and, where necessary, merge duplicate records. This puts you in charge of which record is authoritative and which field values are kept.
- Standards and custom: By default, Salesforce duplicate rules only work on standard objects. We extend this to custom objects – so you can apply rules evenly across your whole CRM.
- Extended cross-object deduplication: Native duplicate management only supports Lead-to-Contact matching and can’t run cross-object batch cleanup jobs. Plauti enables duplicate detection and cleanup across any standard or custom objects, both in real time and in bulk.
- AI-powered detection: Deterministic rules alone will always create edge cases. Instead, AI merge recommendations understand the context of the conflict so it can decide the right course of action – just as a human would. Then, AI auto-merge applies that logic to resolve conflicts in bulk.
- AI match recommendations: When duplicates are identified, AI analyzes the context and assigns a duplicate, unique, or uncertain score. This gives you the visibility to create safer auto-merge rules, and avoids relying on overly prescriptive logic.
Want to find out more? Head over to our website to see how Plauti can help your organization.
