1
// Environment variables for production
2
const config = {
3
  // Security
4
  N8N_BASIC_AUTH_ACTIVE: true,
5
  N8N_BASIC_AUTH_USER: process.env.ADMIN_USER,
6
  N8N_BASIC_AUTH_PASSWORD: process.env.ADMIN_PASSWORD,
7
  N8N_ENCRYPTION_KEY: process.env.ENCRYPTION_KEY,
8

9
  // Database
10
  DB_TYPE: 'postgresdb',
11
  DB_POSTGRESDB_HOST: process.env.DB_HOST,
12
  DB_POSTGRESDB_PORT: 5432,
13
  DB_POSTGRESDB_DATABASE: 'n8n',
14
  DB_POSTGRESDB_USER: process.env.DB_USER,
15
  DB_POSTGRESDB_PASSWORD: process.env.DB_PASSWORD,
16

17
  // Webhook URL
18
  WEBHOOK_URL: 'https://your-domain.com',
19
  N8N_PROTOCOL: 'https',
20
  N8N_HOST: 'your-domain.com',
21

22
  // Execution
23
  EXECUTIONS_PROCESS: 'main',
24
  EXECUTIONS_TIMEOUT: 3600,
25
  EXECUTIONS_TIMEOUT_MAX: 7200,
26

27
  // Queue (for scaling)
28
  QUEUE_BULL_REDIS_HOST: process.env.REDIS_HOST,
29
  QUEUE_BULL_REDIS_PORT: 6379
30
};

1
// Node types and their purposes
2
const nodeTypes = {
3
  trigger: {
4
    description: "Start workflows based on events",
5
    examples: ["Webhook", "Cron", "Email Trigger", "Slack Trigger"]
6
  },
7

8
  action: {
9
    description: "Perform operations on external services",
10
    examples: ["HTTP Request", "Database", "Send Email", "Slack Message"]
11
  },
12

13
  transform: {
14
    description: "Manipulate and transform data",
15
    examples: ["Set", "Function", "Merge", "Split In Batches"]
16
  },
17

18
  flow: {
19
    description: "Control workflow execution flow",
20
    examples: ["IF", "Switch", "Loop", "Wait"]
21
  }
22
};

1
// Example: Email notification workflow
2
const emailNotificationWorkflow = {
3
  name: "Email Notification System",
4
  nodes: [
5
    {
6
      name: "Webhook Trigger",
7
      type: "n8n-nodes-base.webhook",
8
      parameters: {
9
        path: "notify",
10
        responseMode: "onReceived",
11
        responseData: "allEntries"
12
      }
13
    },
14
    {
15
      name: "Validate Data",
16
      type: "n8n-nodes-base.function",
17
      parameters: {
18
        functionCode: `
19
          const requiredFields = ['email', 'subject', 'message'];
20
          const data = items[0].json;
21

22
          for (const field of requiredFields) {
23
            if (!data[field]) {
24
              throw new Error(\`Missing required field: \${field}\`);
25
            }
26
          }
27

28
          // Email validation
29
          const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
30
          if (!emailRegex.test(data.email)) {
31
            throw new Error('Invalid email address');
32
          }
33

34
          return items;
35
        `
36
      }
37
    },
38
    {
39
      name: "Send Email",
40
      type: "n8n-nodes-base.emailSend",
41
      parameters: {
42
        fromEmail: "noreply@company.com",
43
        toEmail: "={{$json.email}}",
44
        subject: "={{$json.subject}}",
45
        text: "={{$json.message}}",
46
        html: "<h2>{{$json.subject}}</h2><p>{{$json.message}}</p>"
47
      }
48
    }
49
  ]
50
};

