N8n Workflow Patterns V2

n8n Workflow Patterns

Overview

This public intake copy packages plugins/antigravity-awesome-skills/skills/n8n-workflow-patterns from https://github.com/sickn33/antigravity-awesome-skills into the native Omni Skills editorial shape without hiding its origin.

Use it when the operator needs the upstream workflow, support files, and repository context to stay intact while the public validator and private enhancer continue their normal downstream flow.

This intake keeps the copied upstream files intact and uses the external_source block in metadata.json plus ORIGIN.md as the provenance anchor for review.

n8n Workflow Patterns Proven architectural patterns for building n8n workflows.

Imported source sections that did not map cleanly to the public headings are still preserved below or in the support files. Notable imported sections: The 5 Core Patterns, Pattern Selection Guide, Data Flow Patterns, Common Gotchas, Integration with Other Skills, Pattern Statistics.

When to Use This Skill

Use this section as the trigger filter. It should make the activation boundary explicit before the operator loads files, runs commands, or opens a pull request.

• You need to choose an architectural pattern for an n8n workflow before building it.
• The task involves webhook processing, API integration, scheduled jobs, database sync, or AI-agent workflow design.
• You want a high-level workflow structure rather than node-by-node troubleshooting.
• Use when the request clearly matches the imported source intent: Proven architectural patterns for building n8n workflows.
• Use when the operator should preserve upstream workflow detail instead of rewriting the process from scratch.
• Use when provenance needs to stay visible in the answer, PR, or review packet.

Operating Table

Workflow

This workflow is intentionally editorial and operational at the same time. It keeps the imported source useful to the operator while still satisfying the public intake standards that feed the downstream enhancer flow.

1. Webhook - HTTP endpoint (instant)
2. Schedule - Cron-based timing (periodic)
3. Manual - Click to execute (testing)
4. Polling - Check for changes (intervals)
5. HTTP Request - REST APIs
6. Database nodes - Postgres, MySQL, MongoDB
7. Service nodes - Slack, Google Sheets, etc.

Imported Workflow Notes

Imported: Common Workflow Components

All patterns share these building blocks:

1. Triggers

• Webhook - HTTP endpoint (instant)
• Schedule - Cron-based timing (periodic)
• Manual - Click to execute (testing)
• Polling - Check for changes (intervals)

2. Data Sources

• HTTP Request - REST APIs
• Database nodes - Postgres, MySQL, MongoDB
• Service nodes - Slack, Google Sheets, etc.
• Code - Custom JavaScript/Python

3. Transformation

• Set - Map/transform fields
• Code - Complex logic
• IF/Switch - Conditional routing
• Merge - Combine data streams

4. Outputs

• HTTP Request - Call APIs
• Database - Write data
• Communication - Email, Slack, Discord
• Storage - Files, cloud storage

5. Error Handling

• Error Trigger - Catch workflow errors
• IF - Check for error conditions
• Stop and Error - Explicit failure
• Continue On Fail - Per-node setting

Imported: Workflow Creation Checklist

When building ANY workflow, follow this checklist:

Planning Phase

• Identify the pattern (webhook, API, database, AI, scheduled)
• List required nodes (use search_nodes)
• Understand data flow (input → transform → output)
• Plan error handling strategy

Implementation Phase

• Create workflow with appropriate trigger
• Add data source nodes
• Configure authentication/credentials
• Add transformation nodes (Set, Code, IF)
• Add output/action nodes
• Configure error handling

Validation Phase

• Validate each node configuration (validate_node)
• Validate complete workflow (validate_workflow)
• Test with sample data
• Handle edge cases (empty data, errors)

Deployment Phase

• Review workflow settings (execution order, timeout, error handling)
• Activate workflow using activateWorkflow operation
• Monitor first executions
• Document workflow purpose and data flow

Imported: Summary

Key Points:

1. 5 core patterns cover 90%+ of workflow use cases
2. Webhook processing is the most common pattern
3. Use the workflow creation checklist for every workflow
4. Plan pattern → Select nodes → Build → Validate → Deploy
5. Integrate with other skills for complete workflow development

Next Steps:

1. Identify your use case pattern
2. Read the detailed pattern file
3. Use n8n MCP Tools Expert to find nodes
4. Follow the workflow creation checklist
5. Use n8n Validation Expert to validate

Related Skills:

• n8n MCP Tools Expert - Find and configure nodes
• n8n Expression Syntax - Write expressions correctly
• n8n Validation Expert - Validate and fix errors
• n8n Node Configuration - Configure specific operations

Imported: The 5 Core Patterns

Based on analysis of real workflow usage:

1. Webhook Processing (Most Common)

   • Receive HTTP requests → Process → Output
   • Pattern: Webhook → Validate → Transform → Respond/Notify

2. [HTTP API Integration]

   • Fetch from REST APIs → Transform → Store/Use
   • Pattern: Trigger → HTTP Request → Transform → Action → Error Handler

3. Database Operations

   • Read/Write/Sync database data
   • Pattern: Schedule → Query → Transform → Write → Verify

4. AI Agent Workflow

   • AI agents with tools and memory
   • Pattern: Trigger → AI Agent (Model + Tools + Memory) → Output

5. Scheduled Tasks

   • Recurring automation workflows
   • Pattern: Schedule → Fetch → Process → Deliver → Log

Examples

Example 1: Ask for the upstream workflow directly

Use @n8n-workflow-patterns-v2 to handle <task>. Start from the copied upstream workflow, load only the files that change the outcome, and keep provenance visible in the answer.

Explanation: This is the safest starting point when the operator needs the imported workflow, but not the entire repository.

Example 2: Ask for a provenance-grounded review

Review @n8n-workflow-patterns-v2 against metadata.json and ORIGIN.md, then explain which copied upstream files you would load first and why.

Explanation: Use this before review or troubleshooting when you need a precise, auditable explanation of origin and file selection.

Example 3: Narrow the copied support files before execution

Use @n8n-workflow-patterns-v2 for <task>. Load only the copied references, examples, or scripts that change the outcome, and name the files explicitly before proceeding.

Explanation: This keeps the skill aligned with progressive disclosure instead of loading the whole copied package by default.

Example 4: Build a reviewer packet

Review @n8n-workflow-patterns-v2 using the copied upstream files plus provenance, then summarize any gaps before merge.

Explanation: This is useful when the PR is waiting for human review and you want a repeatable audit packet.

Imported Usage Notes

Imported: Quick Start Examples

Example 1: Simple Webhook → Slack

