Backend-driven loan application forms

Welcome to all the new subscribers who are hearing from me for the first time.

And hello again to those who haven't heard from me.

It's been a long time since the last issue.

In case you don't remember me, I'm Vova, and I run a software engineering services firm that builds custom solutions for lending companies.

I've been busy figuring out how to grow our company and haven't prioritised publishing newsletters.

But now that I have more clarity, I'm picking it back up and will send a new issue every Thursday.

Let's dive into the first issue after the break.

We're working on a solution design for the loan eligibility assessment software.

As a part of the process, I came across a design decision related to handling loan form submissions early in the loan origination process.

There's nothing more mundane in software engineering than handling form submissions.

But in the context of loan applications, how you handle them unlocks or limits a number of valuable capabilities.

Let me explain.

Loan application form submission approaches

There are a couple of ways how you can handle loan application submission:

• Client-driven

• Backend-driven

In the client-driven approach, the loan application form lifecycle starts on the client side, and the form is only sent to the backend once the borrower completes the full form and submits it.

This is the most common and straightforward method.

In the backend-driven approach, the loan application form lifecycle starts at the backend before the borrower submits the form.

When a borrower starts an application, the client requests loan application services that issue a new form instance and send the form identifier to the client.

As a borrower progresses through the form, the client sends data to the loan application services to persist in the database.

When the borrower submits the form, the client notifies the services, marking it as submitted.

What backend-driven loan application form enables

We considered using a backend-driven approach to improve loan application analytics.

But once we thought more, it turned out that it would enable several other use cases.

So here's a list of the use cases where backend-driven loan applications would be helpful.

Loan application analytics

With client-driven loan applications, the earliest point in the loan origination process you can reliably track is once the borrower submits an application.

But it's rare when the borrower's journey is that straight.

A significant drop-off happens before the application is submitted.

With backend-driven loan applications, the earliest point you can track is when a new loan application is issued.

And this extends visibility earlier into the process and gives a more complete picture of the application process to identify areas for improvement.

Abandoned application recovery

Besides having data to measure the drop-off, the backend-driven approach also offers data to do something about it.

You know when someone starts an application process, and can detect when they have abandoned it.

You can identify borrowers early because the application inevitably has the borrower's contact details.

You can send automated communication to remind borrowers to complete their application.

Unfinished application completion

It’s rare when a borrower completes a loan application form in one go.

Often, they start the application and return later to complete it.

Instead of starting from a blank slate, you can give them the option to continue where they've left off.

Less friction, higher conversion rate.

Eligibility check fraud detection

Identifying anonymous borrowers early and linking all their loan applications to their identity gives you more data points to detect fraud.

A high number of applications or discrepancies in data between applications can indicate someone is trying to trick an automated loan eligibility check.

How to implement a backend-driven form

Implementation of this pattern is still straightforward compared to the capabilities it offers.

To implement a backend-driven approach, you'll need to:

• Add on more entities to persist an application (if you haven't already)

• Add a service that issues new forms and persists them in the database

• Change the client so it requests a new form issue and persists it in the progress

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.

Thank you!

Vova