1
// Robust error handling pattern
2
const errorHandlingPattern = {
3
  name: "Error Handling Pattern",
4

5
  implementation: `
6
    // Main workflow with try-catch
7
    try {
8
      // Your main logic here
9
      const result = await processData($input.all());
10
      return result;
11

12
    } catch (error) {
13
      // Log error
14
      await $workflow.webhook('error-logger', {
15
        error: error.message,
16
        stack: error.stack,
17
        input: $input.all(),
18
        timestamp: new Date().toISOString()
19
      });
20

21
      // Retry logic
22
      const maxRetries = 3;
23
      const retryCount = $node["Retry Counter"].json.count || 0;
24

25
      if (retryCount < maxRetries) {
26
        // Exponential backoff
27
        const delay = Math.pow(2, retryCount) * 1000;
28
        await new Promise(resolve => setTimeout(resolve, delay));
29

30
        // Increment retry counter
31
        $node["Retry Counter"].json.count = retryCount + 1;
32

33
        // Retry
34
        return $workflow.execute('self');
35
      }
36

37
      // Max retries reached - send to dead letter queue
38
      await $workflow.webhook('dead-letter-queue', {
39
        error: error.message,
40
        data: $input.all(),
41
        retries: retryCount
42
      });
43

44
      throw error;
45
    }
46
  `
47
};

1
// Parallel execution pattern
2
const parallelProcessingPattern = {
3
  name: "Parallel Processing Pattern",
4

5
  nodes: [
6
    {
7
      name: "Split Data",
8
      type: "n8n-nodes-base.splitInBatches",
9
      parameters: {
10
        batchSize: 10
11
      }
12
    },
13
    {
14
      name: "Process Batch",
15
      type: "n8n-nodes-base.function",
16
      parameters: {
17
        functionCode: `
18
          // Process items in parallel
19
          const promises = items.map(async (item) => {
20
            return await processItem(item.json);
21
          });
22

23
          const results = await Promise.all(promises);
24

25
          return results.map(result => ({
26
            json: result
27
          }));
28
        `
29
      }
30
    },
31
    {
32
      name: "Merge Results",
33
      type: "n8n-nodes-base.merge",
34
      parameters: {
35
        mode: "multiplex"
36
      }
37
    }
38
  ]
39
};

1
// Dynamic routing based on conditions
2
const conditionalRoutingPattern = {
3
  name: "Conditional Routing Pattern",
4

5
  implementation: `
6
    // Router function
7
    const route = (data) => {
8
      const routes = {
9
        'high_priority': data.priority > 7,
10
        'customer_issue': data.type === 'support',
11
        'sales_lead': data.type === 'sales' && data.value > 1000,
12
        'default': true
13
      };
14

15
      for (const [route, condition] of Object.entries(routes)) {
16
        if (condition) {
17
          return route;
18
        }
19
      }
20
    };
21

22
    const routeName = route($input.first().json);
23

24
    // Execute specific workflow based on route
25
    switch(routeName) {
26
      case 'high_priority':
27
        return $workflow.execute('high-priority-handler');
28
      case 'customer_issue':
29
        return $workflow.execute('support-ticket-creator');
30
      case 'sales_lead':
31
        return $workflow.execute('sales-notification');
32
      default:
33
        return $workflow.execute('default-handler');
34
    }
35
  `
36
};

1
const customerOnboardingWorkflow = {
2
  triggers: ["New signup webhook"],
3

4
  steps: [
5
    "Validate customer data",
6
    "Create account in CRM",
7
    "Send welcome email",
8
    "Schedule onboarding call",
9
    "Create project in PM tool",
10
    "Set up billing",
11
    "Add to mailing list",
12
    "Notify sales team"
13
  ],
14

15
  implementation: async (customer) => {
16
    // Step 1: CRM Integration
17
    const crmRecord = await $node['Salesforce'].create({
18
      object: 'Account',
19
      fields: {
20
        Name: customer.company,
21
        Contact: customer.name,
22
        Email: customer.email,
23
        Plan: customer.plan
24
      }
25
    });
26

27
    // Step 2: Email Sequence
28
    await $node['SendGrid'].send({
29
      template_id: 'welcome_email',
30
      to: customer.email,
31
      dynamic_template_data: {
32
        name: customer.name,
33
        company: customer.company,
34
        onboarding_link: generateOnboardingLink(customer)
35
      }
36
    });
37

38
    // Step 3: Calendar Scheduling
39
    await $node['Calendly'].createEvent({
40
      email: customer.email,
41
      event_type: 'onboarding_call',
42
      timezone: customer.timezone
43
    });
44

45
    // Step 4: Project Setup
46
    await $node['Asana'].createProject({
47
      name: `Onboarding - ${customer.company}`,
48
      template: 'customer_onboarding',
49
      team: 'customer_success'
50
    });
51

52
    return { success: true, customer_id: crmRecord.id };
53
  }
54
};

