An approval chain is a sequence of human decision points inserted into an otherwise automated process. Rather than the system completing every step on its own, it pauses at defined stages, routes a request to one or more people, waits for a decision, and then continues based on the outcome. The value lies in keeping human judgement where it matters while removing the manual work of moving information between people.
Approval chains sit within a broader workflow system but behave differently from straight-through automation. A business rules engine might determine that an invoice under £500 can be paid automatically, whereas anything above that threshold enters an approval chain. The rules engine handles the routing logic; the approval chain handles the human interaction layer on top of it.
There are three structural patterns that cover most business needs. Sequential approval passes a request from one person to the next in a fixed order, common in purchase-order sign-off where a line manager approves before finance reviews. Parallel approval sends the request to multiple people at once, useful when several department heads need to weigh in independently and none needs to wait for another. Conditional approval changes the chain based on data in the request itself: a high-value contract might require board-level approval that a standard one would not.
Each approval step needs a defined set of elements: who can approve, what they are approving, what information they see when making the decision, what actions are available to them (approve, reject, request changes, delegate), what happens to the request after their decision, and what the time limit is before the system escalates. Missing any of these creates ambiguity that stalls processes or forces workarounds.
Automation decisions to resolve before building
Document and contract approvals
In a customer portal or internal document-management system, contracts often require review by sales, legal and finance before execution. The workflow receives a drafted contract, attaches the relevant metadata (customer, value, contract type), and routes it according to rules. Legal only sees contracts above a certain value or containing specific clauses. Finance only sees the commercial terms. Each approver works within their own view, reducing noise and focusing their decision on what they are responsible for.
Purchase-order and expense approvals
Replacing spreadsheet-based approval logs with a system where purchase requests are submitted, validated against budget codes, and routed automatically removes significant admin overhead. The chain might require a project manager's approval first, then a department head if the amount exceeds a threshold, then finance for final release to the supplier. Each step can have different time limits: a project manager might have two working days, finance five.
Customer onboarding and compliance checkpoints
For regulated industries, customer onboarding often includes Know Your Customer checks, risk assessments and manual verification at specific points. The system can automate data collection, identity verification and initial scoring, then pause for a compliance officer to review flagged cases before the account is activated. The approval chain here is not about hierarchy but about specialist judgement that cannot be reduced to rules alone.
Delegation and absence handling
One of the most practical considerations is what happens when an approver is unavailable. The system needs rules for delegation: can the approver nominate a deputy, does it automatically fall to a defined backup, or does it escalate to a manager? Delegation rules should be configurable per approver rather than a single global setting, because the right delegate for a finance approval is unlikely to be the right delegate for a legal one.
Time-based escalation
Without escalation, approval chains become bottlenecks. Each step should have a configurable timeout. When the timeout is reached, the system can send reminders, escalate to a designated backup, or in some cases auto-approve with a flag for later review. The appropriate behaviour depends on the risk profile of the decision. Auto-approving a low-risk expense after three days might be acceptable; auto-approving a contract never is.
Integration with the rest of the system
Approval chains do not exist in isolation. When an approval is granted, the system typically needs to trigger downstream actions: updating a record status, sending a notification, creating a task, or calling an external API to release a payment. When an approval is rejected, the workflow needs to route the request back to the originator with context about why, and often with the ability to amend and resubmit without starting from scratch.
Over-engineering simple decisions
A frequent failure is building approval chains for decisions that do not need them. If every purchase request, regardless of value, requires three levels of sign-off, the system will be slower than the spreadsheet it replaced. The design phase should start by identifying which decisions genuinely require human judgement and which can be handled by rules. Every approval step adds latency, so each one must earn its place.
Ignoring exception paths
Workflows are usually designed for the happy path: submit, approve, approve, complete. In practice, approvers request changes, reject with conditions, delegate unexpectedly, or simply disagree with each other in parallel chains. The system needs clear rules for what happens when one parallel approver approves and another rejects, when changes are requested after partial approval, and when a request has been rejected and resubmitted multiple times.
No audit trail
Approval chains create a decision record that matters for compliance, dispute resolution and process improvement. Every action, who took it, when, and with what comment should be logged immutably. If the system allows approvers to edit their decisions after the fact, the audit trail loses its value. Check whether the logging meets the retention and immutability requirements relevant to your sector, and seek current specialist advice where regulation applies.
Insufficient information at the point of decision
An approver who cannot see what they need to make a decision will either delay or guess. Each approval step should present the relevant data, document previews, history of previous decisions on the same request, and any related records. If the approver has to leave the system and open another application to find context, the workflow is not functioning as intended.
Questions that should be answered before supplier commitment
- Can approval chains be configured without code changes, or does each new workflow require development work?
- How does the system handle approvers who are also the submitter, to prevent self-approval?
- Can delegation rules be set per person and per workflow type?
- What happens to in-flight approvals when organisational structure changes and reporting lines are updated?
- Is the audit trail exportable, and can it be retained independently of the workflow system?
- Can approvers see the full chain history, including previous rejections and resubmissions?
Checks before an automated approval chain goes live
- Test every exception path: rejection, change request, delegation, timeout and escalation.
- Verify that parallel approvals handle conflicting decisions according to your business rules.
- Confirm that resubmission after rejection does not duplicate records or create orphaned tasks.
- Check that notifications reach the right people at the right time without spamming unrelated users.
- Ensure the audit trail captures enough detail to satisfy your compliance and internal-review requirements.
- Run the workflow with a small group using realistic scenarios before rolling out organisation-wide.
Approval chains are a focused tool: they insert human control at the points where automation should stop and judgement should take over. Designing them well means being clear about which decisions need that control, building the exception paths that real use will inevitably require, and ensuring the system logs enough detail to be accountable afterwards.