Introduction
Once you’ve mastered basic n8n workflows, you’ll encounter scenarios requiring more sophisticated patterns: handling errors gracefully, processing large datasets, creating reusable components, and managing complex branching logic. This guide covers advanced workflow patterns that will help you build robust, maintainable automations.
Understanding Flow Logic in n8n
n8n provides several core nodes for controlling workflow execution flow:
┌─────────────────────────────────────────────────────────────────────┐
│ n8n Flow Control Nodes │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ If │ │ Switch │ │ Loop │ │ Wait │ │
│ │ │ │ │ │ │ │ │ │
│ │ Condition│ │ Multiple│ │ Iterate │ │ Pause │ │
│ │ Branching│ │ Cases │ │ Items │ │ Workflow│ │
│ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Merge │ │ Split │ │ Error │ │ Sub- │ │
│ │ │ │ Batches │ │ Handler │ │ Workflow│ │
│ │ Combine │ │ Chunk │ │ Catch │ │ Reuse │ │
│ │ Branches│ │ Data │ │ Errors │ │ Logic │ │
│ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘
Conditional Branching
Using the If Node
The If node routes data based on conditions:
┌─────────────────┐
│ Trigger │
│ (HTTP/Webhook)│
└────────┬────────┘
│
▼
┌─────────────────┐
│ If │
│ │
│ Condition: │
│ {{ $json.status │
│ === "active" │
│ }} │
└────────┬────────┘
┌────┴────┐
│ │
▼ ▼
┌────────┐ ┌────────┐
│ True │ │ False │
│ │ │ │
│ Process│ │ Log & │
│ Active │ │ Return │
│ User │ │ 400 │
└────────┘ └────────┘
Multiple Conditions
Chain If nodes for complex logic:
# Multiple If Nodes Pattern
workflow:
- If: "status === 'active'" # First check
true: → Check Permission
false: → Log Inactive User
- If: "role === 'admin'" # Second check
true: → Full Access
false: → Limited Access
Using the Switch Node
For multiple branches, Switch is more efficient:
# Switch Node Configuration
{
"data": "{{ $json.order_status }}",
"cases": {
"pending": "→ Process Pending Orders",
"processing": "→ Update Processing Status",
"shipped": "→ Send Shipping Notification",
"delivered": "→ Update CRM",
"_default": "→ Log Unknown Status"
}
}
Looping and Iteration
Split In Batches Node
Process large datasets without overwhelming APIs:
┌─────────────────┐
│ Get All Items │
│ (1000+ records)│
└────────┬────────┘
│
▼
┌─────────────────┐
│ Split In Batches│
│ │
│ Batch Size: 10 │
│ Wait: 500ms │
└────────┬────────┘
│
┌────┴────┐
│ Loop │
│ 10 at │
│ a time │
▼ ▼
┌─────────────────┐
│ Process Each │
│ Batch of 10 │
└────────┬────────┘
│
▼
┌─────────────────┐
│ Continue │
│ Loop? │
└─────────────────┘
Loop Over Items Configuration
// Loop configuration
{
"batchSize": 10, // Items per iteration
"wait": 500, // Wait between batches (ms)
"maxWait": 30000 // Maximum wait time
}
Practical Example: Process Customer List
# Customer Processing Workflow
1. Trigger: Schedule (daily at 9 AM)
2. HTTP Request: GET /api/customers
3. Split In Batches:
- Batch size: 5
- Wait: 1000ms (rate limiting)
4. Loop per batch:
a. HTTP Request: POST /api/send-email (per customer)
b. Wait: 500ms
5. Slack: Send summary message
Error Handling
Error Workflow Pattern
Create a dedicated error handling workflow:
┌─────────────────────────────────────────────────────────────┐
│ Main Workflow │
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Execute │───►│ Execute │───►│ Success │ │
│ │ Step 1 │ │ Step 2 │ │ Action │ │
│ └─────────┘ └────┬────┘ └─────────┘ │
│ │ │
│ ┌──────┴──────┐ │
│ │ Error? │ │
│ └──────┬──────┘ │
│ │ │
│ ▼ │
│ ┌────────────────┐ │
│ │ Continue: │ │
│ │ Error Workflow │ │
│ └────────────────┘ │
└─────────────────────────────────────────────────────────────┘
Error Trigger Node
# Error Workflow Setup
1. Error Trigger Node
- Trigger on: Any Workflow Error
- Include: Full error details
2. Notify Team (Slack/Email)
- Subject: "n8n Workflow Error: {{$json.workflow.name}}"
- Message: "{{$json.execution.error.message}}"
3. Log to Database
- Table: error_logs
- Fields: workflow_id, error_message, timestamp, data
4. Auto-Retry (optional)
- Retry failed execution
Retry Pattern with Error Handling
// Using Error Workflow with Retry
{
"errorWorkflow": "error-handler-main", // Separate error workflow
"continueOnFail": true, // Continue on failure
"retryOnFail": true, // Enable retry
"maxTries": 3, // Max 3 attempts
"wait": 5000 // Wait 5 seconds between tries
}
Good vs Bad Error Handling
// BAD: No error handling
async function badWorkflow() {
const data = await httpRequest();
await processData(data);
await sendNotification();
// If any step fails, entire workflow stops silently
}
// GOOD: Proper error handling
async function goodWorkflow() {
try {
const data = await httpRequest();
await processData(data);
await sendNotification();
} catch (error) {
// Log error details
await logError(error);
// Notify team
await notifyTeam(error);
// Optionally retry
await retryWorkflow();
}
}
Parallel Execution
Running Tasks Concurrently
┌─────────────────┐
│ Trigger │
└────────┬────────┘
│
▼
┌─────────────────────────────────────────────┐
│ Fork Flow │
│ │
│ ┌──────────┐ ┌──────────┐ ┌───────┐ │
│ │ Fetch │ │ Fetch │ │Fetch │ │
│ │ Orders │ │ Customers│ │Products│ │
│ └────┬─────┘ └────┬─────┘ └──┬────┘ │
│ │ │ │ │
│ └───────────────┼──────────────┘ │
│ ▼ │
│ ┌─────────────┐ │
│ │ Merge Data │ │
│ │ (Join All) │ │
│ └─────────────┘ │
└─────────────────────────────────────────────┘
Merge Node Configuration
# Merge Node Options
mergeMode: "manual" # or "pass-through"
joinMode: "inner" # inner, outer, left, right
overlapMode: "prefer1" # prefer1, prefer2, preferBoth
Performance Comparison
| Pattern | Time (100 items) | API Calls |
|---|---|---|
| Sequential | 100 seconds | 100 |
| Parallel (10 concurrent) | 10 seconds | 100 |
| Split in Batches (10) | 11 seconds | 110 |
Sub-workflows
Creating Reusable Workflows
┌─────────────────────────────────────────────┐
│ Main Workflow │
│ │
│ 1. Trigger (Schedule) │
│ 2. Get Data │
│ 3. Execute Sub-workflow │
│ → Transform Data (reusable) │
│ 4. Save Results │
└─────────────────────────────────────────────┘
┌─────────────────────────────────────────────┐
│ Sub-workflow: Transform Data │
│ │
│ 1. Trigger: Workflow Call │
│ 2. Edit Fields (Set) │
│ 3. Rename Keys │
│ 4. Return Data │
└─────────────────────────────────────────────┘
Execute Workflow Node
# Call sub-workflow
{
"workflowId": "workflow_id_here",
"data": {
"input": "{{ $json.data }}",
"mode": "transform"
},
"waitForResponse": true
}
Benefits of Sub-workflows
- Reusability: Use same logic across multiple workflows
- Maintainability: Update in one place
- Testing: Test sub-workflows independently
- Organization: Cleaner main workflows
Waiting and Delays
Wait Node Patterns
# Delayed Processing
1. Receive Order
2. Wait: 24 hours
3. Check Order Status
4. If pending → Send Reminder
# Approval Workflow
1. Receive Request
2. Send Approval Request (Slack)
3. Wait: 48 hours for response
4. Check: Approval Received?
- Yes → Process Request
- No → Escalate or Cancel
Wait Node Configuration
{
"amount": 24, // Wait duration
"unit": "hours", // seconds, minutes, hours, days
"addTimestamp": true // Add wait metadata
}
Combining Patterns
Complete Example: Order Processing Pipeline
# Complete Workflow
1. Webhook Trigger (new order received)
2. Split In Batches (process items)
- Batch size: 5
3. Loop per batch:
a. If item in stock:
- Reserve inventory ✓
b. If item out of stock:
- Continue on fail: true
- Log to "backorder" table
4. Merge results
5. If all items available:
- Calculate shipping
- Create shipment
- Send confirmation email
6. If some items backordered:
- Send partial fulfillment email
- Create follow-up task
7. Error Workflow:
- Log to database
- Send Slack notification
- Retry up to 3 times
Best Practices
Good Patterns
# Good: Clear error handling
- name: "API Call with Error Handling"
nodes:
- HTTP Request
- Error Workflow: "notify-team-on-fail"
- Continue on Fail: false
# Good: Rate limiting
- Split In Batches
batchSize: 10
wait: 1000
# Good: Idempotent operations
- Check if record exists before creating
- Use unique identifiers
Bad Patterns to Avoid
# Bad: No rate limiting
- HTTP Request (1000 calls at once)
# Results: API blocking, IP ban
# Bad: Swallowed errors
- Continue on Fail: true (everywhere)
# Results: Silent failures, data loss
# Bad: Deep nesting
- 10+ levels of If nodes
# Results: Unmaintainable
Debugging Complex Workflows
Using Debug Tools
# Add debug points
1. NoOp (Debug Helper)
- Input: "{{ $json }}"
2. Edit Fields (Debug)
- Add: "{{ $now }}" timestamp
- Add: "{{ $execution.id }}"
3. Filter (for testing)
- Condition: "{{ $json.test === true }}"
Execution Analysis
- Use “All Executions” view to see history
- Check execution time for bottlenecks
- Monitor data transformation at each step
Conclusion
Mastering these advanced patterns will help you build robust, scalable n8n workflows. Start with simple patterns and gradually incorporate more complexity as needed. Remember:
- Always implement error handling from the start
- Use sub-workflows for reusable logic
- Monitor and log everything in production
- Test thoroughly before deploying
Related Articles
- n8n Complete Guide: AI-Powered Workflow Automation
- n8n Self-Hosted Production Guide
- n8n Webhooks and API Integration
Comments