1
const dataPipelineWorkflow = {
2
  schedule: "0 2 * * *", // Daily at 2 AM
3

4
  pipeline: [
5
    {
6
      stage: "Extract",
7
      sources: ["Database", "API", "Files"],
8
      implementation: async () => {
9
        const data = await Promise.all([
10
          extractFromDatabase(),
11
          extractFromAPI(),
12
          extractFromFiles()
13
        ]);
14
        return mergeData(data);
15
      }
16
    },
17
    {
18
      stage: "Transform",
19
      operations: ["Clean", "Normalize", "Enrich"],
20
      implementation: async (data) => {
21
        const cleaned = await cleanData(data);
22
        const normalized = await normalizeData(cleaned);
23
        const enriched = await enrichData(normalized);
24
        return enriched;
25
      }
26
    },
27
    {
28
      stage: "Load",
29
      destinations: ["Data Warehouse", "Analytics", "Reports"],
30
      implementation: async (data) => {
31
        await Promise.all([
32
          loadToWarehouse(data),
33
          updateAnalytics(data),
34
          generateReports(data)
35
        ]);
36
      }
37
    }
38
  ]
39
};

1
// Optimization strategies
2
const optimizationStrategies = {
3
  // Use batching for bulk operations
4
  batching: {
5
    bad: "Process 1000 items one by one",
6
    good: "Process in batches of 100",
7
    implementation: `
8
      const batchSize = 100;
9
      const batches = [];
10

11
      for (let i = 0; i < items.length; i += batchSize) {
12
        batches.push(items.slice(i, i + batchSize));
13
      }
14

15
      for (const batch of batches) {
16
        await processBatch(batch);
17
      }
18
    `
19
  },
20

21
  // Cache frequently accessed data
22
  caching: {
23
    implementation: `
24
      const cache = new Map();
25
      const CACHE_TTL = 3600000; // 1 hour
26

27
      const getCachedData = async (key) => {
28
        const cached = cache.get(key);
29

30
        if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
31
          return cached.data;
32
        }
33

34
        const data = await fetchData(key);
35
        cache.set(key, { data, timestamp: Date.now() });
36

37
        return data;
38
      };
39
    `
40
  },
41

42
  // Parallel execution
43
  parallelization: {
44
    implementation: `
45
      // Instead of sequential
46
      for (const item of items) {
47
        await processItem(item);
48
      }
49

50
      // Use parallel
51
      await Promise.all(items.map(item => processItem(item)));
52
    `
53
  }
54
};

1
// Efficient resource usage
2
const resourceManagement = {
3
  // Connection pooling
4
  databasePool: {
5
    min: 2,
6
    max: 10,
7
    idleTimeoutMillis: 30000,
8
    connectionTimeoutMillis: 2000
9
  },
10

11
  // Memory management
12
  memoryOptimization: `
13
    // Stream large files instead of loading into memory
14
    const stream = fs.createReadStream(largeFi…
15
    stream.pipe(processStream).pipe(outputStream);
16

17
    // Clear unused variables
18
    let largeData = await fetchLargeDataset();
19
    processData(largeData);
20
    largeData = null; // Clear reference
21
  `,
22

23
  // Rate limiting
24
  rateLimiting: `
25
    const rateLimiter = {
26
      maxRequests: 100,
27
      windowMs: 60000,
28

29
      async execute(fn) {
30
        if (this.requests >= this.maxRequests) {
31
          await this.waitForWindow();
32
        }
33

34
        this.requests++;
35
        return await fn();
36
      }
37
    };
38
  `
39
};

