zapier-make-patterns

What this skill does

# Zapier & Make Patterns

No-code automation democratizes workflow building. Zapier and Make (formerly
Integromat) let non-developers automate business processes without writing
code. But no-code doesn't mean no-complexity - these platforms have their
own patterns, pitfalls, and breaking points.

This skill covers when to use which platform, how to build reliable
automations, and when to graduate to code-based solutions. Key insight:
Zapier optimizes for simplicity and integrations (7000+ apps), Make
optimizes for power and cost-efficiency (visual branching, operations-based
pricing).

Critical distinction: No-code works until it doesn't. Know the limits.

## Principles

- Start simple, add complexity only when needed
- Test with real data before going live
- Document every automation with clear naming
- Monitor errors - 95% error rate auto-disables Zaps
- Know when to graduate to code-based solutions
- Operations/tasks cost money - design efficiently

## Capabilities

- zapier
- make
- integromat
- no-code-automation
- zaps
- scenarios
- workflow-builders
- business-process-automation

## Scope

- code-based-workflows → workflow-automation
- browser-automation → browser-automation
- custom-integrations → backend
- api-development → api-designer

## Tooling

### Platforms

- Zapier - When: Simple automations, maximum app coverage, beginners Note: 7000+ integrations, linear workflows, task-based pricing
- Make - When: Complex workflows, visual branching, budget-conscious Note: Visual scenarios, operations pricing, powerful data handling
- n8n - When: Self-hosted, code-friendly, unlimited operations Note: Open-source, can add custom code, technical users

### Ai_features

- Zapier Agents - When: AI-powered autonomous automation Note: Natural language instructions, 7000+ app access
- Zapier Copilot - When: Building Zaps with AI assistance Note: Describes workflow, AI builds it
- Zapier MCP - When: LLM tools accessing Zapier actions Note: 30,000+ actions available to AI models

## Patterns

### Basic Trigger-Action Pattern

Single trigger leads to one or more actions

**When to use**: Simple notifications, data sync, basic workflows

# BASIC TRIGGER-ACTION:

"""
[Trigger] → [Action]
  e.g., New Email → Create Task
"""

## Zapier Example
"""
Zap Name: "Gmail New Email → Todoist Task"

TRIGGER: Gmail - New Email
  - From: [email protected]
  - Has attachment: yes

ACTION: Todoist - Create Task
  - Project: Inbox
  - Content: {{Email Subject}}
  - Description: From: {{Email From}}
  - Due date: Tomorrow
"""

## Make Example
"""
Scenario: "Gmail to Todoist"

[Gmail: Watch Emails] → [Todoist: Create a Task]

Gmail Module:
  - Folder: INBOX
  - From: [email protected]

Todoist Module:
  - Project ID: (select from dropdown)
  - Content: {{1.subject}}
  - Due String: tomorrow
"""

### Best Practices:
- Use descriptive Zap/Scenario names
- Test with real sample data
- Use filters to prevent unwanted runs

### Multi-Step Sequential Pattern

Chain of actions executed in order

**When to use**: Multi-app workflows, data enrichment pipelines

# MULTI-STEP SEQUENTIAL:

"""
[Trigger] → [Action 1] → [Action 2] → [Action 3]
Each step's output available to subsequent steps
"""

## Zapier Multi-Step Zap
"""
Zap: "New Lead → CRM → Slack → Email"

1. TRIGGER: Typeform - New Entry
   - Form: Lead Capture Form

2. ACTION: HubSpot - Create Contact
   - Email: {{Typeform Email}}
   - First Name: {{Typeform First Name}}
   - Lead Source: "Website Form"

3. ACTION: Slack - Send Channel Message
   - Channel: #sales-leads
   - Message: "New lead: {{Typeform Name}} from {{Typeform Company}}"

4. ACTION: Gmail - Send Email
   - To: {{Typeform Email}}
   - Subject: "Thanks for reaching out!"
   - Body: (template with personalization)
"""

## Make Scenario
"""
[Typeform] → [HubSpot] → [Slack] → [Gmail]

- Each module passes data to the next
- Use {{N.field}} to reference module N's output
- Add error handlers between critical steps
"""

### Conditional Branching Pattern

Different actions based on conditions

