Build an SME Loan Underwriting App with ToolJet MCP and Jev

Introduction

Credit teams at banks need a loan underwriting app that keeps pending cases, financial ratios, and supporting documents in one place. With ToolJet MCP, you can build an SME loan underwriting app with a clean queue, financial ratios, and document-backed review. In this walkthrough, we will use TypeSafe’s Jev to return risk bands, an affordability score, a refer-to-credit-committee signal, a fraud signal, and a main concern for each application while the underwriter decides. The agent generated result is a structured ToolJet application, with data, queries, and interface together, that the team keeps running. That gives you one place to compare the model’s view with the final decision instead of tracking the case across separate screens.

The Pipeline page lists loan applications waiting for a decision, with Jev's risk band on each row.

The Underwrite page shows the financial ratios, Jev's assessment, supporting documents and the decision form.

The Portfolio review page compares Jev's risk band with the underwriter's final band and shows approvals by sector.

How The Pipeline Page And Jev Work

The Pipeline page is the working queue, where you filter pending cases by sector, band, amount, and waiting time, then open a row into the underwriting screen. The underwrite page opens from the row action and keeps the decision flow on the same record. The flow keeps the underwriter on the case without jumping between records. The review page pairs ratios, Jev's assessment, and linked documents with a decision form, so the underwriter checks evidence, sets a final band, and records a reason before saving. The supporting PDFs stay in reach on the same screen, so the reviewer moves from ratios to documents without leaving the case. The Portfolio review page compares Jev's band with the final band and shows approvals by sector. Jev returns risk_band, affordability, refer_to_credit_committee, fraud_signal, and main_concern, with confidence on the choices, affordability as a score, and the refer and fraud outputs as percentages.

• Queue pending applications with filters for sector, AI band, amount, and waiting time
• Review financial ratios, Jev's assessment, and linked S3 documents on one screen
• Record a final decision with a required reason, then route threshold cases to the Credit Committee
• Compare Jev's band with the underwriter's band and track approvals by sector
• Keep mutable decisions and cached assessments separate in ToolJet DB

Set Up ToolJet MCP and the TypeSafe Datasource

ToolJet MCP connects your coding agent to your ToolJet workspace, so the agent can create the tables, queries and components for you. Set it up with the ToolJet MCP overview and the ToolJet MCP repository. Then add the TypeSafe datasource to the workspace and name it typesafe, which is the name the build prompt refers to.

• At build time: ToolJet MCP lets the agent create the app in your workspace.
• At run time: the app calls Jev, TypeSafe's decision model, through the typesafe datasource and shows its typed answers next to the record.

Why The Prompt Was Consolidated

The real build took several passes, and the requirements are consolidated here into one prompt you could have used from the start. That gives you a single spec to reproduce the underwriting app in one run.

Build a polished internal app called SME Loan Underwriting in ToolJet. Use only ToolJet native components, with HTML blocks only for composed read-only summaries.

Keep it to three pages. Pipeline shows applications waiting for a decision with amount, term, DSCR, Jev's band and refer score, days waiting, filters, and an underwrite action. When Pipeline loads, backfill an assessment for any pending application that does not yet have one. Underwrite shows the selected application, financial ratios, Jev's assessment, supporting PDFs from S3, and a decision form. Underwrite stays off the menu and opens from the row action. Portfolio review compares Jev's band with the underwriter's final band and shows approvals by sector.

Use a dense, clean layout with the custom Oat & Olive Credit theme, restrained colour use, compact rows, and clear hierarchy.

Use la_applications, la_financials, la_directors, lu_decisions, and lu_ai_assessments. Keep lu_ai_assessments as the cached AI result table, unique per application, and derive the working assessment from Jev through the TypeSafe datasource with the evaluate operation. Ask for risk band, affordability, refer to credit committee, fraud signal, and main concern. Show each choice with confidence and probability bars, the score, and the 0 to 1 values as percentages.

Jev recommends and the underwriter decides. Require a reason before saving. Route any application above one hundred and fifty thousand pounds or with refer above sixty percent to the Credit Committee save path, otherwise to the underwriter save path. After saving, mark the application decided and return to the pipeline. Add groups for underwriters, the Credit Committee, relationship managers, and risk, and keep relationship managers on their own applicants through a server-side filter.

How MCP Builds The Full App

ToolJet MCP works through the whole application structure, so the data model, pages, components, queries, and wiring land as one structured ToolJet application. That matters because data connectivity, workflows, permissions, deployment, and ongoing change sit with the runtime where supported, instead of leaving you with a codebase to operate yourself and a generated app to keep editing in the same workspace. The path stays open, so AI generation can be followed by visual editing and code where a case needs it.

The Sector Chart Labels We Fixed

The approved-by-sector chart clipped the pound labels on the right edge, so the values looked cut off. The chart container was holding the labels too tightly, and widening the available space fixed the display for the bar chart.

The Tables Behind The Loan App

The app ended up with five tables. la_applications stores application records, la_financials holds the ratios and figures behind each case, la_directors keeps the linked directors, lu_decisions stores final decisions, and lu_ai_assessments caches Jev's assessment for each application.

Page	Components	What they cover
Pipeline	9	Four KPI tiles, four filters and the table of pending applications with Jev's risk band.
Underwrite	14	Case header, financial ratios, Jev's assessment, S3 documents and the decision form.
Portfolio review	11	Four KPI tiles, three charts and the decision log.