1
// Secure credential handling
2
const credentialManagement = {
3
  // Never hardcode credentials
4
  bad: {
5
    api_key: "sk-1234567890abcdef"
6
  },
7

8
  // Use environment variables or n8n credentials
9
  good: {
10
    api_key: process.env.API_KEY,
11
    n8n_credential: $credentials.apiKey
12
  },
13

14
  // Encryption for sensitive data
15
  encryption: `
16
    const crypto = require('crypto');
17
    const algorithm = 'aes-256-gcm';
18

19
    const encrypt = (text, password) => {
20
      const salt = crypto.randomBytes(16);
21
      const key = crypto.pbkdf2Sync(password, salt, 100000, 32, 'sha256');
22
      const iv = crypto.randomBytes(16);
23
      const cipher = crypto.createCipheriv(algorithm, key, iv);
24

25
      let encrypted = cipher.update(text, 'utf8', 'hex');
26
      encrypted += cipher.final('hex');
27

28
      const authTag = cipher.getAuthTag();
29

30
      return {
31
        encrypted,
32
        salt: salt.toString('hex'),
33
        iv: iv.toString('hex'),
34
        authTag: authTag.toString('hex')
35
      };
36
    };
37
  `
38
};

1
// Implementing access control
2
const accessControl = {
3
  // Webhook authentication
4
  webhookAuth: `
5
    // Validate webhook signature
6
    const validateWebhook = (request) => {
7
      const signature = request.headers['x-signature'];
8
      const payload = JSON.stringify(request.body);
9

10
      const expectedSignature = crypto
11
        .createHmac('sha256', process.env.WEBHOOK_SECRET)
12
        .update(payload)
13
        .digest('hex');
14

15
      if (signature !== expectedSignature) {
16
        throw new Error('Invalid webhook signature');
17
      }
18
    };
19
  `,
20

21
  // API key validation
22
  apiKeyValidation: `
23
    const validateApiKey = async (apiKey) => {
24
      const hashedKey = crypto
25
        .createHash('sha256')
26
        .update(apiKey)
27
        .digest('hex');
28

29
      const valid = await $node['Database'].query({
30
        query: 'SELECT * FROM api_keys WHERE key_hash = ?',
31
        params: [hashedKey]
32
      });
33

34
      if (!valid || valid.length === 0) {
35
        throw new Error('Invalid API key');
36
      }
37

38
      return valid[0];
39
    };
40
  `
41
};

1
// Monitoring implementation
2
const monitoring = {
3
  // Performance metrics
4
  metrics: {
5
    execution_time: "Track workflow duration",
6
    success_rate: "Monitor success/failure ratio",
7
    throughput: "Measure items processed per minute",
8
    error_rate: "Track error frequency"
9
  },
10

11
  // Logging strategy
12
  logging: `
13
    const logger = {
14
      info: (message, data) => {
15
        console.log(\`[INFO] \${new Date().toISOString()} - \${message}\`, data);
16
      },
17

18
      error: (message, error) => {
19
        console.error(\`[ERROR] \${new Date().toISOString()} - \${message}\`, error);
20

21
        // Send to monitoring service
22
        $node['Datadog'].send({
23
          metric: 'workflow.error',
24
          tags: ['workflow:' + $workflow.name],
25
          value: 1
26
        });
27
      },
28

29
      metric: (name, value, tags = []) => {
30
        $node['Prometheus'].push({
31
          metric: name,
32
          value: value,
33
          tags: tags,
34
          timestamp: Date.now()
35
        });
36
      }
37
    };
38
  `,
39

40
  // Health checks
41
  healthCheck: `
42
    const healthCheck = async () => {
43
      const checks = {
44
        database: await checkDatabase(),
45
        api: await checkExternalAPIs(),
46
        storage: await checkStorage(),
47
        memory: process.memoryUsage()
48
      };
49

50
      const status = Object.values(checks).every(check => check.healthy);
51

52
      return {
53
        status: status ? 'healthy' : 'unhealthy',
54
        checks: checks,
55
        timestamp: new Date().toISOString()
56
      };
57
    };
58
  `
59
};

