This post was originally published in April 2023 and was updated in Jan 2025.
Cash application has come a long way in a short time. Thanks to automation, businesses are handling payments faster and more accurately than ever. With tools powered by AI and machine learning, you’re not just speeding things up, you’re making cash application smarter.
As impressive as automation is, it’s not always perfect. You will encounter occasional complexities, such as missing invoice numbers, new company names, partial payments, disputes, or deductions.
When an exception is identified, it’s up to humans to make the right match and help the system learn to handle similar cases better in the future.
The secret to making cash application work for you? A combination of automated matching, strategic exception handling, and human expertise. They all work together to keep your cash application process efficient and accurate.
Matching is automated, exceptions are human-driven
Let's start where the human experience of cash application begins: exception handling. Exceptions are inevitable. What matters most is how you handle them. When an exception pops up, it’s your chance to step in and make the right adjustments, which trains the automation to do better next time. Over time, this will reduce the occurrence of exceptions, driving continuous improvement.
For example, let’s say you’re trying to match invoices for a customer, but their payments come from their parent company under a slightly different name.
You’re billing a customer as Fairchild Tires, but their payments come from Fairchild Automotive, their parent company.
An automated system would flag the name mismatch and log it as an exception. However, a human would quickly recognize the connection and correct it.
Therefore, the next step is for a human to enter the exception-handling workflow and match the Fairchild Automotive payment to the Fairchild Tires invoice.
This is where confidence-based matching and rule-based matching that different paths.
With many rule-based cash application solutions, the next time this happens, the system will flag the same exception all over again. In our example, Fairchild Automotive paying a Fairchild Tires invoice, another exception gets generated. And this could go on forever.
The only way to resolve it in a rule-based system is by creating a new rule for this exact scenario. That’s the problem with a static, rule-based approach: it doesn’t learn. It’s stuck following pre-set rules, and is more expensive to implement, because every change requires developer time.
A confidence-based engine works differently. While it still uses rules, those rules are weighted. In this system, the closer a payee name matches an invoice name, the higher the likelihood of a correct match.
These confidence scores are combined across multiple categories and averaged into a Match Score, which considers all relevant variables. If the Match Score exceeds a set threshold, the payment, remittance, and open balance are automatically settled and sent back to your ERP without any human intervention needed.
You can also adjust the threshold to fit your business. For instance, if your current confidence score threshold for a match is 90%, but you notice many exceptions with tentative matches scored at 88%, you can easily lower the threshold to capture those and reduce exceptions. Plus, the engine always provides potential matches for exceptions, giving you the flexibility to fine-tune as needed.
Let’s go back to our example. In a rule-based engine you might have a rule that says the payee name on the payment must exactly match the name on the invoice. Even a small variation, like the difference “Fairchild Tire” versus “Fairchild Tires” would trigger an exception.
Here's an illustration:
A confidence-based matching engine looks beyond exact matches. It evaluates confidence scores across multiple categories, like the Name Likeness Score above. With all other factors being equal, a confidence-based matching engine is more likely to match an invoice and payment, even if there’s a minor discrepancy in the payee names.
By combining these confidence scores into a single Match Score, the engine decides if a match meets the set threshold. If it does, the match happens automatically.
Here’s how a confidence-based matching engine learns from your exception handling behavior:
One of the factors that contributes to the Match Score is past history. If you have manually matched a Fairchild Tire invoice to a Fairchild Automotive payment in the past, the engine remembers. The more times you make that same match, the higher the Match Score for future payments. Eventually, the score will exceed the threshold, and the system will handle that match automatically. That specific exception will never occur again.
Compare this to a rule-based engine, which will flag the same exception over and over again unless you hire a developer to create a new rule. Imagine having to do that for every exception as your customer lists grows or businesses change.
A confidence-based engine gets smarter over time by learning from data gathered through exception handling.
The power of control
Confidence-based matching engines put you in the driver’s seat. Beyond learning from your actions, they let you adjust the weighting of different categories that contribute to the Match Score. You can also raise or lower the threshold for matches based on patterns you observe in flagged exceptions.
For example, if your current match threshold is set at 90% but you notice a lot of correct tentative matches scored at 88%, you can lower the threshold to capture those and reduce exceptions.
Confidence-based matching thrives in messy, imperfect data environments. That’s why it’s perfect for cash application.
Rule-based matching works best with large, accurate, and consistent datasets. But for cash application, where data is often messy and inconsistent, it falls short. It’s also more expensive to maintain since every change requires developer time.
Head-to-head comparison of rule-based and confidence-based matching engines
| Rule-based matching | Confidence-based matching | |
|---|---|---|
| Making changes to matching rules | Optimization can be slow and expensive because every change requires a developer. Can lead to a situation where AR teams accept a sub-optimal configuration. | Self-service capabilities allow changes to be made in minutes, not days. Most critically, rules can be easily added after implementation. |
| Optimizing match rates | Requires the intervention of a developer, either a contractor hired by the AR team, or someone from the solution provider. | Self-service and machine learning power constant evolution in the matching engine, ensuring that it is always moving towards its most optimal state. |
| New customer setup | Requires new rules to be written and developers to do so. |
New customers can be onboarded with simple self-service changes and machine learning optimization. |
| Complex relationships | Complex parent / child relationships amid customers can require custom rules be written for each relationship. |
Even if names and customer numbers differ, other elements that the matching engine looks for can still lead to correct matches without custom programming. And exception handling activities automatically improve that engine's recognition of parent / child relationships. |
| Ease of exception handling | Exceptions may be organized by rules they have violated, but they will not show suggested matches. |
Every unmatched invoice and payment is still assigned a Match Score. If it’s in the exception que, then the Match Score isn’t above the confidence threshold for an automatic match. But it will still suggest the best match, which can make exception handling easier. |
Confidence-based matching unlocks machine learning
These engines can automatically improve their matching accuracy over time, something rule-based systems simply can’t do.
The real game-changer with confidence-based matching engines is their ability to leverage machine learning. These engines can automatically improve their matching accuracy over time, something rule-based systems fundamentally cannot do.
Learn more
We’ve covered the key differences between confidence-based versus rule-based cash application and why confidence-based matching is the smarter choice for messy, real-world data.
Now it’s time to see it in action. Billtrust’s Cash Application, powered by confidence-based matching and machine learning, is designed to adapt to your unique processes and deliver measurable time and monetary savings.
Connect with our team today to schedule a quick call with one of our cash application experts.
FAQ
Confidence-based matching uses weighted rules and machine learning to evaluate and match payments to invoices based on a confidence score. This approach adapts over time, learning from past matches to improve accuracy and reduce exceptions.
Rule-based matching relies on static, predefined rules that do not adapt to new data, often requiring developer intervention for changes. Confidence-based matching, on the other hand, uses weighted rules and machine learning to continuously improve and handle exceptions more efficiently.
Confidence-based matching enhances accuracy, reduces manual intervention, and improves efficiency by learning from past exceptions. It provides flexibility in adjusting match thresholds and handles complex data environments better than rule-based systems.
Machine learning in confidence-based matching engines continuously analyzes data and past matches to refine its algorithms. This leads to more accurate matches over time, reducing the need for manual corrections and improving overall cash application efficiency.
Exception handling allows human intervention to correct mismatches and train the system for future accuracy. Effective exception handling reduces the frequency of errors, enhances the learning process of the matching engine, and ensures smoother cash application operations.