1. Webhook (path: "form-submit", POST)
2. Set (map form fields)
3. Slack (post message to #notifications)

Example 2: Scheduled Report

1. Schedule (daily at 9 AM)
2. HTTP Request (fetch analytics)
3. Code (aggregate data)
4. Email (send formatted report)
5. Error Trigger → Slack (notify on failure)

Example 3: Database Sync

1. Schedule (every 15 minutes)
2. Postgres (query new records)
3. IF (check if records exist)
4. MySQL (insert records)
5. Postgres (update sync timestamp)

Example 4: AI Assistant

1. Webhook (receive chat message)
2. AI Agent
   ├─ OpenAI Chat Model (ai_languageModel)
   ├─ HTTP Request Tool (ai_tool)
   ├─ Database Tool (ai_tool)
   └─ Window Buffer Memory (ai_memory)
3. Webhook Response (send AI reply)

Example 5: API Integration

1. Manual Trigger (for testing)
2. HTTP Request (GET /api/users)
3. Split In Batches (process 100 at a time)
4. Set (transform user data)
5. Postgres (upsert users)
6. Loop (back to step 3 until done)

Imported: Real Template Examples

From n8n template library:

Template #2947: Weather to Slack

• Pattern: Scheduled Task
• Nodes: Schedule → HTTP Request (weather API) → Set → Slack
• Complexity: Simple (4 nodes)

Webhook Processing: Most common pattern

• Most common: Form submissions, payment webhooks, chat integrations

HTTP API: Common pattern

• Most common: Data fetching, third-party integrations

Database Operations: Common pattern

• Most common: ETL, data sync, backup workflows

AI Agents: Growing in usage

• Most common: Chatbots, content generation, data analysis

Use search_templates and get_template from n8n-mcp tools to find examples!

Best Practices

Treat the generated public skill as a reviewable packaging layer around the upstream repository. The goal is to keep provenance explicit and load only the copied source material that materially improves execution.

• Start with the simplest pattern that solves your problem
• Plan your workflow structure before building
• Use error handling on all workflows
• Test with sample data before activation
• Follow the workflow creation checklist
• Use descriptive node names
• Document complex workflows (notes field)

Imported Operating Notes

Imported: Best Practices

✅ Do

• Start with the simplest pattern that solves your problem
• Plan your workflow structure before building
• Use error handling on all workflows
• Test with sample data before activation
• Follow the workflow creation checklist
• Use descriptive node names
• Document complex workflows (notes field)
• Monitor workflow executions after deployment

❌ Don't

• Build workflows in one shot (iterate! avg 56s between edits)
• Skip validation before activation
• Ignore error scenarios
• Use complex patterns when simple ones suffice
• Hardcode credentials in parameters
• Forget to handle empty data cases
• Mix multiple patterns without clear boundaries
• Deploy without testing

Troubleshooting

Problem: The operator skipped the imported context and answered too generically

Symptoms: The result ignores the upstream workflow in plugins/antigravity-awesome-skills/skills/n8n-workflow-patterns, fails to mention provenance, or does not use any copied source files at all. Solution: Re-open metadata.json, ORIGIN.md, and the most relevant copied upstream files. Check the external_source block first, then restate the provenance before continuing.

Problem: The imported workflow feels incomplete during review

Symptoms: Reviewers can see the generated SKILL.md, but they cannot quickly tell which references, examples, or scripts matter for the current task. Solution: Point at the exact copied references, examples, scripts, or assets that justify the path you took. If the gap is still real, record it in the PR instead of hiding it.

Problem: The task drifted into a different specialization

Symptoms: The imported skill starts in the right place, but the work turns into debugging, architecture, design, security, or release orchestration that a native skill handles better. Solution: Use the related skills section to hand off deliberately. Keep the imported provenance visible so the next skill inherits the right context instead of starting blind.

Related Skills

• @00-andruia-consultant - Use when the work is better handled by that native specialization after this imported skill establishes context.
• @00-andruia-consultant-v2 - Use when the work is better handled by that native specialization after this imported skill establishes context.
• @10-andruia-skill-smith - Use when the work is better handled by that native specialization after this imported skill establishes context.
• @10-andruia-skill-smith-v2 - Use when the work is better handled by that native specialization after this imported skill establishes context.

Additional Resources

Use this support matrix and the linked files below as the operator packet for this imported skill. They should reflect real copied source material, not generic scaffolding.

Imported Reference Notes

Imported: Pattern Selection Guide

When to use each pattern:

Webhook Processing - Use when:

• Receiving data from external systems
• Building integrations (Slack commands, form submissions, GitHub webhooks)
• Need instant response to events
• Example: "Receive Stripe payment webhook → Update database → Send confirmation"

HTTP API Integration - Use when:

• Fetching data from external APIs
• Synchronizing with third-party services
• Building data pipelines
• Example: "Fetch GitHub issues → Transform → Create Jira tickets"

Database Operations - Use when:

• Syncing between databases
• Running database queries on schedule
• ETL workflows
• Example: "Read Postgres records → Transform → Write to MySQL"

AI Agent Workflow - Use when:

• Building conversational AI
• Need AI with tool access
• Multi-step reasoning tasks
• Example: "Chat with AI that can search docs, query database, send emails"

Scheduled Tasks - Use when:

• Recurring reports or summaries
• Periodic data fetching
• Maintenance tasks
• Example: "Daily: Fetch analytics → Generate report → Email team"

Imported: Data Flow Patterns

Linear Flow

Trigger → Transform → Action → End

Use when: Simple workflows with single path

Branching Flow

Trigger → IF → [True Path]
             └→ [False Path]

Use when: Different actions based on conditions

Parallel Processing

Trigger → [Branch 1] → Merge
       └→ [Branch 2] ↗

Use when: Independent operations that can run simultaneously

Loop Pattern

Trigger → Split in Batches → Process → Loop (until done)

Use when: Processing large datasets in chunks

Error Handler Pattern

Main Flow → [Success Path]
         └→ [Error Trigger → Error Handler]

Use when: Need separate error handling workflow

Imported: Common Gotchas

1. Webhook Data Structure

Problem: Can't access webhook payload data

Solution: Data is nested under $json.body

❌ {{$json.email}}
✅ {{$json.body.email}}

See: n8n Expression Syntax skill

2. Multiple Input Items

Problem: Node processes all input items, but I only want one

Solution: Use "Execute Once" mode or process first item only

{{$json[0].field}}  // First item only

3. Authentication Issues

Problem: API calls failing with 401/403

Solution:

• Configure credentials properly
• Use the "Credentials" section, not parameters
• Test credentials before workflow activation

4. Node Execution Order

Problem: Nodes executing in unexpected order

Solution: Check workflow settings → Execution Order

• v0: Top-to-bottom (legacy)
• v1: Connection-based (recommended)

5. Expression Errors

Problem: Expressions showing as literal text

Solution: Use {{}} around expressions

• See n8n Expression Syntax skill for details

Imported: Integration with Other Skills

These skills work together with Workflow Patterns:

n8n MCP Tools Expert - Use to:

• Find nodes for your pattern (search_nodes)
• Understand node operations (get_node)
• Create workflows (n8n_create_workflow)
• Deploy templates (n8n_deploy_template)
• Use ai_agents_guide for AI pattern guidance

n8n Expression Syntax - Use to:

• Write expressions in transformation nodes
• Access webhook data correctly ({{$json.body.field}})
• Reference previous nodes ({{$node["Node Name"].json.field}})

n8n Node Configuration - Use to:

• Configure specific operations for pattern nodes
• Understand node-specific requirements

n8n Validation Expert - Use to:

• Validate workflow structure
• Fix validation errors
• Ensure workflow correctness before deployment

Imported: Pattern Statistics

Common workflow patterns:

Most Common Triggers:

1. Webhook - 35%
2. Schedule (periodic tasks) - 28%
3. Manual (testing/admin) - 22%
4. Service triggers (Slack, email, etc.) - 15%

Most Common Transformations:

1. Set (field mapping) - 68%
2. Code (custom logic) - 42%
3. IF (conditional routing) - 38%
4. Switch (multi-condition) - 18%

Most Common Outputs:

1. HTTP Request (APIs) - 45%
2. Slack - 32%
3. Database writes - 28%
4. Email - 24%

Average Workflow Complexity:

• Simple (3-5 nodes): 42%
• Medium (6-10 nodes): 38%
• Complex (11+ nodes): 20%

Imported: Detailed Pattern Files

For comprehensive guidance on each pattern:

• webhook_processing.md - Webhook patterns, data structure, response handling
• http_api_integration - REST APIs, authentication, pagination, retries
• database_operations.md - Queries, sync, transactions, batch processing
• ai_agent_workflow.md - AI agents, tools, memory, langchain nodes
• scheduled_tasks.md - Cron schedules, reports, maintenance tasks

Imported: Limitations

• Use this skill only when the task clearly matches the scope described above.
• Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
• Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.