1
// Backup strategies
2
const backupStrategies = {
3
  // Workflow backup
4
  workflowBackup: `
5
    const backupWorkflows = async () => {
6
      const workflows = await $node['n8n'].getAllWorkflows();
7

8
      const backup = {
9
        timestamp: new Date().toISOString(),
10
        workflows: workflows,
11
        credentials: await exportCredentials(),
12
        settings: await exportSettings()
13
      };
14

15
      // Store backup
16
      await $node['S3'].upload({
17
        bucket: 'n8n-backups',
18
        key: \`backup-\${backup.timestamp}.json\`,
19
        body: JSON.stringify(backup)
20
      });
21

22
      return backup;
23
    };
24
  `,
25

26
  // Disaster recovery
27
  recovery: `
28
    const restoreFromBackup = async (backupId) => {
29
      // Download backup
30
      const backup = await $node['S3'].download({
31
        bucket: 'n8n-backups',
32
        key: backupId
33
      });
34

35
      const data = JSON.parse(backup);
36

37
      // Restore workflows
38
      for (const workflow of data.workflows) {
39
        await $node['n8n'].createWorkflow(workflow);
40
      }
41

42
      // Restore credentials
43
      await restoreCredentials(data.credentials);
44

45
      // Restore settings
46
      await restoreSettings(data.settings);
47

48
      return { restored: true, timestamp: data.timestamp };
49
    };
50
  `
51
};

1
# docker-compose for scaled deployment
2
version: '3.8'
3

4
services:
5
  n8n-main:
6
    image: n8nio/n8n
7
    environment:
8
      - EXECUTIONS_MODE=queue
9
      - QUEUE_BULL_REDIS_HOST=redis
10
    command: start
11

12
  n8n-worker-1:
13
    image: n8nio/n8n
14
    environment:
15
      - EXECUTIONS_MODE=queue
16
      - QUEUE_BULL_REDIS_HOST=redis
17
    command: worker
18

19
  n8n-worker-2:
20
    image: n8nio/n8n
21
    environment:
22
      - EXECUTIONS_MODE=queue
23
      - QUEUE_BULL_REDIS_HOST=redis
24
    command: worker
25

26
  redis:
27
    image: redis:alpine
28
    volumes:
29
      - redis_data:/data
30

31
  nginx:
32
    image: nginx
33
    ports:
34
      - "443:443"
35
    volumes:
36
      - ./nginx.conf:/etc/nginx/nginx.conf

1
const troubleshooting = {
2
  "Memory Issues": {
3
    symptom: "Workflow crashes with out of memory error",
4
    solution: `
5
      // Increase Node.js memory limit
6
      NODE_OPTIONS="--max-old-space-size=4096" n8n start
7

8
      // Or use streaming for large data
9
      const stream = $input.getBinaryStream();
10
      stream.pipe(processStream);
11
    `
12
  },
13

14
  "Webhook Not Triggering": {
15
    symptom: "Webhook URL not receiving data",
16
    solution: `
17
      // Check webhook URL configuration
18
      WEBHOOK_URL=https://your-domain.com
19

20
      // Ensure webhook is active
21
      // Test with curl
22
      curl -X POST https://your-domain.com/webhook/test \\
23
        -H "Content-Type: application/json" \\
24
        -d '{"test": "data"}'
25
    `
26
  },
27

28
  "Database Connection Issues": {
29
    symptom: "Cannot connect to database",
30
    solution: `
31
      // Verify connection string
32
      // Check network connectivity
33
      // Ensure database is running
34
      // Verify credentials
35

36
      // Test connection
37
      const testConnection = async () => {
38
        try {
39
          await $node['Database'].query('SELECT 1');
40
          return 'Connection successful';
41
        } catch (error) {
42
          return \`Connection failed: \${error.message}\`;
43
        }
44
      };
45
    `
46
  }
47
};