What Got Generated

Metric	Result
Pages	3
ToolJet DB + PostgreSQL tables	5
Queries	22
Components	34
Code files to maintain	0
Repair cycles	1

The components ToolJet MCP created, in the ToolJet inspector

Industries That Run This

Banks, challenger banks and non-bank lenders that underwrite small and medium business loans, including credit teams, credit committees and risk teams in commercial lending and asset finance.

Who Can Use The Loan App

Four groups were created: Lending - Underwriters, Lending - Credit Committee, Lending - Relationship Managers and Lending - Risk. Underwriters, the Credit Committee and admins can save decisions, only the Credit Committee and admins can run the committee save, and Underwriters, Credit Committee, Risk and admins can open Portfolio review. Relationship Managers see only their own applicants. The groups have no members yet and the rules were not tested by signing in as a group member.

Development, Staging and Production Environments in ToolJet

An SME Loan Underwriting app should never be tested against live data, and ToolJet separates each app into Development, Staging and Production environments with their own data source settings and constants. Builders change the app safely while end users keep working on the released version.

Because the credit team tests underwriting changes against staging data before production, separate environments help keep the banking workflow steady. Server-side secrets stay scoped per environment, so credentials do not need to move through the app.

Development, Staging and Production Environments in ToolJet

Multi-Environment App Lifecycle and Version History

• Multi-environment setup: build in Development, promote to Staging where apps and queries cannot be edited, then promote to Production and release.
• Per-environment data sources: point each environment at a different database or API, and ToolJet uses the right one automatically for the target environment.
• Environment access: admins choose which environments each group or role can open, combined with the app's Edit or View permission.
• Version history: drafts hold work in progress, and saved versions are fixed checkpoints you can promote, release or roll back to.

Workspace Constants and Secret Management

• Workspace constants: store reusable values such as API URLs once per workspace, with a different value per environment. All constants and secrets are encrypted before they are stored.
• Secret constants: keep API keys and database credentials masked in the interface and resolved on the server, so they never reach the browser.
• Referencing constants and secrets in apps: builders use them by name in queries and data sources, while only admins can create, edit or delete them.

This keeps the SME Loan Underwriting app's test data, credentials and releases cleanly separated as the team grows. Multi-environment support is available from the Team plan on the ToolJet pricing page.

Enterprise Features for Your Loan Underwriting App

A loan underwriting app handles applicant financials, director details, and decision reasons. ToolJet covers that governance at the platform layer, so you configure it once instead of rebuilding it in every app.

• SSO and SCIM: sign in with SAML, OIDC or LDAP, and provision users automatically
• Role-based access control: scope permissions to the app, the data source, and each query
• Audit logs: track every login, edit, and approval decision for compliance review
• Air-gapped deployment: self-host on Docker or Kubernetes so your data stays in your network
• Multiplayer editing: several builders work on the same app, with versioning and Git sync
• ToolJet AI inside your own deployment: run the AI features in your tenancy rather than a shared service

You could add a notification layer with ToolJet Workflows. For example, a workflow could fire when a decision is saved, post a Slack message to the manager, send a Gmail message to the applicant owner, and write back to lu_decisions.

Final Takeaways

This SME loan underwriting app shows how a credit team can move from queue review to final decision inside ToolJet without splitting the data, the checks, and the screens. You get a pending pipeline, an underwriting view with ratios and documents, and a portfolio review that compares Jev with the underwriter's band. The build matters because the team keeps one editable app for applications, assessments, and decisions instead of copying the same case across separate places. The prompt in this article captures the working flow clearly enough to reproduce the structure and keep it adaptable as underwriting policy changes. That is the practical value of the result.

Try ToolJet MCP

Build your SME loan underwriting flow with ToolJet MCP, then request a ToolJet demo for your own credit data.

FAQs

What is ToolJet MCP?

ToolJet MCP is the build path that turns a prompt into a structured ToolJet application. In this app, that means the queue, review screen, portfolio view, data connections, and decision rules land together instead of as a codebase you assemble yourself.

Is Jev connected live and does it decide on its own?

No. Jev, TypeSafe's decision model, scores each application and suggests a result, while the underwriter makes the final decision. The review screen still holds the ratios, documents, and reason field for the human decision.

What does Jev return for each application?

Jev returns a risk band, an affordability score, a refer-to-credit-committee value, a fraud signal, and a main concern for each application. The app also shows confidence on the choice outputs and percentages on the signal outputs.

How do I reproduce the app from the prompt and existing data sources?

Use the prompt in this article as the build spec, then map the app to PostgreSQL for applications and financials, ToolJet DB for decisions and cached assessments, and S3 for the supporting PDFs. That keeps the data sources separate while the app still reads like one underwriting flow.

Can I edit the app after generation?

Yes. The app stays editable in ToolJet, so you can adjust the structure, filters, and layout after generation without starting over. Code only becomes relevant when a specific case needs it, not for the normal review flow.

Can several people work on the same app?

Yes. The same underwriting app can serve underwriters, the Credit Committee, Risk, and Relationship Managers at the same time through groups and page access. That keeps each role on the screens it should use, and the permission model stays inside the app.

What happens to the app after the agent finishes?

It stays a ToolJet application on the runtime, so data connections, workflows, access control, auditing, and lifecycle management stay with the app where supported. That gives you a build you keep editing instead of a codebase to operate separately, and deployment stays on the platform layer where supported.