Dirty data will cost your business a fortune. A study by Forrester found that organizations waste 21 cents of every media dollar due to poor data quality.
Duplicate records are often the culprit. And while there are automated solutions for duplicate lead management, you’ll need tools to help with auditing and processing those records that fall between the cracks.
This problem has some interesting challenges. A compelling solution should be able to:
- Identify possible duplicate records.
- Review those records to exclude the ones that are legitimately duplicates and update the “winner” record with the best field values from among all the duplicates identified.
- Identify the related records that look up to the duplicate records, and reparent them to the “winner” record.
- Remove all the duplicate leads and update the winner!
That process should also be as efficient as possible. In other words, if an audit task requires the user to go into each record on a separate web page, find specific fields to update, save and return, it simply won’t get done.
There’s a better way, and in this blog post, I’ll provide a high-level overview of how you can solve this challenge with Skuid.
We’ve made this solution available for you in our Github repo, along with a more comprehensive explanation of how it works. So, after you’ve read this article, head over there and check it out.
How you can dedupe leads using Skuid
Step 1: First you need to identify probable duplicate records. This page we built using Skuid lets you group leads by name or by email to find situations where there are matched records in your database.
Step 2: After selecting an entry to manage, the detailed records are returned for analysis and update.
- The oldest lead is returned as the “recommended winner.”
- Clicking on data values in the “leads to be merged” will update the winner lead with those values, allowing you to easily improve the data quality of the final lead.
- If one of those identified duplicates is really a different person, remove them from the merge activity with the row action.
- A summary indication of the number of related records is shown. At merge time, these will be reparented to the winner.
Step 3: After you analyze this lead, push “Merge” to finish. This button:
- Moves the related records to the winning lead.
- Deletes the remaining leads to be merged.
- Saves the winning lead.
- Takes you back to the audit list so you can quickly start on the next item in the list.
What’s under the hood
Let’s take a look at three key elements in Skuid that make features like these possible.
1. Data connection: Skuid allows you to query for data in lots of different ways and at different times in order to keep your page snappy. Here’s how:
- Aggregate models. Grouping leads by name or email is called “aggregation,” and rather than retrieving all your lead records and doing this in the browser, Skuid models can instruct the server to do this aggregation in the database, making the data retrieved much more straightforward.
- Dynamic updates. You need to be able to dynamically control the filters used to retrieve specific data. With Skuid, this is easy. A simple set of action instructions and a single button will update a filter on five or six different queries and send off the request. Better yet, we can tell these queries not to be triggered on page load. This helps your page load really fast, while the interactive queries take place behind the scenes when the user pushes the button. This is what happens with the “manage duplicates” button in step 1.
- Multiple queries on the same object. In step 2, we’re doing two different queries on the lead object. The first retrieves the oldest lead we have on file, calling this the winner. The second retrieves all the rest. This sort of multiple lists on the same object is not normally possible without coding in the Salesforce platform.
2. UI sophistication: Skuid is an extremely flexible toolkit for organizing sophisticated processes. In this case, there are two related “review and act” interactions that need to be arranged on the same page. Structuring a page that makes these interactions seamless is a challenge.
- A pleasing interaction shouldn’t force the user to push a button at the top of the page as a way of finishing a review process that takes them down toward the bottom of the page. Skuid components can be placed very flexibly on the page, so you can place buttons wherever you want. As shown in step 2, you can put the “Merge” button at the bottom of the page, in visual alignment with the end of the review process.
- Organizing data to appear when and where it should requires flexibility. With Skuid components, you get options for wizards, tabs, panels, or popups, helping users have efficient interactions.
3. Dynamic actions: The page designer often knows the specific actions needed to accomplish some task; for instance, set this filter, update this value, or save this record. With Skuid, those actions don’t have to be individually accomplished; you can script them together and bind them creatively to UI elements on the page. Here are some examples:
- The update data process in step 2 connects each cell of a table to a set of actions that pass the value in that cell to the associated field on the “winner” lead. No copy/paste is needed.
- The merge button is our heaviest sequence. It's a set of nine or 10 different actions that inform the user of what’s going on, update data in related records, delete records, and save other records. This all happens behind the scenes, without the user needing to act. Then, just because we can, we return the user to the audit list (step 1) because we know that’s where they should go. We also re-query that list to remove the records we just merged, providing the immediate satisfaction of a shorter list. Little things matter.
Hopefully, this example gives you some vision of how Skuid can solve complex business challenges. There’s more we could add to this process, and more ways we could style and improve the design, but those challenges will come another day, or in another blog post.
Finally, it’s important to remind you that no code was harmed (used) in the making of this example. All these functions were built declaratively.