Zapier Workflow Builder

Template skill. Fill in the [BRACKETED] placeholders with your organization's details — or paste your org context and ask Claude to populate them for you.

Zapier Workflow Builder

Guide users through designing and building effective Zapier workflows. Your role is to help the user think through their automation need, design the right Zap architecture, and produce either step-by-step instructions or a Copilot prompt they can paste into Zapier to build it.

Before building anything, read the trigger/action logic back to the user in plain language ("so when X happens, this checks Y and then does Z — is that right?"). Confirm it matches what they meant before generating steps or a Copilot prompt. Apply your org's naming and folder conventions (below), and point users to any shared, pre-authenticated app connections instead of asking them to reconnect an account that's already shared.

Workflow: Helping a User Build a Zap

Step 1: Understand the Automation Need

Ask the user to describe what they want to automate. Clarify:

1. The trigger event — What starts this? (new email, form submission, schedule, transcript ready, spreadsheet row, RSS item, etc.)
2. The desired outcome — What should happen? (Slack notification, CRM update, email sent, task created, data logged, etc.)
3. Conditions/filters — Should it run every time, or only when specific criteria are met?
4. Volume — How often does this trigger fire? (determines task efficiency strategy)
5. Apps involved — Which apps need to connect?

Step 2: Design the Zap Architecture

Based on the user's needs, design the workflow following these principles:

Keep it lean:

• Filter as step 2 (right after the trigger) — filters cost zero tasks and stop bad data early
• Use Formatter steps for data transformation — also zero task cost
• Only use AI or Code steps when Formatter can't handle it
• Use Digest by Zapier to batch high-volume triggers into periodic summaries

Naming convention:

[PREFIX] Trigger App: Event -> Action App: Result

Example prefixes: [MARKETING], [OPS], [SALES], [HR], [FINANCE], [DAILY], [WEEKLY] — replace with the department/cadence tags your org actually uses.

Folder taxonomy:

Organize the Zapier workspace by team, with a dedicated templates folder that's never edited directly:

[YOUR ORG] Zaps/
├── [Department A]/
│   ├── [Sub-area]
│   └── [Sub-area]
├── [Department B]/
│   ├── [Sub-area]
│   └── [Sub-area]
├── Operations/
│   ├── Reporting
│   └── Notifications
├── _Archive/
└── [YOUR ORG] TEMPLATES (DO NOT EDIT — duplicate to use)

Duplicate templates from the TEMPLATES folder, never edit the originals, and move the duplicate out of that folder before editing.

Shared connections:

If your org pre-authenticates and shares certain app connections across the team (a CRM enrichment tool, an AI provider, a shared inbox), point users to those instead of having them connect their own accounts — it avoids duplicate auth, keeps API usage on one bill, and means a workflow doesn't break when an individual staffer leaves. For AI by Zapier steps, default to the free "Zapier-provided" model unless the task needs stronger reasoning, in which case use the org's shared AI connection. Zapier's model roster and pricing change often: check the Zap editor's model picker for what's current rather than trusting any specific model name, and treat "cheapest/free model that can do the extraction" as the selection rule.

When to split into multiple Zaps:

• More than 8 steps — hard to debug
• Unrelated actions for different teams
• Different parts need different error handling
• Reusable sequences — use Sub-Zaps instead

When to keep as one Zap:

• Linear logic (trigger + 2-5 sequential actions)
• All steps relate to the same business event
• Later steps need data from earlier steps

Step 3: Present the Design

Show the user their Zap design as a numbered step list:

[MARKETING] Typeform: New Registration -> HubSpot + Slack

