Make Patterns

Advanced patterns for building reliable Make (formerly Integromat) scenarios with routers, iterators, aggregators, and error handling.

---

Scenario architecture

Make scenarios are visual flows of modules connected by routes. Unlike Zapier's linear model, Make supports parallel branches, loops, and error recovery natively.

Key terminology:

• Module - A single operation (API call, transform, filter)
• Route - A connection between modules
• Router - Splits flow into parallel branches with filter conditions
• Scenario - The complete workflow (equivalent to a Zapier "Zap")
• Operation - One module execution (billing unit)

---

Routers

Routers split a single data flow into multiple parallel paths. Each path can have its own filter condition.

Setup:

1. Add a Router module after any step
2. Add routes by clicking the "+" on the router
3. Set filter conditions on each route (or leave one as fallback)
4. Routes execute in order - the first matching route gets the data

Pattern: Priority-based routing

Trigger: New Webhook
  |
  Router
    Route 1 (filter: priority = "critical") -> PagerDuty + Slack #critical
    Route 2 (filter: priority = "high")     -> Slack #support + Jira ticket
    Route 3 (fallback, no filter)           -> Log to Google Sheet

Important: Unlike Zapier Paths, Make routes can each trigger independent sub-flows with their own error handlers.

---

Iterators and aggregators

Iterator

Splits an array into individual items for processing:

Get Spreadsheet Rows -> Iterator -> Process Each Row -> Create CRM Contact

The Iterator takes an array and emits one bundle per item. Every module after the Iterator processes each item independently.

Aggregator

Collects multiple bundles back into a single array:

Iterator -> Transform Each Item -> Array Aggregator -> Send Batch to API

Common aggregator types:

• Array Aggregator - Collects items into an array
• Text Aggregator - Joins items into a string with a separator
• Numeric Aggregator - Sum, average, min, max across items
• Table Aggregator - Creates an HTML or CSV table

Always pair Iterator + Aggregator when you need to process items individually but send the result as a batch. Without the aggregator, downstream modules execute once per item.

---

Data stores

Make's built-in key-value database for persisting state between executions:

Use cases:

• Deduplication: store processed record IDs to skip duplicates
• State tracking: remember the last processed timestamp
• Lookup tables: map codes to human-readable values
• Counters: track how many items have been processed

Operations:

• Add/Replace a record
• Get a record
• Search records
• Delete a record
• Delete all records

Pattern: Deduplication

Webhook Trigger
  -> Data Store: Search for record where key = event_id
  -> Filter: proceed only if record NOT found
  -> Process the event
  -> Data Store: Add record with key = event_id

Data stores have a 1 MB per record limit and a total size limit based on your plan. For large datasets, use an external database instead.

---

Error handling

Make has the most sophisticated error handling of the three major platforms.

Error handler types

Right-click any module > "Add error handler" to attach one:

Handler	Behavior	Use when
Resume	Provides fallback output, continues the scenario	You have a safe default value
Commit	Commits all previous operations, stops scenario	Partial success is acceptable
Rollback	Reverts all operations, stops scenario	All-or-nothing transactions
Break	Stores the bundle for manual retry, stops scenario	You need human review before retry
Ignore	Swallows the error silently, continues	The error is expected and harmless

Error handler pattern

API Call Module
  |-- (success) -> Continue flow
  |-- (error) -> Break handler -> Store failed bundle
                    |-> Slack notification: "Scenario X failed on record Y"

Retry with exponential backoff

Make doesn't have built-in retry with backoff, but you can simulate it:

1. Add a Break error handler to the failing module
2. Configure "Automatically retry" with attempts and interval
3. Set interval to increase: 60s, 300s, 900s

---

Operations optimization

Operations are Make's billing unit. One module execution = one operation.

Reduce operation count:

• Use filters before expensive modules to skip unnecessary processing
• Use "Search" modules instead of "List all + Filter" patterns
• Batch API calls: use bulk endpoints when available
• Set scenario scheduling to match actual data frequency (don't poll every minute if data arrives hourly)
• Use the "Map" function inline instead of adding separate Set Variable modules

Operation counting:

Trigger (1) -> Router -> Route A: 2 modules (2) + Route B: 3 modules (3) = 6 ops per execution
With 100 items through an iterator: 6 x 100 = 600 ops

---

Scenario organization

Naming convention: [Team] - [Source] to [Target] - [Purpose]

• Example: Sales - Typeform to HubSpot - Lead capture
• Example: Ops - Stripe to Sheets - Daily revenue sync

Folder structure:

• Group scenarios by team or business function
• Use color-coded tags for status: green (active), yellow (testing), red (broken)

Documentation:

• Add notes to each module describing what it does and why
• Use the scenario description field for the overall purpose
• Document any non-obvious filter conditions or data mappings

---

Webhook handling

Make provides two webhook trigger types:

Custom Webhook

• Creates a unique URL for receiving arbitrary POST/GET data
• Auto-detects the data structure from the first request
• Can be re-determined if the payload schema changes

App-specific Webhooks

• Pre-built webhook triggers for supported apps
• Handle authentication and payload parsing automatically
• Prefer these over custom webhooks when available

Pattern: Webhook queue processing

Custom Webhook (instant)
  -> Data Store: Add to queue
  -> Response: 200 OK (return immediately)

Scheduled Scenario (every 5 min)
  -> Data Store: Get all queued items
  -> Iterator
  -> Process each item
  -> Data Store: Delete processed item

This pattern decouples receipt from processing, preventing webhook timeouts on heavy operations.

n8n Patterns

Advanced patterns for building n8n workflows, including custom code nodes, credential management, self-hosting considerations, and community nodes.

---

Workflow architecture

n8n workflows are directed graphs of nodes. Each node receives data from its input connections, processes it, and passes output to connected nodes.

Data model:

• Data flows as arrays of JSON objects (called "items")
• Each item has a json property containing the actual data
• Binary data (files, images) is stored in a separate binary property
• Nodes can output to multiple connections (branching)
• Nodes can receive from multiple inputs (merging)

---

Expression syntax

n8n uses a custom expression syntax for referencing data:

// Current node's input data
{{ $json.fieldName }}
{{ $json["field with spaces"] }}

// Nested objects
{{ $json.address.city }}

// Access data from a specific previous node
{{ $node["Node Name"].json.fieldName }}

// Access data from the trigger node
{{ $('Webhook').item.json.body }}

// Access workflow variables
{{ $vars.apiKey }}

// Access environment variables
{{ $env.DATABASE_URL }}

// Built-in functions
{{ $now.toISO() }}
{{ $today.format('yyyy-MM-dd') }}
{{ $json.email.toLowerCase() }}

In n8n v1.0+, use the new expression syntax with $() for node references. The older $node[""] syntax still works but is deprecated.

---

Code node patterns

The Code node lets you write custom JavaScript (or Python in newer versions) for complex transformations.

Transform items

// Code node - Run Once for All Items
const results = [];

for (const item of $input.all()) {
  const name = item.json.fullName.split(' ');
  results.push({
    json: {
      firstName: name[0],
      lastName: name.slice(1).join(' '),
      email: item.json.email.toLowerCase(),
      createdAt: new Date().toISOString()
    }
  });
}

return results;

Filter and enrich

// Code node - Run Once for All Items
const items = $input.all();

return items
  .filter(item => item.json.amount > 100)
  .map(item => ({
    json: {
      ...item.json,
      tier: item.json.amount > 1000 ? 'enterprise' : 'standard',
      formattedAmount: `$${item.json.amount.toFixed(2)}`
    }
  }));

Make HTTP requests in Code node

// Code node - Run Once for All Items
const response = await this.helpers.httpRequest({
  method: 'POST',
  url: 'https://api.example.com/enrich',
  body: {
    emails: $input.all().map(item => item.json.email)
  },
  headers: {
    'Authorization': `Bearer ${$env.API_KEY}`
  }
});

return response.results.map(r => ({ json: r }));

---

Error handling

Error Trigger workflow

Create a separate workflow with an "Error Trigger" node that fires whenever any workflow fails:

Error Trigger -> Set (extract error details) -> Slack (send alert)

The Error Trigger receives:

• execution.id - the failed execution ID
• workflow.id and workflow.name - which workflow failed
• error.message - the error description
• error.node - which node failed

Try/Catch pattern

n8n doesn't have native try/catch, but you can simulate it:

1. Set "Continue On Fail" on the risky node (in node settings)
2. Add an If node after it that checks {{ $json.error }} exists
3. Route errors to a logging/notification path

HTTP Request (Continue On Fail: true)
  -> If: {{ $json.error }} is not empty
    True  -> Log error to Sheet + Slack notification
    False -> Continue normal processing

Retry on failure

Configure retry behavior in node settings:

• Retry On Fail: enable retries for transient errors
• Max Tries: number of retry attempts (default: 3)
• Wait Between Tries: milliseconds between retries

---

Self-hosting

n8n can be self-hosted for full data control and no per-execution costs.

Docker deployment

# docker-compose.yml
version: '3.8'
services:
  n8n:
    image: n8nio/n8n:latest
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=${N8N_PASSWORD}
      - N8N_HOST=n8n.yourdomain.com
      - N8N_PROTOCOL=https
      - WEBHOOK_URL=https://n8n.yourdomain.com/
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=n8n
      - DB_POSTGRESDB_PASSWORD=${DB_PASSWORD}
      - EXECUTIONS_DATA_PRUNE=true
      - EXECUTIONS_DATA_MAX_AGE=168  # hours
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      - postgres

  postgres:
    image: postgres:15
    environment:
      - POSTGRES_DB=n8n
      - POSTGRES_USER=n8n
      - POSTGRES_PASSWORD=${DB_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  n8n_data:
  postgres_data:

Key self-hosting considerations

• Database: Use PostgreSQL for production. SQLite (default) is fine for testing but doesn't handle concurrent executions well.
• Execution data: Enable pruning (EXECUTIONS_DATA_PRUNE=true) to prevent the database from growing indefinitely. Keep 7 days (168 hours) of history.
• Webhook URL: Must be set to the public URL so webhook triggers work. Without this, webhooks will use localhost and fail.
• Scaling: n8n runs single-threaded by default. For high throughput, use n8n's queue mode with Redis and multiple worker instances.
• Backups: Export workflows as JSON regularly. Also back up the PostgreSQL database for credentials and execution history.

---

Credential management

n8n stores credentials encrypted in the database.

Best practices:

• Use environment variables for sensitive values: {{ $env.API_KEY }}
• In self-hosted setups, mount credentials via Docker secrets or environment files
• Never hardcode credentials in Code nodes
• Use n8n's built-in credential types when available (they handle token refresh)

Custom credentials for internal APIs:

1. Go to Credentials > Add Credential > Header Auth
2. Set the header name (e.g., Authorization) and value
3. Reference this credential in HTTP Request nodes

---

Community nodes

n8n has a community node ecosystem for apps without official support:

Installing community nodes:

1. Go to Settings > Community Nodes
2. Enter the npm package name (e.g., n8n-nodes-notion-enhanced)
3. Click Install
4. The node appears in the node palette

Cautions:

• Community nodes are not vetted by n8n - review the source code first
• They may break on n8n version upgrades
• For production workflows, prefer official nodes or HTTP Request nodes
• Pin the community node version to prevent unexpected updates

---

Workflow organization

Naming convention: [Category] [Source] to [Target] - [Purpose]

• Example: [Sales] Webhook to CRM - Lead capture
• Example: [Ops] Cron DB cleanup - Daily

Tags:

• Use tags to categorize: production, staging, deprecated, experimental
• Tag by team: engineering, sales, marketing, ops

Sub-workflows:

• Use the "Execute Workflow" node to call other workflows
• This enables reuse: build a "Send Slack Alert" workflow once, call it from many
• Pass data via the workflow input and return via the workflow output node

Version control:

• Export workflows as JSON and commit to git
• Use n8n's API to automate exports: GET /api/v1/workflows
• For teams, use the n8n CLI: n8n export:workflow --all --output=./workflows/

Zapier Patterns

Advanced patterns for building reliable, maintainable Zapier automations beyond simple two-step Zaps.

---

Multi-step Zaps

Chain multiple actions in sequence. Each step can reference data from any previous step using the data picker.

Best practices:

• Keep Zaps under 10 steps. Beyond that, split into separate Zaps connected via Webhooks by Zapier.
• Name each step descriptively: "Create HubSpot Contact" not "Action 3"
• Test each step individually before testing the full Zap

---

Paths (conditional branching)

Paths split a Zap into multiple branches based on conditions. Each path has its own set of filter rules and actions.

When to use Paths:

• Route data to different destinations based on a field value
• Apply different transformations based on record type
• Send different notifications based on priority level

Limitations:

• Maximum 3 paths per Paths step (use nested Paths for more)
• Each path counts as a separate task when it executes
• You cannot merge paths back together - each path ends independently

Example: Route support tickets

Trigger: New Zendesk Ticket
  Path A (Priority: Urgent) -> Create PagerDuty Incident + Slack #urgent
  Path B (Priority: High)   -> Slack #support-high + Assign to senior agent
  Path C (Default)           -> Add to support queue spreadsheet

---

Formatter by Zapier

Built-in data transformation utilities. Use these instead of Code steps for simple transformations:

Formatter	Use case
Text - Split	Split "John Doe" into first and last name
Text - Replace	Clean up phone number formatting
Text - Truncate	Shorten descriptions for Slack messages
Numbers - Spreadsheet formula	Basic math operations
Date/Time - Format	Convert between date formats
Date/Time - Add/Subtract	Calculate due dates
Utilities - Lookup Table	Map values (e.g., country code -> country name)
Utilities - Line Item to Text	Convert arrays to comma-separated strings

Formatter steps are free - they don't count toward your task limit.

---

Webhooks by Zapier

Two powerful modules for custom integrations:

Catch Hook (trigger)

Creates a unique webhook URL that triggers the Zap when it receives a POST/GET request. Use this when the source app doesn't have a native Zapier integration.

• The URL is unique per Zap and persistent
• Supports JSON, form-encoded, and XML payloads
• First request sets the sample data structure

Send Hook (action)

Makes an HTTP request to any URL. Use this to call APIs that don't have native Zapier integrations.

• Supports GET, POST, PUT, PATCH, DELETE
• Custom headers for authentication
• JSON or form-encoded body

Pattern: Connect two Zaps Use Catch Hook + Send Hook to chain Zaps:

Zap 1: Trigger -> Process -> Webhooks: POST to Zap 2's Catch Hook URL
Zap 2: Catch Hook -> More processing -> Final action

---

Code by Zapier

Execute custom JavaScript for transformations too complex for Formatter:

// Code by Zapier - JavaScript
// Input variables are available as inputData object
const name = inputData.fullName.split(' ');
const amount = parseFloat(inputData.amount);

output = [{
  firstName: name[0],
  lastName: name.slice(1).join(' '),
  amountInCents: Math.round(amount * 100),
  isHighValue: amount > 1000
}];

Constraints:

• JavaScript only (no Python)
• 1 second execution time limit
• 128 MB memory limit
• No external HTTP requests (use Webhooks step instead)
• Must return an array of objects via the output variable
• Can use fetch via the async code variant for HTTP calls

---

Error handling patterns

Zapier's error handling is limited compared to Make or n8n:

1. Auto-replay - Zapier can auto-replay failed tasks. Enable in Zap settings. It retries every 10 minutes for up to 3 days.
2. Error notification - Set up a Zapier Manager alert to get emailed when any Zap errors. Or create a separate Zap: "Error in Zapier" trigger.
3. Defensive Formatter steps - Add a Formatter "Utilities: Default Value" step before actions that might receive null values.
4. Filter as guard - Add Filter steps to skip records that would cause downstream errors (empty emails, invalid formats, etc.).

---

Task optimization

Tasks are Zapier's billing unit. One task = one successful action step execution.

Reduce task consumption:

• Use Filter steps to skip unnecessary executions (filters are free)
• Use Formatter steps for transforms (formatters are free)
• Batch operations: use "Find or Create" actions instead of separate find + create
• Use Digest by Zapier to batch multiple triggers into a single execution
• Prefer Zap-level throttling over per-step delays

Typical monthly usage by company size:

• Small team (5 people, 10 automations): 2,000-5,000 tasks/month
• Mid-size (20 people, 30 automations): 10,000-25,000 tasks/month
• Growth (50+ people, 100+ automations): 50,000+ tasks/month