1
{
2
  "name": "Customer Onboarding Automation",
3
  "nodes": [
4
    {
5
      "parameters": {
6
        "httpMethod": "POST",
7
        "path": "webhook/customer-signup"
8
      },
9
      "name": "Webhook",
10
      "type": "n8n-nodes-base.webhook",
11
      "position": [250, 300]
12
    },
13
    {
14
      "parameters": {
15
        "operation": "create",
16
        "resource": "contact"
17
      },
18
      "name": "Create CRM Contact",
19
      "type": "n8n-nodes-base.hubspot",
20
      "position": [450, 300]
21
    }
22
  ]
23
}

1
// Example credential configuration
2
{
3
  "name": "My API Credentials",
4
  "type": "apiKey",
5
  "data": {
6
    "apiKey": "{{$env.API_KEY}}",
7
    "domain": "api.example.com"
8
  }
9
}

1
{
2
  "name": "E-commerce Order Processing",
3
  "nodes": [
4
    {
5
      "name": "New Order Trigger",
6
      "type": "n8n-nodes-base.shopify",
7
      "parameters": {
8
        "event": "order/created",
9
        "operation": "trigger"
10
      }
11
    },
12
    {
13
      "name": "Update Inventory",
14
      "type": "n8n-nodes-base.postgres",
15
      "parameters": {
16
        "operation": "update",
17
        "table": "inventory",
18
        "updateKey": "sku",
19
        "columns": "quantity"
20
      }
21
    },
22
    {
23
      "name": "Send Order Confirmation",
24
      "type": "n8n-nodes-base.emailSend",
25
      "parameters": {
26
        "toEmail": "={{$json.customer.email}}",
27
        "subject": "Order #{{$json.order_number}} Confirmed",
28
        "html": true,
29
        "htmlTemplate": "order-confirmation.html"
30
      }
31
    },
32
    {
33
      "name": "Create Shipping Label",
34
      "type": "n8n-nodes-base.shipStation",
35
      "parameters": {
36
        "operation": "createLabel",
37
        "orderId": "={{$json.id}}"
38
      }
39
    },
40
    {
41
      "name": "Notify Warehouse",
42
      "type": "n8n-nodes-base.slack",
43
      "parameters": {
44
        "channel": "#warehouse",
45
        "text": "New order ready for fulfillment: #{{$json.order_number}}"
46
      }
47
    }
48
  ]
49
}

1
// Ticket Classification Workflow
2
const ticketWorkflow = {
3
  trigger: {
4
    type: "webhook",
5
    path: "/support/new-ticket"
6
  },
7

8
  classification: {
9
    type: "function",
10
    code: `
11
      const ticket = $input.item.json;
12
      const keywords = {
13
        billing: ['payment', 'invoice', 'charge', 'refund'],
14
        technical: ['bug', 'error', 'crash', 'not working'],
15
        feature: ['request', 'suggestion', 'enhancement']
16
      };
17

18
      for (const [category, words] of Object.entries(keywords)) {
19
        if (words.some(word =>
20
          ticket.description.toLowerCase().includes(word)
21
        )) {
22
          return { category, priority: calculatePriority(ticket) };
23
        }
24
      }
25
      return { category: 'general', priority: 'normal' };
26
    `
27
  },
28

29
  routing: {
30
    type: "switch",
31
    rules: [
32
      { when: "category == 'billing'", output: "billing_team" },
33
      { when: "category == 'technical'", output: "tech_team" },
34
      { when: "priority == 'high'", output: "escalation" }
35
    ]
36
  }
37
};

