Build Expense Reimbursement App With ToolJet MCP

Introduction

Build expense reimbursement app with ToolJet MCP when employees need to submit claims, attach receipts, group them into weekly reports, and track payment status through approval and finance. An agent can generate the build, and the result is a structured ToolJet application, data, queries and interface together, that the team keeps running rather than a screen or a code drop. In this article, you get the app shape, the model behind it, and the prompt that reproduces it.

ExpenseSheet

What We're Building

The first page keeps employee work in one view: KPI tiles at the top, a spend chart, a status breakdown, a needs-attention panel, and a tab switch that leaves only one table visible at a time. The expense modal changes its fields with the selected type, so mileage, accommodation, training, and client entertainment each expose the data that matters for that item. The second page shifts to submitted reports, line-level review in a modal, the approval history, the reimbursement queue, and the policy reference table. Dense layout, short labels, and status cues make the page read like an operations console instead of a brochure.

• Generates a structured ToolJet application from the prompt, with tables, pages, queries and wiring created together
• Keeps the app editable in the builder after generation, with visual edits for layout and code for edge cases
• Runs the expense workflow on a live runtime so data, approvals and payment state stay connected where supported
• Fits internal operations work that needs review steps, history and later changes without rebuilding the app
• Can run on infrastructure you control where supported, which suits internal finance systems

Build Expense Reimbursement App With ToolJet MCP From One Prompt

Want to build it yourself? Start with the ToolJet MCP repository for setup instructions, supported agents, and everything you need to follow along.

The Consolidated Build Prompt

The build took several passes to settle the page split, the data model, and the interaction rules. The requirements here are consolidated into one prompt so you can reproduce the app in a single run.

Build a polished internal app for expense and reimbursement management in ToolJet.

Keep it to 2 pages. The employee page shows a title and short purpose line, a 2x2 KPI tile area, a spend chart, a status breakdown chart, a needs-attention panel, and a tabbed area so only one table is visible at a time. The second page is for approvals and finance, with an approval inbox, a review modal that shows line-level decisions and history, a reimbursement queue, and a policy reference table.

Use 7 tables: employees, policies, expenses, weekly_reports, report_expenses, approvals, and reimbursements. Model approvals and payments as linked records, not loose status fields, so report state and payment state stay consistent.

Make the form rules do the work. Every expense must point to a policy, over-limit items become policy exceptions with a reason, receipt-required policies disable submit until a bill is attached, and only expenses not already attached to a report can be added. Managers can approve a whole report or send back individual lines, employees can reopen sent-back reports, and reimbursement status must flow through raised, processing, paid, and failed while writing every decision to history.

Use a dense, light-mode enterprise style with restrained colour, compact spacing, and clear hierarchy.

How ToolJet MCP Builds the App

ToolJet MCP works through the full application structure, so the data model, pages, components, queries and the wiring between them land as one structured ToolJet application. That matters because expense work does not stop at the interface, it keeps moving through data connectivity, workflows, permissions, deployment and later change, and the generated app sits on a runtime that carries those where supported instead of handing you a codebase to operate yourself. From there, you can keep shaping the app visually and drop into code only where a case needs it.

Data Created

The app ended up with seven tables in three groups: exp_employees and exp_policies hold the people and reimbursement rules, exp_expenses, exp_weekly_reports and exp_report_expenses hold the claim flow, and exp_approvals plus exp_reimbursements record decisions and payment progress. The approval table is the audit trail, and the reimbursement table pushes the payment state back onto the claim view.

Page	Components	What they cover
Expense Workspace	33	Four KPI tiles, spend and status charts, a needs-attention panel, segmented expense and report tables, and three modals for submission, detail, and report creation
Approvals & Finance	26	An approval inbox with five filters, a KPI strip, a reimbursement queue, a policy reference table, and three modals for review, reimbursement, and policy detail

Build Results

The agent produced two pages, seven ToolJet DB tables, 23 queries, and 59 components. The tables below show what landed in the app.

Metric	Value
Pages	2
ToolJet DB tables	7
Queries	23
Components	59
Prompt iterations	6
Code files to maintain	0

Enterprise Features for Your Expense Management App

An expense app handles payroll data, receipts, and approval chains. 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 finance data stays in your network.
• Multiplayer editing: Several builders work on the same app, with versioning and Git sync.

ToolJet Workflows adds the notification layer. One workflow fires when a weekly report is submitted, posts to the manager in Slack, emails the employee through Gmail, and writes the decision back to exp_approvals.

Final Takeaways

This build shows that a single specification can produce a working expense workflow where employees submit claims, managers review line items, and finance tracks reimbursement status on the same record. The value is that you keep a real ToolJet application, not generated code, so the next change lands in the app rather than in a file tree you now own. Visual edits handle the common changes, code covers the edge cases, and the runtime keeps the data and workflow pieces tied together as the process changes.

Try ToolJet MCP

Build an expense reimbursement app with ToolJet MCP using your claims and policy data, then request a ToolJet demo.

FAQs

How do I build expense reimbursement app with ToolJet MCP?

Use the prompt in this article to generate the two-page app, then tune the tables, statuses and form rules to match your own policies. The page split keeps employee work separate from approvals and finance without turning the build into a screen-only demo.

What does ToolJet MCP produce after the prompt runs?

It produces a structured ToolJet application, not a loose bundle of files. For this build, the employee workspace, approvals page, queries and table wiring all land inside the same app.

What happens to the app after the agent finishes?

The result stays inside the ToolJet runtime, so you keep editing the same app instead of taking ownership of generated code. Data, queries and workflow changes stay connected, and you can move between visual editing and code when a case needs it.

Does this app support weekly reports and partial approvals?

Yes. The employee groups expenses into weekly reports, managers can approve a whole report or send back individual lines, and the reimbursement state follows the same claim through review and payment.

Can I use the same structure with my own expense data?

Yes. The model is built around employees, policies, expenses, reports, approvals and reimbursements, so you can map the same shape onto your own source of truth. The key is keeping the claim, report and payment records linked.

Do I need to write code to finish the build?

No. You can generate the structure first, use the visual editor for most changes, and only drop into code when a field or rule needs custom logic. That keeps the app readable when policy rules or approval steps change.