Workflow Patterns - n8n Skills

Overview

The n8n Workflow Patterns skill teaches five proven architectural patterns drawn from analysis of real-world n8n usage. These five patterns cover over 90% of automation use cases.

Webhook Processing

Receive HTTP requests from external systems and process them instantly. The most common pattern (35% of workflows).

HTTP API Integration

Fetch data from REST APIs, transform it, and use it in your workflow. Ideal for data pipelines.

Database Operations

Read, write, sync, and manage database data. For ETL, data sync, and maintenance tasks.

AI Agent Workflow

Build AI agents with tool access, memory, and reasoning capabilities.

Scheduled Tasks

Recurring automation workflows that run automatically on a time-based schedule.

Pattern Selection Guide

Choose based on what triggers the workflow and what it does with data:

Pattern	Use When	Example
Webhook Processing	An external system pushes data to you	Stripe payment webhook → Update DB → Send receipt
HTTP API Integration	You need to pull data from external APIs	Fetch GitHub issues → Transform → Create Jira tickets
Database Operations	Syncing, ETL, or scheduled DB maintenance	Read Postgres records → Transform → Write to MySQL
AI Agent Workflow	Need AI with tool access and reasoning	Chat with AI that can search docs, query DB, send emails
Scheduled Tasks	Recurring reports, monitoring, or maintenance	Daily: Fetch analytics → Generate report → Email team

Webhook Processing

Use when: Receiving data from external systems (Slack commands, form submissions, payment webhooks, GitHub events) Key characteristic: Instant, event-driven processing

Node Structure

Webhook → [Validate] → [Transform] → [Action] → [Response/Notify]

Configuration Notes

The most common webhook mistake: webhook payload data is nested under $json.body, not at the root level.

❌ {{$json.email}}        → undefined
✅ {{$json.body.email}}   → "john@example.com"

The webhook node supports two response modes:

Mode	Behavior	Use When
`onReceived`	Immediate 200 OK, workflow continues in background	Long-running workflows, fire-and-forget
`lastNode`	Wait for completion, send custom response	Synchronous processing, form submissions with confirmation

Example Use Cases

Form Submissions
GitHub Webhooks
Chat Integrations