1. Trigger: Typeform — New Entry (form: "Event Registration")
2. Filter: Only continue if "Company Size" is not blank
3. Formatter: Split "Full Name" into First Name / Last Name
4. Action: HubSpot — Create Contact (map: first name, last name, email, company)
5. Action: Slack — Send Channel Message (#events-team: "{Name} from {Company} registered")

Include:

• Estimated tasks per run (only action steps count — triggers, filters, formatters, delays, paths, loops, sub-zap calls are free)
• Any app connections they'll need to authenticate
• Potential issues or edge cases

Step 4: Generate a Copilot Prompt

Zapier has a built-in AI assistant called Copilot that can build Zaps from natural language. It's available in the Zap editor (icon in lower left) and on Zapier's home page.

After designing the Zap, generate a structured Copilot prompt the user can paste directly into Zapier. Structure complex prompts with XML tags to prevent instruction bleed:

Example Copilot prompt:

<trigger>
New Typeform submission on the form "Event Registration"
</trigger>

<filter>
Only continue if the "Company Size" field is not blank
</filter>

<actions>
1. Use Formatter to split the "Full Name" field into First Name and Last Name (split on space, take first and last segments)
2. Create a contact in HubSpot with: First Name, Last Name, Email, Company Name, Company Size
3. Send a message to the Slack channel #events-team with the text: "[First Name] [Last Name] from [Company Name] just registered for [Event Name]"
</actions>

Copilot prompting tips:

• Use consistent field names throughout — if you say "Company Size" once, keep calling it that
• Frame positively: "Send notifications Monday through Friday" not "Don't send on weekends"
• Be specific about apps — vague prompts produce generic results
• For simple Zaps, one-liners work: "When a new Typeform response comes in, add the person to HubSpot and send a Slack message to #marketing"
• Iterate — keep the conversation going with Copilot to refine steps rather than starting over
• Copilot can also accept voice input and image/sketch attachments

Copilot limitations:

• Won't connect app accounts — users still authenticate each app themselves
• Complex field mappings often need manual refinement after the draft is built
• Always test after building — Copilot can't predict trigger behavior

Step 5: Provide Setup Guidance

Walk the user through any configuration that Copilot won't handle:

• App authentication
• Filter conditions and field mapping verification
• Testing each step with real data
• Renaming steps descriptively (e.g., "AI by Zapier" -> "Extract name and company from article")
• Version naming before publishing (e.g., "2026-01-15: initial setup for event registration")

Task Cost Reference

Understanding what counts as a task prevents billing surprises:

Cost optimization rule: Put filters and formatters before action steps. A 5-step Zap (1 trigger + 1 filter + 1 formatter + 2 actions) costs only 2 tasks per run.

Common Automation Patterns

Lead Capture + CRM

Trigger: Form submission (Typeform/Gravity Forms/etc.)
-> Filter: Company field is not blank
-> Action: Enrich contact (FullEnrich, Apollo, or similar)
-> Action: Create/update CRM contact (HubSpot, Salesforce, etc.)
-> Action: Slack notification to relevant team channel

Meeting Recap Automation

Trigger: Transcription tool — New transcript (Fireflies, Granola, etc.)
-> Filter: Participants include internal team members
-> AI: Summarize key decisions and action items
-> Action: Post summary to Slack DM or channel
-> Action: Create tasks in project management tool

News / Content Monitoring

Trigger: RSS by Zapier — Google News or industry RSS feed
-> Filter: Exclude irrelevant publishers
-> AI: Extract relevant entities and summary from article
-> Action: Log to Google Sheets or Zapier Tables
-> Action: Slack notification to relevant channel

Automated Outreach with Human Review

Trigger: New CRM contact or scheduled trigger
-> AI: Draft personalized message
-> Action: Slack "Request Approval" with draft preview
-> Path A (Approved): Send via email
-> Path B (Rejected): Log and stop

Weekly Digest / Reporting

Trigger: Schedule — Every Monday at 9 AM
-> Action: Pull data from spreadsheet or database
-> Formatter: Format dates and numbers
-> Action: Send compiled email or Slack message

Error Handling

For Critical Zaps (lead capture, customer data, outreach)

Add an error handler on action steps: click the three dots on any step -> "Add error handler" -> send a Slack message with error details to the owner.

Important tradeoff: Zaps with custom error handlers will NOT use Autoreplay (automatic retry). Choose one per Zap:

• Autoreplay — best for transient failures (API timeouts, rate limits). Retries up to 3 times automatically.
• Error handlers — best when you need immediate notification or alternate logic on failure.

For Non-Critical Zaps

Rely on Zapier's default email notifications for errors.

Avoiding Loops

A Zap loop happens when Zap A triggers Zap B which triggers Zap A. Prevention:

• Add a guard field (e.g., processed_by_zap = true) and filter on it
• For Google Sheets: use "Trigger Column" to only fire on specific column changes
• Never have two Zaps that read/write the same data without loop guards

AI Steps: When to Use What

Code by Zapier: No Coding Required

Users don't need to write code themselves. Two approaches:

Option A — Zapier Copilot (fastest): Click "Generate with AI" inside the Code step and describe what you need. Copilot writes the code and maps variables automatically.

Option B — External AI (fallback): Ask Claude/ChatGPT to write the code, then paste it into the Code step. Always specify: "Write a Zapier JavaScript code block" and describe input variable names and expected outputs.

When to suggest Code over AI:

• Splitting email lists into internal/external (deterministic, no hallucination risk)
• Calculating business days (date math needs precision)
• URL/domain extraction (parsing logic, not interpretation)
• Any transform where the answer must be exactly right every time

Testing Checklist

Before turning on any Zap:

1. Test the trigger with real data (not just the default sample)
2. Test each action — action tests are live (they create real records, send real messages). Use test data where impact is reversible.
3. Run end-to-end using "Test run" (top right of editor) on a selected record
4. Check edge cases: records with blank optional fields, unusual characters, conditions that should halt the Zap
5. Rename every step descriptively — makes debugging dramatically faster
6. Name the version before publishing (this is your changelog)
7. Monitor Zap History after the first few live runs — filter by "Errored" to catch issues early

Debugging workflow:

1. Open Zap History -> filter by "Errored"
2. Click the failed run -> see which step failed
3. Click "Troubleshoot" tab — Zapier's built-in AI generates specific fix instructions
4. Click "Logs" tab for raw HTTP details if needed
5. Fix, re-test the step, re-publish

Quick Reference