Most finance teams don't have an SLA problem. They have a fragmented SLA problem. Reimbursements have their own turnaround target. Approvals have a separate escalation rule somebody set up two years ago. Reconciliation runs on "whenever month-end gets close." Vendor credits live in a side spreadsheet with no clock on them at all.
Each process got its own definitions, its own owners, its own idea of what "late" means. And because none of them share a common language, nobody can answer the simplest cross-process question: where is this expense stuck, who owns it right now, and how long until it becomes a problem?
The fix isn't adding more SLAs. It's building one SLA taxonomy that every expense process inherits from — a single vocabulary for timers, states, triggers, escalation, and ownership. When you do that, a late approval and a stale reconciliation item become the same kind of problem, measured the same way, escalated the same way. That's the whole point of an expense SLA framework for an SMB: one model, applied everywhere, instead of twelve micro-policies nobody remembers.
Why per-process SLAs quietly fall apart
Almost every growing team hits the same pattern. Early days, maybe three people touching expenses. SLAs are informal — "I'll approve it by Friday." It works because everyone's in the same room (or Slack channel) and the volume is manageable.
-
Reimbursements got slow → someone sets a "5 business day" target.
-
An approval sat for three weeks → someone adds an escalation to the manager.
-
Month-end slipped → someone adds a reconciliation deadline.
None of these were designed together. So they use different units (business days vs. calendar days), different escalation paths (manager vs. finance lead vs. "just ping them"), and different definitions of when the clock even starts. One counts from submission, another from approval, another from... nobody's sure.
The result is a system that looks governed but can't be reasoned about as a whole. When something breaks across two processes — say an approved expense that never got reconciled and is now blocking a client rebill — there's no shared framework to tell you who's late or who owns the recovery.
What breaks at scale isn't any single SLA. It's the absence of a common model underneath them.
The taxonomy: five things every SLA needs to define
Before you can map SLAs to actions, you need the vocabulary. Every SLA in your operation — no matter the process — should be describable with the same five components.
Stop losing track of your business spending.
Costyly helps you record, monitor & control expenses—accurately and efficiently.
- Automated expense categorization
- Real-time budget tracking
- Detailed financial reports
No credit card required
1. The subject. What object is the SLA attached to? A reimbursement request, an approval task, a reconciliation item, a disputed charge, a vendor credit. Everything that moves through finance is an object with a lifecycle.
2. The clock start. The precise event that starts the timer. Not "around submission" — the exact trigger. "Receipt attached and category assigned." "Approver notified." "Statement imported." Ambiguous start events are the single biggest reason SLAs become unmeasurable.
3. The target. How long the subject is allowed to stay in its current state before it's considered breached. Keep units consistent across the whole org — pick business days or calendar days and don't mix them.
4. The breach action. What automatically happens when the target is exceeded, not what someone "should" do. Reassign, escalate, notify, flag for review. A target with no attached action is just a number nobody acts on.
5. The owner. Who is accountable for the subject right now. This changes as the object moves through states, which is why ownership has to be tracked per-state, not per-process.
Once you've described SLAs this way, a reimbursement SLA and a reconciliation SLA are structurally identical. Only the values differ. That structural sameness is what lets you apply one model everywhere instead of maintaining separate playbooks.
A reusable SLA tier table
Instead of inventing targets process by process, define a small set of tiers and assign every SLA to one. This keeps things consistent as the number of tracked objects grows from a handful to a few hundred a month.
| Tier | Typical target | Breach action | Escalates to | Example subjects |
|---|---|---|---|---|
| Fast | 1–2 business days | Auto-reminder, then reassign | Peer / backup approver | Low-value approvals, receipt resubmission |
| Standard | 3–5 business days | Reminder → escalate to owner's manager | Department head | Reimbursements, routine approvals |
| Reconcile | Aligned to close cycle | Flag on reconciliation dashboard | Finance lead | Card matching, statement reconciliation |
| Exception | 2–3 business days (short, deliberate) | Immediate flag, no silent waiting | Finance lead + requester | Disputes, vendor credits, missing-receipt holds |
The mistake most teams make: they give exceptions the longest clock because they're "complicated." That's backwards. Exceptions carry the most financial risk — a stuck vendor credit or an unresolved dispute ages into a write-off. Give them a short clock and loud visibility, not a long leash.
Also worth noting: there are only four tiers here, and that's intentional. If you end up with nine, you've recreated the per-process mess with extra steps. Fewer tiers, consistently applied, beat precise tiers nobody can remember.
Mapping SLA states to actions
A taxonomy only earns its keep when each state maps to a defined action. Here's how the SLA→action mapping works applied to any subject:
-
On clock start — Timer begins, owner assigned, subject appears on the right person's queue. No action required yet, but it's now visible and counted.
-
At 50% of target — Soft nudge to the current owner. This is the cheapest intervention and prevents most breaches. Teams that skip this step end up burning escalation paths on things a reminder would've solved.
-
At target (breach) — The breach action fires automatically per the tier. Reassign, escalate, or flag. Crucially, this does not depend on a human noticing.
-
Post-breach aging — The subject keeps aging and the escalation climbs. A standard-tier item that's been breached for three days shouldn't sit at the same escalation level as one that just breached an hour ago.
-
Resolution — Clock stops, state closes, full timeline recorded. How long each state took is what feeds your analytics later.
One thing worth flagging: don't treat breach as the end of the story. Breach is a state, not an event. An item can be breached and still ignored for a week. Your mapping has to keep escalating past that point, or breaches just pile up quietly somewhere nobody's looking.
RACI: who actually owns each state
Most expense RACI docs are written at the process level — "Finance owns reimbursements." That's too coarse to be useful. At scale, ownership has to be defined per state, because the accountable party changes as the object moves.
-
Capture (submitter's responsibility) Submitter is Responsible. Finance is Accountable for the capture standard (what counts as complete). Bookkeeper is Consulted on category questions.
-
Approval Approver is Responsible. Department head is Accountable for approvals happening within SLA. Finance is Informed.
-
Reconciliation Bookkeeper is Responsible. Finance lead is Accountable. Approver is Informed if a discrepancy traces back to their approval.
The pattern that keeps RACI honest: exactly one Accountable per state, and it's never the same person as Responsible for that state. When those two roles collapse into one person, the SLA has no backstop — if they're out or overloaded, nothing catches it.
This per-state ownership is also what makes the approach from an approval matrix and SLA playbook composable with everything else. Approvals stop being a special island and become one segment of a single accountable chain.
Escalation mechanics that don't just make noise
Escalation is where most frameworks fall apart. Either everything escalates (so nobody reacts) or nothing does (so items rot). Good escalation mechanics have three properties.
They're tiered, not binary. A breach shouldn't jump straight to the CFO. Reminder → owner's manager → finance lead → leadership. Each level only fires if the previous one didn't resolve it.
They carry context, not just a name. "Expense #4821 is late" is useless. "Reimbursement for $1,240, submitted 6 days ago, awaiting your approval, blocking the employee's next submission" tells the person exactly what to do. Escalations without context get ignored because resolving them requires detective work.
They have a ceiling. There needs to be a final level where someone decides — approve, reject, write off, or override. Items that escalate forever without a terminal decision are worse than items that breach quietly, because they consume attention without resolution.
One pattern worth copying: batch low-tier escalations, surface high-tier ones immediately. Nobody needs a real-time ping for a receipt that's one day late — put it in a daily digest. An unresolved dispute aging toward a write-off deadline should interrupt. Mixing these up trains people to ignore all of it.
A cross-process example: capture → approval → reconcile
Here's how the same expense flows through all three processes under one taxonomy:
``
[Capture] → clock start: receipt + category assigned
↓ (Fast tier)
[Approval] → clock start: approver notified
↓ (Standard tier)
[Reconcile] → clock start: statement imported
↓ (Reconcile tier)
[Exception] → triggered by mismatch, short clock, immediate flag
``
This is where the single taxonomy pays off. One expense, all three processes, the same SLA model.
Here's a simple visual of that flow.
Capture. An employee submits a $1,240 client-billable expense. Clock starts when the receipt is attached and category assigned (Fast tier for completeness checks). OCR pulls a questionable amount; at 50% of target, a nudge asks for a clearer receipt. Resolved in a day. State closes, hands off to approval.
Approval. Clock restarts on approver notification (Standard tier). The approver is traveling. At day 3, reminder. At day 5, it auto-escalates to the department head per the Standard tier's breach action. Approved day 6. Because the item was visible and counted the whole time, nobody had to go hunting for it.
Reconcile. The approved expense now needs matching against the card statement and flagging as client-billable (Reconcile tier, aligned to the close cycle). The statement import is the clock start. A mismatch — the card charge is $1,265, not $1,240 — moves it to the Exception tier with a short clock, because unresolved billable discrepancies age into either a client overcharge or an absorbed cost.
Three different processes, one vocabulary. Same tier logic, same breach→action mapping, same per-state RACI. The expense never disappears between processes because the handoff is just a clock stop followed by a clock start on the next subject. This continuity is exactly what a repeatable month-end system depends on — reconciliation stops being a scramble because nothing arrived unaccounted for.
A real scenario
A regional design-build firm with around 18 people — architects, project managers, a part-time bookkeeper, and a finance lead — ran expenses across two entities. Each process had grown its own rules. Reimbursements usually cleared in about a week, approvals "whenever," and reconciliation was a two-day month-end fire drill.
Their actual pain wasn't speed. It was invisibility. Items fell between processes. An approved expense that never got reconciled surfaced three months later as an un-billed client cost — roughly $6k–$8k in client-billable expenses they'd absorbed over two quarters because nobody could tell what had been reconciled and what hadn't.
They collapsed everything into one four-tier taxonomy. Nothing exotic — the same tiers in the table above. Every expense object got a clock start, a tier, a breach action, and a single accountable owner per state.
Within two months, the change wasn't that everything got faster. It was that nothing got lost. Month-end reconciliation dropped from a two-day scramble to roughly half a day because items arrived already accounted for. The un-billed leakage effectively stopped — the Exception tier caught billable discrepancies while they were still fresh. Reimbursement turnaround barely moved, and that was fine; speed was never the real problem. Consistency was. Their work on faster, error-free reimbursements slotted into the same framework without a separate ruleset.
When this makes sense — and when it doesn't
When one SLA taxonomy is worth building:
-
You run more than one expense process with its own ad-hoc rules.
-
Items regularly fall between processes (approved-but-not-reconciled, disputed-but-untracked).
-
You have more than one approver or more than one entity.
-
You can't currently answer "where is this stuck and who owns it?" in under a minute.
When it's overkill:
-
You're a two- or three-person team where everyone sees everything. Formalizing SLAs you already meet informally just adds overhead.
-
Your volume is low enough that a shared spreadsheet and a weekly review genuinely covers it.
Who should not start here: teams whose capture data is a mess. If half your expenses arrive miscategorized or without receipts, an SLA framework will just measure your chaos faster. Fix the capture standard first — then put a clock on it.
Rolling it out without boiling the ocean
You don't deploy a taxonomy all at once. A lightweight checklist to phase it in:
-
[ ] List every expense object you track (reimbursement, approval, reconciliation item, dispute, credit).
-
[ ] For each, define the exact clock-start event. Argue about this until it's unambiguous.
-
[ ] Assign each object to one of four tiers. Resist adding a fifth.
-
[ ] Write the breach action for each tier — automatic, not aspirational.
-
[ ] Define one Accountable owner per state, distinct from Responsible.
-
[ ] Set escalation levels with a ceiling and a terminal decision.
-
[ ] Pick one process to run on the new model for a month before expanding.
-
[ ] Review breaches weekly — not to punish, but to tune tiers and clock starts.
Run the taxonomy on one process for a month to surface tuning needs quickly.
That last point matters most. Your first set of targets will be wrong. Some tier will be too tight and generate noise; another too loose and let things rot. Treat the taxonomy as something you tune, not something you finalize.
The real reason this works
The value of one SLA taxonomy isn't tighter targets. It's that every expense problem becomes the same shape. A late approval, a stale reconciliation item, an aging dispute — they're all just "a subject in a state past its tier target with a defined owner and escalation path." You stop context-switching between twelve micro-policies and start managing one system.
As you add people, entities, and volume, that single model is what holds. Per-process rules multiply with complexity; a shared taxonomy absorbs it. The expense that used to vanish between approval and reconciliation now has nowhere to hide, because the handoff is just one clock stopping and another starting — inside the same framework, owned the whole way through.
Build the vocabulary once. Apply it everywhere.
Build the vocabulary once. Apply it everywhere.
Ready to master your business expenses?
Join 5,000+ businesses using Costyly to save time, reduce overspending, and improve financial visibility.