1
{
2
  "name": "ETL Data Pipeline",
3
  "nodes": [
4
    {
5
      "name": "Schedule Trigger",
6
      "type": "n8n-nodes-base.cron",
7
      "parameters": {
8
        "cronExpression": "0 2 * * *"
9
      }
10
    },
11
    {
12
      "name": "Extract from API",
13
      "type": "n8n-nodes-base.httpRequest",
14
      "parameters": {
15
        "url": "https://api.datasource.com/data",
16
        "method": "GET",
17
        "authentication": "predefinedCredentialType",
18
        "nodeCredentialType": "apiKey"
19
      }
20
    },
21
    {
22
      "name": "Extract from Database",
23
      "type": "n8n-nodes-base.postgres",
24
      "parameters": {
25
        "operation": "executeQuery",
26
        "query": "SELECT * FROM transactions WHERE date >= NOW() - INTERVAL '24 hours'"
27
      }
28
    },
29
    {
30
      "name": "Merge Data",
31
      "type": "n8n-nodes-base.merge",
32
      "parameters": {
33
        "mode": "combine",
34
        "combinationMode": "mergeByPosition"
35
      }
36
    },
37
    {
38
      "name": "Transform Data",
39
      "type": "n8n-nodes-base.function",
40
      "parameters": {
41
        "functionCode": `
42
          return items.map(item => ({
43
            json: {
44
              id: item.json.id,
45
              timestamp: new Date(item.json.date).toISOString(),
46
              amount: parseFloat(item.json.amount),
47
              category: item.json.type.toLowerCase(),
48
              source: item.json.source || 'unknown'
49
            }
50
          }));
51
        `
52
      }
53
    },
54
    {
55
      "name": "Load to Warehouse",
56
      "type": "n8n-nodes-base.snowflake",
57
      "parameters": {
58
        "operation": "insert",
59
        "table": "fact_transactions",
60
        "columns": "id,timestamp,amount,category,source"
61
      }
62
    }
63
  ]
64
}

1
// Robust error handling pattern
2
const errorHandlingWorkflow = {
3
  mainFlow: {
4
    onError: "continue",
5
    retryOnFail: true,
6
    maxTries: 3,
7
    waitBetweenTries: 5000
8
  },
9

10
  errorHandler: {
11
    type: "errorTrigger",
12
    actions: [
13
      {
14
        type: "function",
15
        code: `
16
          const error = $input.item.error;
17
          const context = $input.item.json;
18

19
          // Log error details
20
          console.error('Workflow error:', {
21
            message: error.message,
22
            node: error.node,
23
            timestamp: new Date().toISOString(),
24
            context
25
          });
26

27
          // Determine if recoverable
28
          const recoverableErrors = ['TIMEOUT', 'RATE_LIMIT', 'TEMPORARY'];
29
          const isRecoverable = recoverableErrors.some(type =>
30
            error.message.includes(type)
31
          );
32

33
          return {
34
            json: {
35
              shouldRetry: isRecoverable,
36
              errorType: error.name,
37
              nextAction: isRecoverable ? 'retry' : 'alert'
38
            }
39
          };
40
        `
41
      }
42
    ]
43
  }
44
};

1
{
2
  "name": "Parallel Data Processing",
3
  "nodes": [
4
    {
5
      "name": "Split Into Batches",
6
      "type": "n8n-nodes-base.splitInBatches",
7
      "parameters": {
8
        "batchSize": 100
9
      }
10
    },
11
    {
12
      "name": "Process Batch 1",
13
      "type": "n8n-nodes-base.function",
14
      "parameters": {
15
        "functionCode": "// Process first batch"
16
      }
17
    },
18
    {
19
      "name": "Process Batch 2",
20
      "type": "n8n-nodes-base.function",
21
      "parameters": {
22
        "functionCode": "// Process second batch"
23
      }
24
    },
25
    {
26
      "name": "Wait for All",
27
      "type": "n8n-nodes-base.wait",
28
      "parameters": {
29
        "resume": "webhook",
30
        "options": {
31
          "waitForAllWebhooks": true
32
        }
33
      }
34
    }
35
  ]
36
}

