## Introduction
In my production n8n setups I often see approvals as the bottleneck: long email threads, missed deadlines, and unclear routing. This post shows how to build n8n approval workflows that cut approval time by using dynamic multi-step routing, parallel approvals, reminder schedules, and escalation paths. The pattern is flexible for expense approvals, contract sign-offs, marketing creative reviews, or any decision that needs conditional routing.
I walk through a complete, production-ready workflow with concrete node configurations, expressions, Function node code, credential tips, and operational best practices. Expect to be able to copy/paste code blocks and run this in a self-hosted setup with SMTP/Slack and your CRM/API.
Primary keyword: n8n approval workflows (used throughout to emphasize the focus).
## Why dynamic multi-step n8n approval workflows?
– Remove manual routing: decisions are routed automatically based on metadata (amount, department, SLA).
– Cut delays: schedule reminders and escalate automatically when approvers miss deadlines.
– Improve visibility: write status back to your CRM or Google Sheet.
A pattern I rely on is a small orchestrator workflow that creates an approval context, then fans out approval tasks (parallel or sequential) and merges results with a final decision node. I use the Switch, Wait, Merge, and Function nodes heavily.
## Prerequisites
– A running n8n instance (I recommend self-hosted for enterprise automation; see notes on self-hosted n8n scaling).
– Credentials configured: SMTP (Email), Slack, and your CRM/API (OAuth2 or API key). Use environment variables for secrets in production.
– Optional: Redis for distributed locks and idempotency (n8n Redis integration helps when you scale workers).
– Basic familiarity with n8n nodes: Webhook, Set, Function, Switch, HTTP Request, Wait (Delay), Merge, and Execute Workflow.
Credentials tips from my experience:
– For OAuth2 credentials, enable token rotation and set a monitored Error Trigger workflow to refresh or alert on failures.
– Store SMTP and Slack webhook credentials in n8n Credentials, not in Set nodes.
## Step-by-step guide (numbered + code/examples)
This example builds a workflow that:
1) Accepts an approval request via Webhook
2) Builds an approval context
3) Routes to approvers dynamically (sequential or parallel)
4) Waits with reminders and escalations
5) Merges responses and writes a final status back
1) Webhook trigger — incoming request
– Node: Webhook (HTTP POST)
– Example payload expected:
“`json
{
“requestId”: “REQ-12345”,
“amount”: 4800,
“department”: “Marketing”,
“requester”: { “name”: “Alice”, “email”: “alice@example.com” },
“approverHints”: [“manager”, “finance”]
}
“`
Webhook settings: resource = Generic, HTTP Method = POST, Response Mode = “On Received” (we return an immediate 202 with an approvalId).
2) Set approval context
– Node: Set
– Purpose: create workflow variables like approvalId, deadline, routing rules.
Example Set node values (field names):
– approvalId: {{$json[“requestId”]}}
– amount: {{$json[“amount”]}}
– department: {{$json[“department”]}}
– deadline: {{$now.add(48, ‘hours’).toISOString()}} (48-hour SLA)
– mode: {{$json[“amount”] > 5000 ? ‘sequential’ : ‘parallel’}}
3) Build dynamic approver list (Function node)
– Node: Function
– Purpose: expand approverHints into explicit approver objects via a lookup table or API.
Function node code:
“`javascript
// Map approverHints to real approvers
const lookup = {
manager: { name: ‘Team Manager’, email: ‘manager@example.com’ },
finance: { name: ‘Finance Approver’, email: ‘finance@example.com’ },
director: { name: ‘Director’, email: ‘director@example.com’ }
};
const hints = $json.approverHints || [‘manager’];
const approvers = hints.map(k => lookup[k]).filter(Boolean);
return [{ json: { approvers } }];
“`
4) Create tasks for approvers (Execute Workflow or HTTP Request to Tasking system)
If you use a Tasking system (Jira, ServiceNow) use HTTP Request with OAuth2. For direct emails use the Email node to send an approval link back to n8n (e.g., a pre-signed webhook URL).
Example approval email flow using Email node and an auth token:
– Build an approval link in a Set node: `https://example.com/approve?approvalId={{$json.approvalId}}&approver={{$json.approver.email}}&token={{$randomUuid()}}`
– Store token in a small store (Google Sheet, Redis, or a database) for validation.
5) Routing: parallel vs sequential
– If mode == ‘parallel’: fan out approvals using SplitInBatches or by using the Function node to return multiple items. Each email contains a webhook link to submit approval.
– If mode == ‘sequential’: send only to the first approver. On approval, trigger the workflow to send to the next.
Example expression in Switch node:
– Condition: {{$json.mode}} equals “parallel”
6) Wait, reminders and escalations
I use the Wait node (Delay) and an internal scheduler pattern: create a child workflow that monitors deadlines every 15 minutes for pending approvals. When a reminder is due, run the Email/Slack notification; if past SLA, escalate to the director.
Reminder logic (pseudo):
– If now > deadline – 24h send first reminder
– If now > deadline – 6h send urgent reminder
– If now > deadline escalate
7) Merge approvals and finalize
Use the Merge node with Mode = Wait For All (for parallel) or sequence logic for sequential. Final decision rules:
– Any “rejected” => final = rejected
– All “approved” => final = approved
– Timeout => escalate or auto-decline depending on policy
8) Write back status / Integrate with CRM
– Node: HTTP Request (CRM) or Google Sheets
– Example payload:
“`json
{
“requestId”: “REQ-12345”,
“status”: “approved”,
“approvals”: [ { “email”: “manager@example.com”, “decision”: “approved” } ],
“resolvedAt”: “2025-02-01T12:34:56Z”
}
“`
## Concrete node configuration examples
Function node: compute next approver (JS)
“`javascript
const approvals = $input.all();
// find next unapproved
const next = approvals.find(a => !a.json.decision);
if (!next) {
return [{ json: { done: true } }];
}
return [{ json: { nextApprover: next.json.email } }];
“`
HTTP Request node: CRM update (OAuth2 credential name = CRM OAuth2)
– Method: POST
– URL: https://api.crm.example.com/approvals
– Authentication: OAuth2 (CRM OAuth2)
– Body (raw JSON):
“`json
{
“id”: “{{$json.requestId}}”,
“status”: “{{$json.status}}”,
“meta”: {{$json}}
}
“`
## Best practices
– Idempotency: create an approvalId and validate tokens to avoid double-processing. I store tokens in Redis and mark them consumed. Use n8n Redis integration if you scale horizontally.
– Observability: write audit events to a central store (Elasticsearch, DB, or Google Sheet) and create a dashboard. Include requestId and timestamps.
– Security: validate approval tokens server-side. Do not accept email-only approvals without token verification.
– Error handling: build an Error Trigger workflow that catches failed HTTP Requests and retries with exponential backoff. These are n8n error handling best practices I use daily.
– Secrets: use environment variables for credentials and avoid embedding secrets in Set or Function nodes.
## Common pitfalls & fixes
– Race conditions when two approvers try to approve simultaneously: use Redis locks or database transactions to serialize state updates.
– Missing expressions: if your expression returns undefined, the workflow can produce malformed emails. Use defensive code like `{{$json.amount || 0}}`.
– Timezones: store UTC timestamps. When calculating deadlines for approvers in different locales, convert to their timezone in the notification only.
– Token expiration on external APIs: monitor OAuth2 token expiry and add a refresh workflow. A common failure mode is long-running approval tasks where downstream API tokens expire — refresh or queue writes.
– Over-notification: use exponential reminder backoff, e.g., 24h -> 6h -> 1h, to avoid spamming approvers.
## FAQ
### Q: Can I support both parallel and sequential approvals in the same n8n approval workflows?
Yes. I implement a mode flag (mode = “parallel” or “sequential”) in the Set node. For parallel, return multiple items to fan out; for sequential, use the Function node to return only the current approver and chain approvals on each approval callback.
### Q: How do I make approval links secure?
Generate a random token per approver, store it in Redis or DB, and validate the token on the approval webhook. Tokens should be single-use and expire (e.g., 7 days).
### Q: What if the approver’s email client blocks images or buttons?
Include a plain URL fallback and a copy of metadata in the email. Also provide Slack notifications for teams that use Slack.
### Q: How do I scale this pattern in self-hosted n8n scaling environments?
Use Redis for distributed locks and idempotency, horizontal worker nodes, and an Error Trigger for failures. Monitor queue lengths and use the Execute Workflow node to break large workflows into smaller child workflows.
### Q: How can I test this workflow before production?
Use Postman to send sample payloads to the Webhook node, and inspect the execution using n8n’s Executions panel. Create a staging environment with a sandbox SMTP or Slack workspace.
## Conclusion
n8n approval workflows that use dynamic multi-step routing, reminders, and escalations can dramatically cut approval time. In my production n8n setups, this pattern reduced mean approval time by 60% in one quarter by removing manual handoffs and adding automated reminders and escalations.
Try this pattern in your n8n instance today: implement a webhook-triggered orchestrator, add dynamic routing with a Function node, and handle reminders and escalations with a scheduler. For fundamentals and a deeper n8n primer, see [n8n Fundamentals](/fundamentals).
Next steps/CTA:
– Deploy a staging version and run 10 test requests.
– Add Redis to track tokens and locks.
– Integrate with your CRM via OAuth2 and monitor with an Error Trigger workflow.
[Picture: workflow-diagram-placeholder]