COGS Zapier Automation Guide for Beginners

This practical, link‑free guide combines and expands the original Chatham Oaks posts into one simple pillar. It covers the essentials of building a Zap and the most useful Zapier built‑ins: Formatter, Filters & Paths, Delay, Looping, Digest, Storage, Email Parser, Scheduler, Sub‑Zaps, API Request & Webhooks, Human‑in‑the‑Loop, Code/Functions, and Custom Actions. The goal: help you ship reliable automations fast, without overlap.

Before you start (2 quick habits)

• Name clearly: Trigger > Action | Purpose (for example: Sheets New Row > Slack DM | Leads). Clean names make maintenance easy.

• Test safely: build with a stable test record and a non‑production channel or inbox. Swap to real values after validation.

Create your first Zap

What a Zap is: a workflow with a Trigger (what starts it) and one or more Actions (what happens next). Each successful run consumes a task.

Step‑by‑step:

1. Create & name your Zap using Trigger > Action so it’s scannable later.

2. Choose a Trigger app and event (for example, a new spreadsheet row). Prefer instant triggers when available so runs start immediately rather than on a polling delay.

3. Connect and configure the trigger (pick the correct file, sheet, table, calendar, channel, etc.).

4. Test the trigger to pull a real sample. Confirm fields look right.

5. Add an Action app and event (for example, send an email or create a record).

6. Connect the action account and confirm permissions.

7. Map fields from the trigger sample to the action fields. Keep it minimal on the first pass.

8. Test the action and verify the data flowed correctly end‑to‑end.

9. Publish the Zap and watch the first few runs so you can catch edge cases.

Tiny tips: prefer instant triggers; keep a dedicated “test record”; only map what you truly need at first; expand once it works.

Formatter by Zapier (clean & transform data)

Use Formatter to reshape data between steps so downstream actions don’t break.

Common moves:

• Text: split full names, trim whitespace, extract order IDs, proper‑case.

• Dates/Times: convert formats and time zones, calculate relative dates.

• Numbers: round, format currency, sanitize phone numbers.

• Utilities: lookup tables to standardize values; line‑item helpers to prepare arrays.

Pro tip: run Formatter early to normalize inputs before branching or looping.

Filters & Paths (conditional logic)

Filters stop a run unless conditions pass. Paths branch a run into A/B/C flows based on rules.

Use cases: route VIPs to a special sequence; skip weekends or holidays; split by territory, product, or status without custom code.

Build pattern: place Filters right after the trigger to avoid unnecessary downstream work; use Paths when you truly need separate sequences.

Delay by Zapier (timed pauses & throttling)

Pause a run for a period, until a date/time, or after queue to serialize bursts.

Use cases: gently space outreach; wait two hours before a follow‑up; throttle calls to rate‑limited services; ensure updates post in order.

Tip: pair Delay After Queue with a stable record key so related updates queue together.

Looping by Zapier (repeat steps for each item)

Loop over a list so downstream steps run once per item.

Examples: send one message per assignee; create one invoice line per product; iterate uploaded CSV rows.

Tip: feed Looping a clean array. If your source is a messy string, normalize it first with Formatter.

Digest by Zapier (batch notifications)

Collect items across the day or week and release a single summary on a schedule.

Examples: 5pm daily lead digest to Slack and email; weekly bug summary; payout rollups.

Tip: set clear titles for each digest so they’re easy to filter in your destination.

Storage by Zapier (lightweight state & counters)

A tiny key‑value store to share small data between runs.

Great for: running counters (invoice numbers), dedupe caches (“seen” IDs), last processed timestamps, and feature flags.

Guardrails: keep keys short and values small. For bigger data, pivot to a spreadsheet or database.

Email Parser by Zapier (turn emails into fields)

From the Chatham Oaks walkthrough: create a Parser mailbox, send a test email, then highlight the pieces you want as named fields and save the template. Improve accuracy by marking early parses as accurate or inaccurate and maintaining extra templates whenever the sender’s format varies.

Flow idea: Parser → map fields → create or update a CRM contact → notify a channel → include in a daily Digest summary.

Tips from the post: rename mailboxes for clarity; add multiple mailboxes to organize sources; treat the first few emails as training data.

Scheduler by Zapier (time‑based triggers)

From the Chatham Oaks guide: pick a cadence (hourly, daily, weekly, monthly), set constraints (time of day, day of week), test the trigger, then add any downstream action.

Examples: schedule a social post at the right hour; send a newsletter while you’re out; move data from one source to another on a set rhythm; coordinate an omni‑channel launch.

