Inside the credit underwriting black box

As an engineer, credit underwriting has always felt mysterious to me.

What makes it different is that, unlike other parts of the lending process, it's hard to reverse engineer how it works by observing the system from the outside.

With application intake, loan processing or loan servicing, you see the forms, the workflows, and the interfaces and can get an idea of how it all works together.

When it comes to credit underwriting, there's not even much to observe.

In lendtechs, underwriting is often a fully automated internal service. There's no UI or API that could give cues about what happens inside.

It's a black box that takes input from one service and provides output for another.

Yet, despite being behind the scenes, underwriting is one of the most integral parts of the lending process.

Last week, I was researching credit underwriting software design and would love to share my model of what happens inside the underwriting black box.

Credit underwriting involves multiple steps.

And the process can vary depending on the type of credit product.

For example, if you're underwriting a loan secured by collateral (like a car or property), the process may include additional steps such as collateral valuation.

That said, I isolated four core functions of the underwriting system that should be relevant to most credit products:

Score

The first thing underwriting software does is score the application.

This means analysing the credit file to quantify the risk.

Each data point in a credit file can serve as a risk signal. Some features, like a history of missed payments, might increase the risk. Others, like a long, stable credit history, might reduce it.

The result of scoring is, well, a score. An internal metric that expresses how risky the borrower is as a numeric value.

The score serves as an input into downstream steps and enables decision-making.

Limit

Once the risk is quantified, the credit underwriting system determines how much exposure the lender will take.

In other words, how much the lender is willing to put at stake, knowing the risks of not getting it back.

Acceptable risk when lending £10,000 is different from £100,000. The higher the risk, the lower the acceptable exposure.

This step sets the credit limit.

E.g. how much the lender is willing to lend and for how long.

Price

With risk and exposure determined, the underwriting system calculates the price of the loan.

The goal is to make the risk financially acceptable for lenders while being competitive.

Lenders express the price as an interest rate.

Higher risk generally means a higher interest rate.

The pricing model also accounts for capital costs, profit margins and regulatory constraints.

Decide

Finally, the underwriting engine combines the score, limit, and pricing to make a decision:

• Approve

• Decline

• Approve with conditions

This decision incorporates broader bussiness rules such as risk appetite, profitability targets or compliance policies.

Despite being simplistic, this 4-step model helps me wrap my head around underwriting when designing lending software.

Underwriting is deeply connected to everything else in the lending lifecycle.

Many upstream and downstream services either feed into the underwriting decision or depend on its output.

So, even if you're not working directly on underwriting logic, understanding how it works helps you build better lending software.

That's it for today.

I hope this gave you some useful ideas for building better lending software.

If you want more content like this in your LinkedIn feed, let's connect.