How to Build n8n Approval Workflow Automation That Auto-Approves and Escalates

A finance lead approves the same refunds every morning. Under $100, customer in good standing, clear reason. Approved, approved, approved. The decision was never hard. It just never got automated, so it eats the first hour of every day.

That's the exact job n8n approval workflow automation is built for. Not replacing judgment on the requests that actually need it, but clearing the ones that don't so a person only sees the edge cases. The pattern is old; the trick is wiring auto-approve and escalation into the same flow with a clean audit trail behind both.

Most guides stop at the human-in-the-loop gate. They show you the Wait node and call it done. The harder, more useful half is the rule engine in front of the gate, the part that decides whether a human ever needs to look.

What you can automate

A request comes in, gets scored, and either clears itself or lands in front of the right person. Common jobs that fit:

• Refund and discount approvals: clear small amounts, escalate anything over a dollar threshold
• Purchase orders and expense reports: auto-approve within budget, route overages to a manager
• Time-off and overtime requests: green-light standard requests, flag ones that breach coverage rules
• Vendor and supplier changes: auto-approve known vendors, escalate new ones for review
• Content or campaign sign-offs: pass routine posts, hold anything touching legal or pricing
• New-customer credit terms: approve low-risk tiers, send high-risk applications to a human

Each one shares the same shape. A rule decides the easy cases; a person decides the rest; everything gets logged.

The approval pipeline

Webhook (request) → Code (score + classify) → IF (under threshold?)
  ├── yes → Set decision = approved → Sheets log → respond
  └── no  → Slack escalation (approve/reject) → Wait (resume webhook)
            → Set decision → Sheets log → respond

The split happens at the n8n-nodes-base.if v2 node. Everything before it is mechanical: collect context, compute a risk score, classify the request. Everything after the human branch is mechanical too. The person only touches the one decision in the middle.

1. Collect the request

A n8n-nodes-base.webhook node receives the request payload — amount, type, customer tier, requester. If the source is a form or another system, normalize the fields here so the scoring step reads a predictable shape. Inconsistent field names are the quiet killer of rule engines; a customerTier that's sometimes tier breaks the comparison silently.

2. Score and classify

A n8n-nodes-base.code v2 node with jsCode computes a risk score. Plain arithmetic, no AI needed for most cases:

const r = $input.first().json;
let score = 0;
if (r.amount > 1000) score += 40;
if (r.amount > 5000) score += 30;
if (r.customerTier === 'new') score += 25;
if (r.type === 'refund') score += 10;
return [{ json: { ...r, riskScore: score } }];

Keep the math readable. The person who tunes this in six months shouldn't need to reverse-engineer a nested ternary.

3. Route on the threshold

The n8n-nodes-base.if v2 node compares riskScore against your ceiling. Pull the ceiling from a Config node rather than hardcoding it, so the number lives in one place:

Condition: {{ $json.riskScore }} < {{ $('Config').first().json.autoApproveThreshold }}

True branch clears the request. False branch escalates. That's the whole decision engine — one comparison, fed by a score you control.

4. Escalate the rest

On the false branch, a Slack message goes to the approver with the full request context and approve/reject buttons. The n8n-nodes-base.wait node then pauses the execution on a resume webhook until someone clicks. This is the part the other guides cover well. It's also the part you'll use least, if the rule engine is doing its job.

5. Log everything

Both branches converge on a Google Sheets append. Every decision gets a row: request ID, amount, score, the branch it took, who approved it (or "auto"), and a timestamp. Logging the auto-approved path matters as much as the escalated one. An auditor asking "who approved this $80 refund?" needs an answer, even when the answer is "the rule did, at this score, on this date."

Why the rule engine matters more than the gate

Here's an opinionated take: the Wait node is the easy 20% of approval automation, and most tutorials spend 80% of their words on it. The part that actually saves time is the scoring logic in front of it. A gate with no rule engine just relocates the bottleneck — now a human approves everything through Slack instead of email. Faster, sure. But you haven't removed the work, you've reskinned it.

The payoff is in the threshold. Tune it so 80% of requests clear themselves and a person only sees the 20% that genuinely need a brain. That ratio is where the hours come back.

Implementation patterns

Pattern 1: Threshold split with a Config node

Put every tunable number in an n8n-nodes-base.set v3.4 Config node at the top of the workflow — auto-approve ceiling, escalation channel, the customer tiers that always escalate. Reference them downstream:

{{ $('Config').first().json.autoApproveThreshold }}

Ops changes the policy by editing one field. No branching logic gets touched, which means no broken workflow at 5pm on a Friday.

Pattern 2: Timeout fallback on the Wait node

A human gate that waits forever is a liability. If a refund sits unapproved for 24 hours because the approver's on leave, the customer's still waiting. Set a timeout on the Wait node and decide the default: auto-reject and notify, or escalate to a backup approver. Make the choice explicit. Silence isn't a decision.

Pattern 3: Quorum for high-stakes requests

For requests above a second, higher threshold, require two approvals instead of one. A second IF node checks the score; above the high mark, the flow fans out two Slack messages and waits for both resume webhooks before clearing. Most teams don't need this. The ones moving real money do.

n8n nodes you'll use most

Getting started

1. Map your decisions. Write down the five requests you re-approve most and the rule each one actually follows.
2. Build the Config node first. List your thresholds and channels as fields.
3. Add the Webhook trigger and normalize the incoming fields.
4. Write the scoring Code node. Start simple: amount and customer tier cover most cases.
5. Add the IF node and wire the two branches.
6. On the escalate branch, add Slack plus the Wait node with a timeout.
7. Converge both branches on a Google Sheets append, then return a response.

If you'd rather not build the scoring and audit logic from scratch, the Routine Decision Rule Engine ships the whole pattern ready to configure.

Approvals are one slice of a bigger pattern: codifying the small decisions you make on repeat. The same scoring-and-route shape drives the structured analysis in n8n decision support automation, and it pairs naturally with the intake side covered in n8n Google Forms automation. Build the rule engine once, and the requests that used to eat your morning clear themselves before you're at your desk. The ones that need you still find you. That's the whole point.