Tip: combine Scheduler with Filters/Paths to avoid firing on holidays or outside business hours.

Sub‑Zaps (reusable building blocks)

Chatham Oaks breaks this into two parts: the Sub‑Zap itself and the Main Zap that calls it.

Build the Sub‑Zap:

1. Add Start a Sub‑Zap as the trigger.

2. Define the Input/Argument List (named inputs passed from the main Zap).

3. Add the steps that do the work (lookups, transforms, approvals, enrichments).

4. Add Return from Sub‑Zap as the action and name each Output/Return Value you’ll hand back.

5. Test in isolation if possible.

Call from the Main Zap:

• Add Call a Sub‑Zap, choose the Sub‑Zap, pass inputs, and then use the returned outputs in later steps.

When to use it: anytime logic will be reused across multiple Zaps or you want to keep a long Zap tidy and maintainable.

API Request & Webhooks (talk to any endpoint)

When a native action is missing, use API Request actions (available in many app connectors) to call that app’s endpoints using your existing authentication, or use Webhooks to catch or send generic HTTP requests.

Examples: update a custom field not exposed by the default action; trigger a bulk endpoint; accept inbound webhooks from your site and fan out to multiple destinations.

Tip: validate required headers and rate limits; log responses for troubleshooting.

Human‑in‑the‑Loop (approvals & data collection)

Insert a human pause for review, approval, or data correction; resume the run based on the decision.

Use cases: manager approves discounts; agent fills in missing fields before a CRM upsert; legal signs off on copy before publishing.

Tip: pair with Paths so an approval of “deny” routes to a different sequence than “approve.”

Code & Functions (custom logic when you need it)

• Code: run quick JavaScript or Python snippets for transforms you can’t do elsewhere (regex, compact algorithms, one‑off math).

• Functions: reusable, more robust Python in a managed environment with packages and secrets; call from Zaps like any action.

Tip: keep code small and well‑commented; if it grows, promote it to a Function or a Sub‑Zap.

Custom Actions

Why they matter: they bridge gaps when an app’s built‑in actions don’t offer the exact behavior you need. They’re configured right in the editor, can be shared across Zaps and teammates, and rely on the same authentication you already use.

Where they shine: adding a bespoke approval step into your chat tool; transforming data exactly how your CRM expects it; interacting with internal or less common endpoints without hand‑coding an integration.

Team benefit: one well‑made Custom Action replaces scattered workarounds across multiple Zaps and reduces maintenance.

Putting it all together (3 fast blueprints)

1. Lead‑to‑CRM with zero duplicates
   Trigger: Email Parser → Formatter (cleanup) → Storage (dedupe key) → Filter (skip if seen) → CRM create/update → Digest (daily 5pm summary).

2. Weekly ops runbook
   Trigger: Scheduler (Mon 8:00) → Sub‑Zap “Build Agenda” (lookups, formatting) → Looping (one message per owner) → channel posts → email copy to stakeholders.

3. Fill a missing integration step
   Trigger: App event → API Request to perform the unsupported action → Human‑in‑the‑Loop approval → update destination app → include in a weekly Digest.

FAQ

What is a Zap?
A Zap connects a trigger to one or more actions. When the trigger fires, the actions run using mapped fields.

Do steps like Formatter, Filters/Paths, or Looping count toward task usage?
These steps themselves generally do not create additional tasks; the actions you actually run afterward do. Always check your current plan details.

How long can a Delay hold my run?
Delays are designed for short‑term scheduling and throttling. Use them to space actions or ensure ordered updates.

What are Storage limits?
Storage is a lightweight key‑value store intended for small payloads and short keys. For larger data, move to a spreadsheet or database.

Is Email Parser an instant trigger?
Yes. Once the mailbox receives a message, the Zap can fire immediately.

Can Scheduler run hourly, daily, weekly, and monthly?
Yes. Choose the cadence and set constraints like the time of day or day of week.

When should I use Paths vs. Sub‑Zaps?
Use Paths for branching inside a single Zap. Use Sub‑Zaps to centralize reusable logic you’ll call from multiple Zaps and then return outputs.

What’s the difference between Delay and Digest?
Delay pauses a single run; Digest collects multiple items and releases them as a single summary on a schedule.

What if my app is missing an action?
Use API Request actions or generic Webhooks. If available, create a Custom Action you can reuse across Zaps.

Can I add custom code to a Zap?
Yes. Use Code for quick snippets or Functions for more robust, reusable logic.