An expense approval workflow: who checks what, and what happens to a rejected claim
SynaptaGrid8 min read
In short
An expense approval workflow is the path a claim takes from the moment an employee submits it to the moment it is paid or turned down: a manager checks that the spend was work related, finance checks the receipts and the amount, and the claim ends with a recorded result. Most expense problems come from unclear ownership. Nobody knows who has the claim, a rejected claim is never marked as rejected, or a paid claim cannot be found afterwards. A good workflow gives each check one owner, lets either checker reject, and writes the status onto a record so the claim can be looked up later. We built a small version in our own test workspace in which an AI tool, written for this job and used as an action in a normal step, reads the claim description, picks a category and flags anything a policy would question, and the workflow writes that onto the claim record before the manager reviews it. We ran it three times, once approved and once rejected at each checker, and checked the claim records afterwards. This page describes what we saw and what we did not test.
What an expense approval workflow is
An expense claim is a request to be paid back for money an employee spent on work. An approval workflow writes down who checks the claim, in what order, and what happens after each check. Without one, claims travel by email and the status of any one claim is whatever the last person remembers.
The workflow does not decide whether a claim is fair. People do that. The workflow makes sure the right person looks at it, that a decision is recorded, and that the claim ends in a state anyone can find.
The version we built
The steps to include, and who owns each
- Record the claim
- When a claim arrives, a record is created with the employee, the amount and a status of submitted. Everything after reads from and writes to that record, so there is one place to look.
- Review the claim description
- This is where an AI tool helps. It reads the description the employee wrote, picks a spending category and flags anything the text suggests a policy would question, such as alcohol or a receipt that covers only part of the spend. The next step writes the category and a short note onto the claim record, so the manager sees them with the claim. The tool does not approve or reject anything.
- Manager review
- The employee’s manager reads the AI note on the record and checks that the spend was for work and within policy. The manager knows the context, such as the trip or the project, that finance cannot see.
- Finance check
- Finance checks that the receipts match the amount and that the spending category is allowed. This is a different question from the manager’s, so it is a different step with a different owner.
- Reject from either step
- A claim can be turned down by the manager or by finance. Both rejections lead to the same place: the record is marked rejected and the run ends with a written result.
- Mark the result on the record
- An approved claim is marked approved for payment, and a rejected one is marked rejected. The workflow does this itself, so the status never depends on someone remembering to update a spreadsheet.
- Hand off to payment
- Paying the claim is a separate system in most companies. Decide where the approved claim goes next and who is told, and add that as its own step.
Where approvals and checks belong
Put a decision where a mistake costs money or trust. For expenses that is twice: before anyone commits company money, and before it is paid out. The manager’s review catches spend that is not work related. Finance’s check catches a missing receipt or an amount that does not match. Neither can do the other’s job well, which is why the two checks are separate steps.
Name each approver by role, such as the employee’s manager or the finance team, rather than by person. People change roles, and a process that names an individual stops working the day they move. If a claim is large, you may want a third approver above a set amount; we did not build that, and it is a good example of something to add on your own policy.
The old way and the new way
The table compares expense claims handled by email and a spreadsheet with the same claims run as a workflow.
- First read of a claim
- The old way: The manager reads it cold
- The new way: An AI tool picks the category and flags issues first
- Who has the claim now
- The old way: Whoever received the last email
- The new way: The step the run is on, with a named owner
- Where the status lives
- The old way: A spreadsheet someone updates
- The new way: A record the workflow creates and updates
- A rejected claim
- The old way: An email, often not recorded
- The new way: Marked rejected on the record and ended with a written result
- Who can reject
- The old way: Whoever notices a problem
- The new way: The manager or finance, at their own step
- Finding a claim later
- The old way: Search inboxes
- The new way: Open the record and read its status
- Judgement
- The old way: Still the manager’s and finance’s
- The new way: Still theirs: whether the spend was fair
How we decided
We built the version in the diagram in our own test workspace in SynaptaGrid Automation, with a small record type in SynaptaGrid Data for the claim, and ran it three times in November. The AI part is a custom tool we wrote for the job: a prompt that says how to review a claim, an input that takes the claim text, and an output with a category from a fixed list, a flag and a two-sentence note. In the workflow it is an action in an ordinary step, set up like any action that calls another system, and the next step writes the category and note onto the record. In the first run the manager and then finance both approved. The workflow created the claim record with the status Submitted, and after finance approved it updated the same record to Approved for payment with the paid flag set. The run finished with all five steps completed and the result recorded. In the second run the manager rejected the claim: the run went straight to marking the record rejected and ended with a rejected result, skipping finance. In the third run the manager approved and finance rejected, which ended in the same rejected state.
We checked the records in Data afterwards. The approved claim showed Approved for payment with the paid flag set, and both rejected claims showed Rejected and not paid. All three carried the AI review: the claim text was a client dinner for five including two bottles of wine and a receipt for the restaurant bill only, and the tool filed it under meals and flagged it for the alcohol and the partial receipt. In the first run the manager and finance approved it anyway, which is the point of the design: the tool raised the question and people made the decision.
We chose two separate checkers, rejection at either step and a record that carries the status because those are the places expense handling usually fails. The choice of steps is ours and a judgement; it is not a standard. Our first run of a similar workflow taught us something specific: when a later automatic step reads the new record’s identifier, it must read it from the place the earlier step actually returned it, or the run stops and says an input is missing. The AI tool did not work first time: our earlier attempts to call it failed until we named the model in full in the tool’s settings, and our first version did not use its output in a later step. The version described here is the one that ran three times.
Six limits, so this guide does not claim more than the runs showed. The tool saw one claim description, so we did not test its categories or flags on other claims, and the amount was part of the text rather than a separate number it could check against a limit. One test account held every human step, so the runs show the sequence and the branching, not hand-offs between different people. We did not connect the workflow to an accounting or payment system, so nothing was paid: the only automatic actions wrote to a record in our own test data, and the paid flag on that record is a stand-in, not a payment. We did not build an approval above a set amount, a limit per category or a check for duplicate claims. We did not test reminders when a claim waits too long, or notifications to the employee. And the template carries one test account as every approver and the actions tied to our test record type and our test AI tool, so to reuse it you would change each step to a role and point the actions and the tool at your own, which we did not do.
Standards and accepted practice behind this
These are the practices the guide rests on. We align with them. This page does not claim a certification.
- Segregation of duties
- The person who submits a claim does not approve it, and the person who approves the spend is not the person who checks the receipts. Two checkers is the simplest form of this.
- Source: NIST glossary: separation of duty (opens in a new tab)
- Documented approval
- Auditors expect to see who approved a payment and when. A step that records the decision, and a record that carries the status, are that evidence.
- Human oversight of AI
- Where AI helps with a decision, accepted practice is to keep a person accountable for it and to let them see the AI’s input and output. Here the tool drafts a category and a note and the manager and finance decide.
- Source: EU AI Act (Regulation 2024/1689), Article 14: human oversight (opens in a new tab)
- Retention of records
- Expense records are usually kept for a period set by tax and accounting rules in your country. Check yours before you decide how long the records stay.
- BPMN
- The standard notation for drawing a process. The diagram above is a plain flowchart, and a BPMN diagram of the same steps would show the same decisions.
- Source: OMG: BPMN 2.0 specification (opens in a new tab)
Where SynaptaGrid fits
SynaptaGrid Automation lets you write the steps as a workflow, assign each decision to a person, use an AI tool you wrote as an action in a step, pass its result to the next step, create and update records in SynaptaGrid Data as part of the run, and see where every claim stands. You can start from the version above, change the steps to match your own policy, and keep the result as a template.
Check the limits above before you rely on it: whether each step is assigned to a role rather than a person, whether claims need to reach your accounting or payment system, whether you need a larger-amount approval, and who should be told when a claim waits.
Frequently asked questions
- What steps should an expense approval workflow have?
- Record the claim, a manager review, a finance check of receipts and amount, a way to reject from either step, a status written on the record, and a result recorded at the end.
- Who should approve an expense claim?
- Usually the employee’s manager first and then finance, each decided by role rather than by name.
- What should happen when a claim is rejected?
- The claim record should be marked rejected and the workflow should end with a recorded result, so a rejected claim can be found and is not mistaken for one still waiting.
- Can AI check an expense claim?
- It can draft the first review: a category and a note on anything a policy would question. In our test run it filed a client dinner under meals and flagged the alcohol and the partial receipt. A person still reads it and decides.
- Can a workflow update the expense record for me?
- Yes. In our test run the workflow created the claim record when the claim arrived and updated its status after each decision. You need a record type for the claim and each action pointed at it.
SynaptaGrid
Build your expense approval steps
Start with the steps above in a test workspace and run one claim through each outcome before you use it for real.