| Author: Abdullah Ahmed | Category: AI Automation
An accounts assistant approves a proposed supplier update. Before the background worker executes it, someone changes the destination account in the draft. The system still sees an approved status and proceeds.
There was a human in the workflow, but the approval did not protect the action that actually happened. This is the central design problem in approval-aware AI automation: connect a person's informed decision to a specific, current, authorised operation.
AI can help read requests, collect evidence, identify discrepancies, and prepare proposals for finance and operations teams. The application must own the approval rules and execution controls. The following design approach applies to business workflows such as purchase requests, supplier changes, inventory adjustments, and exception handling.
Define the action being approved
Start with a precise business operation. “Approve this request” can mean permission to investigate, permission to amend a record, or permission to release a downstream instruction. Those decisions should not share an ambiguous button.
For a purchase request, the proposed action might include the supplier identity, items, quantities, amount, currency, cost centre, and intended destination system. For a stock adjustment, it might include the location, item, quantity difference, reason, and supporting count record.
Show the proposal as a change from the current state where that comparison matters. An approver can assess a bank-detail update more effectively when the interface highlights the exact fields changing and identifies the independent verification evidence.
Keep the scope narrow. Approval of an extracted invoice does not automatically authorise a payment, and approval of a supplier record does not authorise every future transaction involving that supplier. Model each authority explicitly.
Separate preparation, decision, and execution
Use distinct responsibilities for the component that prepares a proposal, the person or rule that authorises it, and the service that performs it. The AI preparation step should not hold credentials that bypass the approval mechanism.
A workflow can produce a draft with structured fields and evidence references. A policy service determines the required approvers. An execution service accepts only a valid authorised operation and checks its current preconditions.
This separation also improves maintenance. A prompt change can alter how a description is summarised without changing the rules for who may approve a large adjustment. Policy changes can be reviewed as application behaviour rather than hidden inside free-form instructions.
Where low-risk operations qualify for automatic approval, represent that decision explicitly with the applicable policy version and reason. Do not silently treat the absence of a human task as permission.
Write an approval policy people can explain
Gather the existing rules from finance and operations owners. Include limits, organisational scope, exception types, and any separation of duties. Clarify what happens when the usual approver is absent or the request crosses several departments.
Use a decision table before implementing the routing. The values should come from the organisation's policy; example thresholds in a demonstration must never become production authority by accident.
| Condition | Required decision | Additional evidence |
|---|---|---|
| Routine request within delegated scope | Responsible role under current policy | Complete source request and matching records |
| Sensitive supplier detail change | Designated independent reviewer | Verification through an approved separate channel |
| Unexplained inventory discrepancy | Operations exception owner | Count history and discrepancy explanation |
| Missing or contradictory evidence | Return for clarification | Resolved evidence before a new proposal |
Define precedence when several conditions apply. The system should not choose the easiest route merely because one low-risk rule matches. Make policy decisions reproducible from recorded inputs.
Bind approval to a versioned proposal
Assign each proposal a version and preserve its material fields. An approval record should identify that version, the approver, the decision time, the policy applied, and the action scope.
Changing a material field should create a new version and invalidate approvals that no longer cover it. Materiality depends on the workflow: an amount, recipient, quantity, account, or destination change will usually matter more than an internal formatting correction.
The OWASP Transaction Authorization Cheat Sheet recommends server-side enforcement, clear transaction information, and controls that prevent transaction data from changing after authorisation. Apply those principles to the executable proposal, not only to the review screen.
At execution time, compare the authorised version with the submitted operation. A browser-provided approved flag is not evidence. Read the durable approval record and verify that it is valid for the exact operation being attempted.
Give reviewers evidence they can inspect
A fluent summary can hide an important omission. Show the source material, relevant record values, validation results, and the proposed change. Let the reviewer open the evidence without losing their place in the task.
Distinguish extracted facts from AI interpretation. “Invoice states this amount” is different from “the description appears to match this purchase order.” Where an assertion lacks a source, display it as an inference or unresolved field.
Highlight discrepancies that affect the decision. A different legal entity, a currency mismatch, or a missing receipt should not be buried in a long generated narrative. Present the reason for review close to the action controls.
Allow reviewers to reject, request clarification, or correct a proposal. Capture the reason in a way that helps the next person understand the decision. A single approve button encourages staff to use approval as a way of clearing the queue even when the evidence is incomplete.
Enforce identity and authority at the server
Authentication establishes who is using the system. Approval authority depends on role, organisational scope, delegation, and the current request. Check these conditions on every decision endpoint.
Separate the requester from the approver where policy requires independent review. Do not rely on the interface hiding a button: a caller may send a request directly, use an old link, or act through a different client.
Check delegated authority at the time of the decision and again before execution when required by the process. An employee may move teams or lose authority while a request waits. Record the policy for approvals granted before such a change.
Approval links in email should lead to an authenticated review experience appropriate to the action. Possession of a forwarded notification should not automatically grant the recipient power to approve a sensitive operation.
Treat waiting as a durable part of the process
Human decisions do not fit inside a short API request. Store the pending state, assigned role, due time, proposal version, and escalation history. The workflow should survive worker restarts and expired browser sessions.
Make queue ownership visible. A task assigned to a role still needs an operational team responsible for ensuring someone handles it. Track the age of pending requests and the reasons they are waiting.
Define escalation without silently weakening controls. If the normal approver is unavailable, route to an authorised delegate or exception owner. A timeout should not become approval unless the business has explicitly defined and justified that behaviour.
Specify expiry. Some proposals remain valid for days; others depend on a short-lived price, reservation, or operational state. Expiry should move the workflow to a clear state that requires refresh or cancellation.
Recheck the world before acting
Even an unchanged proposal may become invalid because the underlying business state changes. Stock may be reserved elsewhere, the supplier may be blocked, or the source request may be withdrawn.
Define execution preconditions separately from approval requirements. The executor should confirm that the operation is still relevant and that the expected record version remains current. If those checks fail, stop and explain the mismatch.
Use concurrency control around local state transitions so that two workers cannot both claim the same operation for execution. For remote effects, use the destination's supported idempotency or unique-reference mechanism where available.
A precondition failure should not trigger an automatic rewrite followed by reuse of the old approval. Prepare a new proposal when the required action changes, and route it through the appropriate decision again.
Record execution outcomes honestly
Approved, submitted, and completed are different states. An approved adjustment may still be waiting for the inventory system. A submitted instruction may time out before the caller learns whether it was accepted.
Preserve the external operation reference and a stable idempotency key where supported. If the outcome is uncertain, query or reconcile before retrying. Avoid creating a second financial or operational effect because a network response was lost.
Show staff the difference between rejection by policy, technical failure, and an unknown remote outcome. Each requires a different next step. A generic red error can prompt an operator to repeat an action that already succeeded.
Keep an action ledger that links proposal, approvals, execution attempts, and confirmed result. It should support investigation without requiring unrestricted access to every source document.
Make exceptional access accountable
Some organisations need an emergency process for urgent operational work. Design it explicitly with the process owner. Define who may invoke it, which controls remain mandatory, and what review follows.
Do not implement emergency handling as an undocumented administrator bypass. An override should have a reason, scope, expiry where relevant, and a durable record. Staff should be able to distinguish an ordinary approval from an exceptional authorisation.
Test permission changes, delegation expiry, and conflicting decisions. If one reviewer approves while another rejects, the outcome must follow defined policy rather than whichever database update happens last.
Also test how the system behaves when its approval service is unavailable. Consequential execution should not proceed merely because the check could not be completed.
Measure whether approval improves decisions
Queue throughput alone can reward shallow review. Track correction reasons, repeated missing evidence, stale proposals, and cases that needed reopening after execution. These signals reveal whether the workflow helps people make informed decisions.
Review a representative sample with the responsible team. Ask whether the evidence was sufficient, whether the highlighted issues were relevant, and whether staff could understand the proposed effect. Improve the interface and preparation step based on those findings.
Watch for repeated approvals completed too quickly to inspect complex evidence, but interpret that signal carefully. Experienced staff may handle familiar cases rapidly. Use observation and discussion before assuming a metric proves poor behaviour.
Version policy and preparation changes so their effects can be compared. A lower review time is useful only if the quality and authority of the decisions remain acceptable.
Review a supplier-change scenario end to end
Imagine a supplier sends a request to update its remittance details. The AI component extracts the claimed supplier identity, proposed fields, and supporting references into a draft. It marks the request as sensitive under the application's policy and cannot update the supplier master record itself.
A staff member follows the organisation's independent verification process and attaches the verification reference. The proposal shows the existing and proposed values. An authorised reviewer approves that exact version, with the relevant evidence and policy version recorded.
Before execution, a separate check confirms that the supplier is still eligible for changes and that the master record has not changed since the proposal was prepared. If another authorised update occurred, the system returns the proposal for reconciliation. It does not overwrite the newer record merely because an earlier version was approved.
If the update call times out, the workflow displays an uncertain result and checks the destination before retrying. Once confirmed, it records the destination reference and closes the operation. The audit view connects the incoming request, independent verification, approval, and final effect.
This scenario illustrates a design pattern, not a universal verification policy. The organisation must define the appropriate evidence and authority for its own operations. The software's job is to enforce that decision consistently and keep it reviewable.
Consider what happens when evidence changes
A reviewer may discover that a supporting document belongs to another entity. A later message may withdraw the request. The workflow needs a way to mark evidence invalid and determine which pending approvals depend on it.
For work already executed, the response may be a new corrective process rather than deletion of history. Preserve the original decision and record the correction. Staff need to understand the sequence, especially when an external system has already acted.
Reduce review fatigue through better preparation
Group genuinely routine evidence and highlight deviations, but avoid hiding material details behind an unexplained risk label. Reviewers should be able to inspect the basis for a proposal without reading a long generated essay.
Route requests to people with the relevant authority and context. Sending every item to the most senior person can create delay without improving judgement. The policy should match responsibility while retaining required independent checks.
Test the review experience with realistic workloads. Ask staff to identify a planted discrepancy, reject an incomplete proposal, and explain what approval will cause. If they cannot do those tasks reliably, improve the presentation before increasing automation volume.
Make feedback useful to the preparation team. Repeated corrections to one field may indicate missing reference data, an ambiguous schema, or a poor extraction step. Fixing that cause can reduce review effort without weakening the approval boundary.
Start with one controlled operation
Choose a workflow with a clear owner, accessible evidence, and a well-understood execution interface. Write down the proposal fields, approval policy, invalidation rules, and recovery path before connecting the AI step.
Then demonstrate the difficult cases: edit an approved proposal, revoke an approver's authority, withdraw the source request, and lose the execution response. A system that handles those cases clearly is much closer to a dependable approval workflow than one that only shows a successful happy-path demo.
The practical result should be an operation that a person can understand, authorise, and later explain. AI assistance is valuable when it reduces preparation work while preserving that chain of responsibility.