1
// Complex conditional logic
2
const conditionalWorkflow = {
3
  decisionNode: {
4
    type: "switch",
5
    parameters: {
6
      dataType: "expression",
7
      value1: "={{$json.customer.tier}}",
8
      rules: [
9
        {
10
          value2: "enterprise",
11
          output: "enterpriseFlow"
12
        },
13
        {
14
          value2: "premium",
15
          output: "premiumFlow"
16
        },
17
        {
18
          value2: "standard",
19
          output: "standardFlow"
20
        }
21
      ],
22
      fallbackOutput: "defaultFlow"
23
    }
24
  },
25

26
  enterpriseFlow: {
27
    nodes: [
28
      { type: "dedicatedSupport" },
29
      { type: "priorityProcessing" },
30
      { type: "customIntegration" }
31
    ]
32
  },
33

34
  premiumFlow: {
35
    nodes: [
36
      { type: "fastProcessing" },
37
      { type: "emailSupport" }
38
    ]
39
  }
40
};

1
// Optimize API calls with batching
2
const batchProcessor = {
3
  accumulator: [],
4
  batchSize: 50,
5

6
  process: async function(items) {
7
    // Accumulate items
8
    this.accumulator.push(...items);
9

10
    // Process when batch is full
11
    if (this.accumulator.length >= this.batchSize) {
12
      const batch = this.accumulator.splice(0, this.batchSize);
13
      await this.processBatch(batch);
14
    }
15
  },
16

17
  processBatch: async function(batch) {
18
    // Single API call for entire batch
19
    const response = await api.bulkCreate(batch);
20
    return response;
21
  }
22
};

1
// Implement caching for expensive operations
2
const cacheNode = {
3
  type: "function",
4
  code: `
5
    const cacheKey = $input.item.json.id;
6
    const cached = await $getWorkflowStaticData(cacheKey);
7

8
    if (cached && cached.timestamp > Date.now() - 3600000) {
9
      return { json: cached.data };
10
    }
11

12
    // Expensive operation
13
    const result = await expensiveOperation($input.item.json);
14

15
    // Cache result
16
    await $setWorkflowStaticData(cacheKey, {
17
      data: result,
18
      timestamp: Date.now()
19
    });
20

21
    return { json: result };
22
  `
23
};

1
// Secure credential handling
2
const secureCredentials = {
3
  // Never hardcode credentials
4
  badPractice: {
5
    apiKey: "sk_live_abcd1234" // DON'T DO THIS
6
  },
7

8
  // Use environment variables
9
  goodPractice: {
10
    apiKey: process.env.API_KEY,
11
    endpoint: process.env.API_ENDPOINT
12
  },
13

14
  // Use n8n credential system
15
  bestPractice: {
16
    type: "n8n-nodes-base.apiKeyAuth",
17
    credentials: {
18
      name: "myApiCredentials",
19
      type: "apiKey"
20
    }
21
  }
22
};

1
// Validate and sanitize inputs
2
const validationNode = {
3
  type: "function",
4
  code: `
5
    const input = $input.item.json;
6
    const errors = [];
7

8
    // Validate email
9
    if (!input.email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(input.email)) {
10
      errors.push('Invalid email format');
11
    }
12

13
    // Validate required fields
14
    const required = ['name', 'email', 'orderId'];
15
    for (const field of required) {
16
      if (!input[field]) {
17
        errors.push(\`Missing required field: \${field}\`);
18
      }
19
    }
20

21
    // Sanitize inputs
22
    const sanitized = {
23
      name: input.name.trim().replace(/<script>/gi, ''),
24
      email: input.email.toLowerCase().trim(),
25
      orderId: parseInt(input.orderId, 10)
26
    };
27

28
    if (errors.length > 0) {
29
      throw new Error(\`Validation failed: \${errors.join(', ')}\`);
30
    }
31

32
    return { json: sanitized };
33
  `
34
};

1
// Track workflow performance
2
const metricsCollector = {
3
  startTime: Date.now(),
4

5
  collectMetrics: function() {
6
    return {
7
      executionTime: Date.now() - this.startTime,
8
      nodesExecuted: $workflow.nodes.length,
9
      itemsProcessed: $items.length,
10
      timestamp: new Date().toISOString(),
11
      workflowId: $workflow.id,
12
      status: $execution.status
13
    };
14
  },
15

16
  sendToMonitoring: async function(metrics) {
17
    await $http.post('https://monitoring.example.com/metrics', {
18
      body: metrics,
19
      headers: {
20
        'Content-Type': 'application/json'
21
      }
22
    });
23
  }
24
};

