🥇 Underwriting automation drives better customer experiences, lower costs, increased accuracy and improved compliance.
Across every credit vertical, lenders are looking to automate complex underwriting decisions. The benefits are obvious, however transitioning from manual to automated processes can be a daunting task.
DigiFi has helped a variety of lenders automate their credit underwriting and we’ve found that these 5 steps are a great process to follow:
- Document the Manual Underwriting Process
- Create a Detailed Framework for Automated Underwriting
- Convert General Guidelines to Specific Rules
- Implement and Test
- Integrate into Systems and Workflows
This post explores each step to provide a basic framework for achieving world-class automated underwriting. If you would like to discuss your specific situation and how DigiFi might be able to help, please don’t hesitate to reach out.
Step 1 – Document the Manual Underwriting Process
In an ideal world, your entire underwriting process would be documented in a specific credit policy (and if so, you can skip this step!). In practice, there’s often not a single “source of truth” for the entire underwriting process, so the first step to automation is the process of documenting the following:
- What are the basic product parameters (loan term, loan amount, fees, collateral requirements, etc.)
- What are the data sources used in the underwriting process? (information provided by the applicant, information from internal databases such as existing customer data, information provided by third parties such as credit bureaus)
- How do we determine loan eligibility (basic credit requirements)?
- What is our formula or logic for setting pricing?
- What determines the maximum loan amounts (and other caps)?
- Are there manual overrides to eligibility, pricing or exposure logic? If so, why?
The questions are simple but the process of answering them can be difficult – it typically requires reading credit policies, speaking with internal stakeholders and working directly with loan officers to understand how decisions are being made. In some cases, there’s conflicting information to resolve and even the tightest credit policies can contain inconsistencies that need to be clarified.
The good news is that this was the hardest part – once you know the information above, you’re in a great spot to automate.
Step 2 – Create a Detailed Framework for Automated Underwriting
Once you’ve documented the underwriting process, you can begin outlining the high-level workflow. Since you already documented the process, this can be simple and typically serves as a tool to facilitate internal discussion and set the groundwork for what you’ll end up implementing.
The goal is to create a simple process flowchart that contains the major components of your underwriting process in the order they must occur. For example, an underwriting process might involve pulling a credit file, checking credit requirements, scoring the applicant, setting pricing and terms, calculating payment amounts and setting maximum exposures, which could be outlined like this:
It’s important to note the areas where an applicant can be rejected. For example, in the above process they could either fail Basic Eligibility Requirements or Maximum Exposure Limits, whereas all other sections are gathering data, setting outputs or performing calculations.
Step 3 – Convert General Guidelines to Specific Rules
Credit policies typically contain tons of information but sometimes skip over exact specifics. This is often fine for manual underwriting, since the loan officers have been trained how to use the logic, but automated underwriting requires more specific and comprehensive rules. Here’s an example of a general guideline that requires additional clarity:
“The APR is 8% for loans up to $3,000 and subject to increases above that.”
In practice, loan officers likely know what to do above $3,000. However, this is not logic that can be automated without additional detail and you therefore need to determine exactly what happens above $3,000 and convert this to specific rules.
For example, assume that above the APR for loans above $3,000 is based on the customer’s credit score. You would create specific rules such as the following
- IF Loan Amount <= $3,000 THEN APR = 8%
- IF Loan Amount > $3,000 AND Credit Score >= 700 THEN APR = 12%
- IF Loan Amount > $3,000 AND Credit Score < 700 THEN APR = 16%
The above rules are easy to implement, whereas the general logic was not. This is a critical step that can take time but, in addition to enabling automation, it often uncovers areas where the credit policy would benefit from additional specificity.
Step 4 – Implement and Test
If you completed steps 1 to 3, you’re ready to begin automating! There are two common approaches for implementing the logic:
- Code the logic into a custom system (requires the assistance of a development team)
- Implement in a rules management platform (can be done by business users through a visual interface)
There are a variety of pitfalls and challenges that come with hardcoding credit rules (as discussed in our recent post The Evolution of Decision Automation) so this section focuses on using a rules management platform.
Rules management systems are built to make implementation as simple as possible, but they obviously require rules! Since you already created those, it’s just a matter of getting them into the platform. Every rules management platform is a bit different, however rules are typically implemented in an “If this, then that” type manner. Here’s an example of how you’d implement one of the rules above:
It typically takes a few hours to implement all of the rules, with more complex underwriting processes taking a bit longer. (For example, we recently implemented a policy with 2,800+ discrete rules. Which took one person a few days). As you implement the logic, your decision process will start to match your credit policy very closely.
Here’s an example of a simple set of rules implemented in DigiFi’s system. In this case pricing is set for a loan based on the applicant’s custom risk score (which was determined by a scorecard in an earlier step):
Best-in-class rules management platforms also make it easy to test your implemented logic. A common way to do this is batch processing, where you process hundreds or thousands of decisions at once to confirm the results or identify any issues.
Step 5 – Integrate into Systems and Workflows
Once you’ve implemented and tested the logic, the final step is to integrate the underwriting process with other systems and workflows. The most common technical integration is between an existing Loan Origination System (“LOS”) and the Rules Engine where you’ve implemented the logic. In these cases:
- The LOS sends an automated Decision Request with the information needed to start the process
- The Rules Engine processes the decision and sends back an automated Decision Response
- The Decision Response is received by the LOS
The results are typically saved into a database and incorporated into digital or in-person workflows, which can differ by use case and loan product (note: Steps 1 to 4 can typically be handled without IT support, however Step 5 typically requires engineering assistance).
And then you’re done!
While the transition from manual to automated decision can be daunting, the opportunity greatly outweighs the costs. Decision automation drives better customer experiences and increased decision accuracy, while also lowering costs and reducing compliance risks. The approach outlined above is a good starting point for companies making the transition which, with the right tools and organizational buy-in, can often be completed in just weeks to months.
DigiFi is a technology company that helps businesses make better automated decisions.
Our platform lets businesses easily use automated machine learning and rules management to optimize critical decisions with no coding or technical expertise required. Repetitive work that used to take hours can now be completed in minutes, letting your team focus on what matters most.
Learn more at digifi.io