Natural Language Approval Rules: The End of Workflow Consultants

The line item nobody questions

Go pull up your company's annual ERP budget. Somewhere in there, you'll find a line item — maybe split across a few categories — that adds up to roughly $150K or more. Workflow consultants. Approval matrix configuration. Change request fees. Testing cycles.

It's been there so long that nobody questions it. The assumption is baked in: changing how approvals work requires specialists, because the system speaks a language that finance people don't.

What if that assumption is just... wrong?

September 28. Q4 starts in 3 days.

We hear this one constantly. A Controller needs to tighten approval controls before quarter-end close. Four changes. Nothing exotic — lower the threshold on consulting invoices, add an exception for pre-approved vendors, route related-party transactions through Audit Committee, set up a backup approver.

She knows exactly what the rules should be. She could explain them to a new hire in two minutes. But explaining them to the ERP? That's a project.

The 6-step, 27-day approval rule change

Here's what actually happens in a legacy ERP when finance wants to change four approval rules:

• •Step 1 (2–3 days): Controller and Finance Manager draft a requirements document. Map the approval matrix. Document edge cases. Circulate for review.
• •Step 2 (1–2 days): Finance Manager submits an IT change request. Ticket lands behind 23 others in the queue. Priority: Medium.
• •Step 3 (5–8 days): A Business Analyst translates the spec. A developer builds 4 workflow branches, 6 condition nodes, a calendar integration, a delegation chain. The "pre-approved vendor" exception? Can't be done without custom development.
• •Step 4 (3–5 days): QA runs 40+ test scenarios. Finance Manager validates in sandbox. Three bugs. Back to dev.
• •Step 5 (2–7 days): Change Approval Board reviews. IT Director, Finance Director, Compliance Officer. The board meets Thursdays. Just missed this week's.
• •Step 6 (1–2 days): Production deployment. Notify affected users. Hope nothing breaks.

Total: 14–27 days. 6 people across 3 departments. $8–15K. And remember — Q4 started October 1. Best case, the policy goes live October 12. That's 12 days of Q4 running with last quarter's controls.

Or she could just write the rules herself

With Uno360's natural language workflow engine, the Controller emails the ERP directly. Plain English. The same words she'd use to explain the policy to a colleague.

No requirements document. No IT ticket. No BA translating English into decision trees. The rule is the specification.

What comes back

The AI Engine parses the four rules, creates them with auto-expiry, runs a simulation against 90 days of real transactions, and responds:

She reviews the simulation report, replies "Activate," and the rules are live. Before Q4 starts. One person. One email. Zero dollars.

Who actually owns the rules?

Here's the question nobody asks because the answer feels inevitable: why does Finance need IT's permission to change a finance policy?

In legacy systems, the answer is architecture. Approval rules live as code — decision trees, condition nodes, workflow branches compiled into the system. Only developers can write that code. So finance writes requirements, IT translates them, and somewhere in the translation, nuance gets lost. The "pre-approved vendor exception"? Too complex for the workflow engine. The auto-expiry? Manual reminder to undo the rules in January.

When rules are stored as natural language and evaluated by AI at runtime, that dependency disappears. The Controller writes "All consulting invoices over $10,000 require my approval." That sentence is stored verbatim. The AI Engine evaluates each transaction against it. No translation layer. No code. No drift between what the policy says and what the system enforces.

The math on $150K

We've run this analysis with a dozen mid-market companies. The workflow management cost stack usually breaks down like this:

• •Workflow tooling licenses: $30–80K/year for platforms like ServiceNow, Kissflow, or ERP-specific modules
• •Implementation consultants: $40–120K/year for initial setup and ongoing modifications
• •Change requests: $8–15K per cycle, 8–12 cycles per year = $65–180K
• •Internal IT time: 20–40% of an ERP admin's bandwidth on workflow maintenance

Conservative total: $155–385K per year. And that's before counting the cost of delayed policy enforcement — those 12 days of Q4 without proper controls, multiplied by every quarter-end, every regulatory change, every reorg.

When approval rules are written in English, all of it goes away. Not reduced. Gone.

The rule is the documentation

There's a subtler benefit that Controllers love. In a legacy system, the approval rule exists in three places: the policy document, the requirements spec, and the code. They drift apart. Always. "The docs say VP approves over $25K, but the system is set to $30K" — we've heard versions of this from almost every finance team we've talked to.

With natural language rules, there's one source of truth. The rule says "VP approves marketing spend over $25K, except recurring vendors with 12+ months history." That's the policy. That's the implementation. That's the audit documentation. One artifact, three purposes.

When an auditor asks "what are your approval thresholds?", the answer isn't "let me check with IT." It's "here — read them yourself." Because they're already in English. And every change is logged with full reasoning — who changed it, when, and why.

Same architecture, everyday use

We used a quarter-end scenario to make the point. But this isn't just for big policy overhauls. The same communication intelligence handles the mundane stuff too.

A new VP joins and needs approval authority for her department. A vendor gets upgraded from probationary to preferred. The board raises the materiality threshold from $50K to $75K. A temporary delegation while the CFO is on vacation. Each of these is a one-line email, not a change request.

The architecture that freezes $2.3M in vendor payments at midnight is the same one that adjusts an approval threshold over lunch. Different stakes. Same 30 seconds.

Where we stand

Approval rules are business logic. They belong to the people who understand the business. Not to developers who translate requirements into decision trees, not to consultants who charge by the workflow branch, and definitely not to a Change Approval Board that meets once a week.

We're building an ERP where the people who know the rules can write the rules. In their own words. And the system just works.

Write rules in English. Change them in seconds.
The $150K consultant just became a $0 email.