1
{
2
  "name": "Workflow Monitoring Alert",
3
  "nodes": [
4
    {
5
      "name": "Check Workflow Status",
6
      "type": "n8n-nodes-base.function",
7
      "parameters": {
8
        "functionCode": `
9
          const failures = await getFailedWorkflows();
10
          if (failures.length > 5) {
11
            return {
12
              json: {
13
                alert: true,
14
                severity: 'high',
15
                message: \`\${failures.length} workflows failed in last hour\`,
16
                workflows: failures
17
              }
18
            };
19
          }
20
        `
21
      }
22
    },
23
    {
24
      "name": "Send Alert",
25
      "type": "n8n-nodes-base.slack",
26
      "parameters": {
27
        "channel": "#alerts",
28
        "text": ":warning: {{$json.message}}",
29
        "attachments": [{
30
          "color": "danger",
31
          "fields": [{
32
            "title": "Failed Workflows",
33
            "value": "{{$json.workflows}}"
34
          }]
35
        }]
36
      }
37
    }
38
  ]
39
}

1
# docker-compose.yml for n8n deployment
2
version: '3.8'
3

4
services:
5
  n8n:
6
    image: n8nio/n8n:latest
7
    restart: always
8
    ports:
9
      - "5678:5678"
10
    environment:
11
      - N8N_BASIC_AUTH_ACTIVE=true
12
      - N8N_BASIC_AUTH_USER=${N8N_USER}
13
      - N8N_BASIC_AUTH_PASSWORD=${N8N_PASSWORD}
14
      - N8N_HOST=${N8N_HOST}
15
      - N8N_PORT=5678
16
      - N8N_PROTOCOL=https
17
      - NODE_ENV=production
18
      - WEBHOOK_URL=${WEBHOOK_URL}
19
      - DB_TYPE=postgresdb
20
      - DB_POSTGRESDB_HOST=postgres
21
      - DB_POSTGRESDB_PORT=5432
22
      - DB_POSTGRESDB_DATABASE=${POSTGRES_DB}
23
      - DB_POSTGRESDB_USER=${POSTGRES_USER}
24
      - DB_POSTGRESDB_PASSWORD=${POSTGRES_PASSWORD}
25
    volumes:
26
      - n8n_data:/home/node/.n8n
27
      - ./workflows:/workflows
28
    depends_on:
29
      - postgres
30
    networks:
31
      - n8n-network
32

33
  postgres:
34
    image: postgres:13
35
    restart: always
36
    environment:
37
      - POSTGRES_USER=${POSTGRES_USER}
38
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
39
      - POSTGRES_DB=${POSTGRES_DB}
40
    volumes:
41
      - postgres_data:/var/lib/postgresql/data
42
    networks:
43
      - n8n-network
44

45
volumes:
46
  n8n_data:
47
  postgres_data:
48

49
networks:
50
  n8n-network:
51
    driver: bridge

1
// Configure n8n for queue mode (high availability)
2
const queueModeConfig = {
3
  main: {
4
    // Main instance handles UI and workflow management
5
    role: "main",
6
    config: {
7
      EXECUTIONS_MODE: "queue",
8
      QUEUE_BULL_REDIS_HOST: "redis.example.com",
9
      QUEUE_BULL_REDIS_PORT: 6379,
10
      QUEUE_HEALTH_CHECK_ACTIVE: true
11
    }
12
  },
13

14
  worker: {
15
    // Worker instances execute workflows
16
    role: "worker",
17
    config: {
18
      EXECUTIONS_MODE: "queue",
19
      QUEUE_BULL_REDIS_HOST: "redis.example.com",
20
      N8N_DISABLE_UI: true,
21
      N8N_WORKER_CONCURRENCY: 10
22
    }
23
  }
24
};