**When to use**: Different handling for different data types

# CONDITIONAL BRANCHING:

"""
              ┌→ [Action A] (condition met)
[Trigger] ───┤
              └→ [Action B] (condition not met)
"""

## Zapier Paths (Pro+ required)
"""
Zap: "Route Support Tickets"

1. TRIGGER: Zendesk - New Ticket

2. PATH A: If priority = "urgent"
   - Slack: Post to #urgent-support
   - PagerDuty: Create incident

3. PATH B: If priority = "normal"
   - Slack: Post to #support
   - Asana: Create task

4. PATH C: Otherwise (catch-all)
   - Slack: Post to #support-overflow
"""

## Make Router
"""
[Zendesk: Watch Tickets]
      ↓
[Router]
   ├── Route 1: priority = urgent
   │     └→ [Slack] → [PagerDuty]
   │
   ├── Route 2: priority = normal
   │     └→ [Slack] → [Asana]
   │
   └── Fallback route
         └→ [Slack: overflow]

# Make's visual router makes complex branching clear
"""

### Best Practices:
- Always have a fallback/else path
- Test each path independently
- Document which conditions trigger which path

### Data Transformation Pattern

Clean, format, and transform data between apps

**When to use**: Apps expect different data formats

# DATA TRANSFORMATION:

## Zapier Formatter
"""
Common transformations:

1. Text manipulation:
   - Split text: "John Doe" → First: "John", Last: "Doe"
   - Capitalize: "john" → "John"
   - Replace: Remove special characters

2. Date formatting:
   - Convert: "2024-01-15" → "January 15, 2024"
   - Adjust: Add 7 days to date

3. Numbers:
   - Format currency: 1000 → "$1,000.00"
   - Spreadsheet formula: =SUM(A1:A10)

4. Lookup tables:
   - Map status codes: "1" → "Active", "2" → "Pending"
"""

## Make Data Functions
"""
Make has powerful built-in functions:

Text:
  {{lower(1.email)}}           # Lowercase
  {{substring(1.name; 0; 10)}} # First 10 chars
  {{replace(1.text; "-"; "")}} # Remove dashes

Arrays:
  {{first(1.items)}}           # First item
  {{length(1.items)}}          # Count items
  {{map(1.items; "id")}}       # Extract field

Dates:
  {{formatDate(1.date; "YYYY-MM-DD")}}
  {{addDays(now; 7)}}

Math:
  {{round(1.price * 0.8; 2)}}  # 20% discount, 2 decimals
"""

### Best Practices:
- Transform early in the workflow
- Use filters to skip invalid data
- Log transformations for debugging

### Error Handling Pattern

Graceful handling of failures

**When to use**: Any production automation

# ERROR HANDLING:

## Zapier Error Handling
"""
1. Built-in retry (automatic):
   - Zapier retries failed actions automatically
   - Exponential backoff for temporary failures

2. Error handling step:
   Zap:
     1. [Trigger]
     2. [Action that might fail]
     3. [Error Handler]
        - If error → [Slack: Alert team]
        - If error → [Email: Send report]

3. Path-based handling:
   [Action] → Path A: Success → [Continue]
            → Path B: Error → [Alert + Log]
"""

## Make Error Handlers
"""
Make has visual error handling:

[Module] ──┬── Success → [Next Module]
           │
           └── Error → [Error Handler]

Error handler types:
1. Break: Stop scenario, send notification
2. Rollback: Undo completed operations
3. Commit: Save partial results, continue
4. Ignore: Skip error, continue with next item

Example:
[API Call] → Error Handler (Ignore)
           → [Log to Airtable: "Failed: {{error.message}}"]
           → Continue scenario
"""

### Best Practices:
- Always add error handlers for external APIs
- Log errors to a spreadsheet/database
- Set up Slack/email alerts for critical failures
- Test failure scenarios, not just success

### Batch Processing Pattern

Process multiple items efficiently

**When to use**: Importing data, bulk operations

# BATCH PROCESSING:

## Zapier Looping
"""
Zap: "Process Order Items"

1. TRIGGER: Shopify - New Order
   - Returns: order with line_items array

2. LOOPING: For each item in line_items
   - Create inventory adjustment
   - Update product count
   - Log to spreadsheet

No