Webhook (path: "contact-form", POST)
IF (check email & message not empty)
Postgres (insert into contacts table)
Email (send confirmation to user)
Slack (notify team in #leads)
Webhook Response ({"status": "success"})

Data access:

Name:    {{$json.body.name}}
Email:   {{$json.body.email}}
Message: {{$json.body.message}}

Webhook (path: "github", POST)
IF (check $json.body.action equals "opened")
Set (extract PR details: title, author, url)
Slack (notify #dev-team)
Webhook Response (200 OK)

Data access:

Event Type: {{$json.headers['x-github-event']}}
Action:     {{$json.body.action}}
PR Title:   {{$json.body.pull_request.title}}
Author:     {{$json.body.pull_request.user.login}}

Webhook (path: "slack-command", POST)
Code (parse Slack payload)
HTTP Request (fetch data from API)
Set (format Slack message)
Webhook Response (immediate reply)

Data access:

Command:    {{$json.body.command}}
Text:       {{$json.body.text}}
User ID:    {{$json.body.user_id}}
Channel ID: {{$json.body.channel_id}}

Template References

From the n8n template library (1,085 webhook templates):

Simple Form to Slack: Webhook → Set → Slack
Payment Processing: Webhook → Verify Signature → Update Database → Send Receipt → Notify Admin
Chat Bot: Webhook → Parse Command → AI Agent → Format Response → Webhook Response

HTTP API Integration

Use when: Fetching data from external APIs, synchronizing with third-party services, or building data pipelines Key characteristic: External data fetching with error handling

Node Structure

Trigger → HTTP Request → [Transform] → [Action] → [Error Handler]

Configuration Notes

Always use n8n’s credentials system for API keys — never hardcode them in parameters. Use environment variables for API base URLs: ={{$env.API_BASE_URL}}/users

For large datasets, implement pagination to avoid memory issues:

Set (initialize: page=1, has_more=true)
HTTP Request (GET /api/items?page={{$json.page}})
Code (check if more pages)
IF (has_more === true)
   └→ Set (increment page) → Loop to step 2

Example Use Cases

Data Fetching
API to API
Monitoring

Fetch GitHub issues hourly and store in Postgres:

1. Schedule (every hour)
2. HTTP Request
   - Method: GET
   - URL: https://api.github.com/repos/owner/repo/issues
   - Auth: Bearer Token
   - Query: state=open
3. Code (filter by labels)
4. Set (map to database schema)
5. Postgres (upsert issues)

Sync Jira tickets to Slack every 15 minutes:

Schedule (every 15 minutes)
HTTP Request (GET Jira tickets updated today)
IF (check if tickets exist)
Set (format for Slack)
HTTP Request (POST to Slack webhook)

Check API health every 5 minutes:

Schedule (every 5 minutes)
HTTP Request (GET /health endpoint)
IF (status !== 200 OR response_time > 2000ms)
Slack (alert #ops-team)
PagerDuty (create incident)

Template References

From the n8n template library (892 API integration templates):

GitHub to Notion: Schedule → HTTP Request (GitHub) → Transform → HTTP Request (Notion)
Weather to Slack: Schedule → HTTP Request (Weather API) → Set (format) → Slack
CRM Sync: Schedule → HTTP Request (CRM A) → Transform → HTTP Request (CRM B)

Database Operations

Use when: Syncing between databases, running database queries on schedule, ETL workflows Key characteristic: Data persistence and synchronization

Node Structure

Trigger → [Query/Read] → [Transform] → [Write/Update] → [Verify/Log]

Configuration Notes

Always use parameterized queries to prevent SQL injection:

// ✅ SAFE
{
  query: "SELECT * FROM users WHERE email = $1",
  parameters: ["={{$json.email}}"]
}

// ❌ DANGEROUS
{
  query: "SELECT * FROM users WHERE email = '={{$json.email}}'"
}

Supported databases: Postgres, MySQL, MongoDB, Microsoft SQL, SQLite, Redis, and more via community nodes.

Example Use Cases

Data Sync
ETL Pipeline
Cleanup

Sync Postgres to MySQL every 15 minutes:

Schedule (every 15 minutes)
Postgres (SELECT WHERE updated_at > last_sync)
IF (check if records exist)
Set (map Postgres schema to MySQL schema)
MySQL (INSERT or UPDATE users)
Postgres (UPDATE sync_log SET last_sync = NOW())
Slack (notify: "Synced X users")

Consolidate data from multiple sources daily:

1. Schedule (daily at 2 AM)
2. [Parallel branches]
   ├─ Postgres (SELECT orders)
   ├─ MySQL (SELECT customers)
   └─ MongoDB (SELECT products)
3. Merge (combine all data)
4. Code (transform to warehouse schema)
5. Postgres (warehouse INSERT into fact_sales)
6. Email (send summary report)

Archive and clean old logs weekly:

Schedule (weekly on Sunday at 2 AM)
Postgres (find records older than 90 days)
IF (records exist)
Code (export to JSON for archive)
Google Drive (upload archive file)
Postgres (DELETE archived records)
Slack (report: "Archived X records")

Template References

From the n8n template library (456 database templates):

Data Sync: Schedule → Postgres (SELECT new records) → Transform → MySQL (INSERT)
ETL Pipeline: Schedule → [Multiple DB reads] → Merge → Transform → Warehouse (INSERT)
Backup: Schedule → Postgres (SELECT all) → JSON → Google Drive (upload)

AI Agent Workflow

Use when: Building conversational AI, creating agents with tool access, or automating multi-step reasoning tasks Key characteristic: AI-powered decision making with tool use

Node Structure

Trigger → AI Agent (Model + Tools + Memory) → [Process Response] → Output

Configuration Notes

n8n supports 8 AI connection types. The most critical rule: connect tools via the ai_tool port, not the main port.

HTTP Request --[ai_tool]--> AI Agent  ✅
HTTP Request -----------> AI Agent    ❌

The 8 AI connection types:

Connection Type	Purpose
`ai_languageModel`	The LLM (OpenAI, Anthropic, Google, Ollama)
`ai_tool`	Functions the agent can call
`ai_memory`	Conversation context
`ai_outputParser`	Parse structured outputs
`ai_embedding`	Vector embeddings
`ai_vectorStore`	Vector database
`ai_document`	Document loaders
`ai_textSplitter`	Text chunking

Example Use Cases

Customer Support Bot
SQL Analyst
Document Q&A

1. Webhook (path: "chat", POST)
   - Receives: {user_id, message, session_id}

2. AI Agent
   ├─ OpenAI Chat Model (gpt-4)
   ├─ HTTP Request Tool (search knowledge base)
   ├─ Postgres Tool (query customer orders)
   └─ Window Buffer Memory (by session_id)

3. Code (format response)
4. Webhook Response (send reply)

1. Webhook (data question)

2. AI Agent
   ├─ OpenAI Chat Model (gpt-4)
   ├─ Postgres Tool (execute SELECT queries)
   └─ Code Tool (data analysis)

3. Code (generate visualization data)
4. Webhook Response (answer + chart data)

Security: Create a read-only DB user for AI tools:

CREATE USER ai_readonly WITH PASSWORD 'secure';
GRANT SELECT ON customers, orders TO ai_readonly;

Setup phase (run once):

Read Files (load documentation)
Text Splitter (chunk into paragraphs)
Embeddings (OpenAI Embeddings)
Vector Store (store vectors)

Query phase:

1. Webhook (receive question)
2. AI Agent
   ├─ OpenAI Chat Model (gpt-4)
   ├─ Vector Store Tool (search similar docs)
   └─ Buffer Memory (context)
3. Webhook Response (answer with citations)

Template References

From the n8n template library (234 AI templates):

Simple Chatbot: Webhook → AI Agent (GPT-4 + Memory) → Webhook Response
Document Q&A: Setup: Files → Embed → Vector Store / Query: Webhook → AI Agent → Response
SQL Analyst: Webhook → AI Agent (GPT-4 + Postgres Tool) → Format → Response

Scheduled Tasks

Use when: Recurring reports or summaries, periodic data fetching, maintenance tasks Key characteristic: Time-based automated execution

Node Structure

Schedule Trigger → [Fetch Data] → [Process] → [Deliver] → [Log/Notify]

Configuration Notes

Always set an explicit timezone in the workflow settings. Without it, the schedule runs in the server’s local time, which may shift with daylight saving transitions.

// Workflow settings
{ timezone: "America/New_York" }

The Schedule node supports three modes:

Mode	Best For	Example
Interval	Simple recurring tasks	Every 15 minutes
Days & Hours	Specific days and times	Weekdays at 9 AM
Cron	Complex schedules	`0 9,17 * * 1-5`

Common cron expressions:

9 * * 1-5      Every weekday at 9 AM
0 1 * *        First day of every month
*/15 9-17 * * *  Every 15 min during business hours
*/6 * * *      Every 6 hours

Example Use Cases

Daily Reports
Monitoring
Backup

Sales report at 9 AM every day:

1. Schedule (daily at 9 AM)
2. Postgres (query yesterday's sales)
   SELECT date, SUM(amount) as total, COUNT(*) as orders
   FROM orders
   WHERE date = CURRENT_DATE - INTERVAL '1 day'
3. Code (calculate metrics: total, avg order value, comparison)
4. Set (format email body)
5. Email (send to team@company.com)
6. Slack (post summary to #sales)

Website uptime check every 5 minutes:

Schedule (every 5 minutes)
HTTP Request (GET /health, timeout: 10s, continueOnFail)
IF (status !== 200 OR response_time > 2000ms)
Redis (check alert cooldown)
IF (no recent alert)
Slack (notify #ops-team)
PagerDuty (create incident)
Postgres (log uptime check result)

Database backup nightly at 2 AM:

Schedule (daily at 2 AM)
Code (execute pg_dump)
Code (compress backup)
AWS S3 (upload compressed backup)
AWS S3 (list old backups, keep last 30 days)
AWS S3 (delete old backups)
IF (error occurred)
   ├─ PagerDuty (critical alert)
   └─ Email (backup failed!)
   ELSE → Slack (#devops: "✅ Backup completed")

Template References

From the n8n template library:

Template #2947 (Weather to Slack): Schedule (daily 8 AM) → HTTP Request (weather API) → Set (format) → Slack
Daily backup: Schedule (nightly 2 AM) → Postgres (export) → Google Drive (upload) → Email (confirmation)
Monitoring: Schedule (every 5 min) → HTTP Request (health check) → IF (down) → PagerDuty alert

Workflow Creation Checklist

Apply this checklist to every workflow regardless of pattern:

Planning Phase

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

Implementation Phase

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

Validation Phase

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

Deployment Phase

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

Pattern Statistics

Based on analysis of real n8n workflow usage: Most common triggers:

Webhook — 35%
Schedule (periodic tasks) — 28%
Manual (testing/admin) — 22%
Service triggers (Slack, email, etc.) — 15%

Most common transformations:

Set (field mapping) — 68%
Code (custom logic) — 42%
IF (conditional routing) — 38%
Switch (multi-condition) — 18%

Average workflow complexity:

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

Start with the simplest pattern that solves your problem. Most workflows fall in the 3–5 node range.

Common Data Flow Shapes

Linear Flow
  Trigger → Transform → Action → End
  Use when: Simple workflows with a 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

Getting Help

Issues: github.com/czlonkowski/n8n-skills/issues
Discussions: github.com/czlonkowski/n8n-skills/discussions

​Overview

Webhook Processing

HTTP API Integration

Database Operations

AI Agent Workflow

Scheduled Tasks

​Pattern Selection Guide

​Webhook Processing

​Node Structure

​Configuration Notes

​Example Use Cases

​Template References

​HTTP API Integration

​Node Structure

​Configuration Notes

​Example Use Cases

​Template References

​Database Operations

​Node Structure

​Configuration Notes

​Example Use Cases

​Template References

​AI Agent Workflow

​Node Structure

​Configuration Notes

​Example Use Cases

​Template References

​Scheduled Tasks

​Node Structure

​Configuration Notes

​Example Use Cases

​Template References

​Workflow Creation Checklist

​Pattern Statistics

​Common Data Flow Shapes

​Getting Help

Overview

Pattern Selection Guide

Webhook Processing

Node Structure

Configuration Notes

Example Use Cases

Template References

HTTP API Integration

Node Structure

Configuration Notes

Example Use Cases

Template References

Database Operations

Node Structure

Configuration Notes

Example Use Cases

Template References

AI Agent Workflow

Node Structure

Configuration Notes

Example Use Cases

Template References

Scheduled Tasks

Node Structure

Configuration Notes

Example Use Cases

Template References

Workflow Creation Checklist

Pattern Statistics

Common Data Flow Shapes

Getting Help