1
# nginx.conf for n8n load balancing
2
upstream n8n_backend {
3
    least_conn;
4
    server n8n-main-1:5678 weight=1;
5
    server n8n-main-2:5678 weight=1;
6
    server n8n-main-3:5678 weight=1;
7
}
8

9
server {
10
    listen 443 ssl http2;
11
    server_name n8n.example.com;
12

13
    ssl_certificate /etc/ssl/certs/n8n.crt;
14
    ssl_certificate_key /etc/ssl/private/n8n.key;
15

16
    location / {
17
        proxy_pass http://n8n_backend;
18
        proxy_http_version 1.1;
19
        proxy_set_header Upgrade $http_upgrade;
20
        proxy_set_header Connection "upgrade";
21
        proxy_set_header Host $host;
22
        proxy_set_header X-Real-IP $remote_addr;
23
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
24
        proxy_set_header X-Forwarded-Proto $scheme;
25

26
        # WebSocket support
27
        proxy_read_timeout 86400;
28
    }
29

30
    location /webhook/ {
31
        proxy_pass http://n8n_backend;
32
        proxy_http_version 1.1;
33
        proxy_set_header Host $host;
34
        proxy_buffering off;
35
        proxy_cache off;
36
    }
37
}

1
// Service mesh integration pattern
2
const microserviceIntegration = {
3
  serviceRegistry: {
4
    services: [
5
      { name: "user-service", endpoint: "http://users.svc:8080" },
6
      { name: "order-service", endpoint: "http://orders.svc:8080" },
7
      { name: "inventory-service", endpoint: "http://inventory.svc:8080" }
8
    ]
9
  },
10

11
  orchestrator: {
12
    type: "function",
13
    code: `
14
      // Service discovery
15
      const service = serviceRegistry.services.find(
16
        s => s.name === $input.item.json.targetService
17
      );
18

19
      if (!service) {
20
        throw new Error(\`Service not found: \${$input.item.json.targetService}\`);
21
      }
22

23
      // Circuit breaker pattern
24
      const circuitBreaker = {
25
        failureThreshold: 5,
26
        timeout: 30000,
27
        resetTimeout: 60000
28
      };
29

30
      try {
31
        const response = await $http.request({
32
          method: $input.item.json.method,
33
          url: \`\${service.endpoint}\${$input.item.json.path}\`,
34
          body: $input.item.json.body,
35
          timeout: circuitBreaker.timeout
36
        });
37

38
        return { json: response.data };
39
      } catch (error) {
40
        // Handle circuit breaker logic
41
        if (circuitBreaker.isOpen) {
42
          throw new Error('Circuit breaker is open');
43
        }
44
        throw error;
45
      }
46
    `
47
  }
48
};

1
{
2
  "name": "Event Bus Integration",
3
  "nodes": [
4
    {
5
      "name": "Kafka Consumer",
6
      "type": "n8n-nodes-base.kafka",
7
      "parameters": {
8
        "topic": "order-events",
9
        "groupId": "n8n-consumer-group",
10
        "autoCommit": true
11
      }
12
    },
13
    {
14
      "name": "Event Router",
15
      "type": "n8n-nodes-base.switch",
16
      "parameters": {
17
        "dataType": "expression",
18
        "value1": "={{$json.eventType}}",
19
        "rules": [
20
          {
21
            "value2": "order.created",
22
            "output": "orderCreatedHandler"
23
          },
24
          {
25
            "value2": "order.updated",
26
            "output": "orderUpdatedHandler"
27
          },
28
          {
29
            "value2": "order.cancelled",
30
            "output": "orderCancelledHandler"
31
          }
32
        ]
33
      }
34
    },
35
    {
36
      "name": "Publish Processed Event",
37
      "type": "n8n-nodes-base.kafka",
38
      "parameters": {
39
        "operation": "produce",
40
        "topic": "processed-events",
41
        "message": "={{JSON.stringify($json)}}"
42
      }
43
    }
44
  ]
45
}

1
// Automated workflow testing
2
const workflowTest = {
3
  setup: async function() {
4
    // Initialize test environment
5
    this.testData = {
6
      input: { id: 1, name: "Test User", email: "test@example.com" },
7
      expectedOutput: { status: "success", userId: 1 }
8
    };
9
  },
10

11
  test: async function(workflowId) {
12
    const execution = await n8n.workflow.execute(workflowId, {
13
      data: this.testData.input,
14
      mode: 'test'
15
    });
16

17
    // Assert output
18
    assert.deepEqual(execution.data, this.testData.expectedOutput);
19

20
    // Verify side effects
21
    const dbRecord = await db.query('SELECT * FROM users WHERE id = ?', [1]);
22
    assert.equal(dbRecord.email, this.testData.input.email);
23
  },
24

25
  teardown: async function() {
26
    // Clean up test data
27
    await db.query('DELETE FROM users WHERE email LIKE ?', ['test@%']);
28
  }
29
};

1
// Load testing workflows
2
const performanceTest = {
3
  concurrent: 100,
4
  duration: 60000, // 1 minute
5

6
  runTest: async function(workflowId) {
7
    const results = [];
8
    const startTime = Date.now();
9

10
    // Generate load
11
    const promises = Array(this.concurrent).fill().map(async (_, i) => {
12
      const execStart = Date.now();
13
      try {
14
        await n8n.workflow.execute(workflowId, {
15
          data: { testId: i }
16
        });
17
        return {
18
          success: true,
19
          duration: Date.now() - execStart
20
        };
21
      } catch (error) {
22
        return {
23
          success: false,
24
          error: error.message,
25
          duration: Date.now() - execStart
26
        };
27
      }
28
    });
29

30
    const executions = await Promise.all(promises);
31

32
    // Calculate metrics
33
    const metrics = {
34
      totalExecutions: executions.length,
35
      successfulExecutions: executions.filter(e => e.success).length,
36
      failedExecutions: executions.filter(e => !e.success).length,
37
      averageDuration: executions.reduce((sum, e) => sum + e.duration, 0) / executions.length,
38
      maxDuration: Math.max(...executions.map(e => e.duration)),
39
      minDuration: Math.min(...executions.map(e => e.duration)),
40
      throughput: executions.length / ((Date.now() - startTime) / 1000)
41
    };
42

43
    return metrics;
44
  }
45
};

1
// Optimize memory usage in large data processing
2
const memoryOptimization = {
3
  streamProcessing: {
4
    type: "function",
5
    code: `
6
      // Process items in chunks to avoid memory overflow
7
      const chunkSize = 100;
8
      const results = [];
9

10
      for (let i = 0; i < $items.length; i += chunkSize) {
11
        const chunk = $items.slice(i, i + chunkSize);
12

13
        // Process chunk
14
        const processed = chunk.map(item => {
15
          // Heavy processing
16
          return processItem(item);
17
        });
18

19
        // Store results and free memory
20
        results.push(...processed);
21

22
        // Force garbage collection hint
23
        if (global.gc) {
24
          global.gc();
25
        }
26
      }
27

28
      return results;
29
    `
30
  }
31
};

1
// Enhanced debugging utilities
2
const debugHelper = {
3
  logNode: {
4
    type: "function",
5
    code: `
6
      console.log('=== Debug Information ===');
7
      console.log('Node:', $node.name);
8
      console.log('Execution ID:', $execution.id);
9
      console.log('Workflow:', $workflow.name);
10
      console.log('Items count:', $items.length);
11
      console.log('First item:', JSON.stringify($items[0], null, 2));
12
      console.log('Environment:', $env);
13
      console.log('======================');
14

15
      // Pass through items unchanged
16
      return $items;
17
    `
18
  },
19

20
  breakpoint: {
21
    type: "function",
22
    code: `
23
      // Conditional breakpoint
24
      if ($json.debug === true) {
25
        debugger; // Will pause execution in debug mode
26
      }
27
      return $items;
28
    `
29
  }
30
};