The verdict, up front: If your team can read JSON and isn’t scared of branching logic, use Make. If your team is non-technical and you mostly need “when X happens in Slack, do Y in HubSpot,” use Zapier. If you’re a SaaS team building the product itself, you’ll probably end up using both for different jobs — and that’s fine.
This is a comparison from a builder team that runs both tools in production every day, not from someone who set up “Hello World” once and called it a review.
Where Make wins (and why we use it for production workflows)
Make (formerly Integromat) is what you reach for when “send the data through” needs to actually mean “transform, branch, retry, and observe.” Three things make it our default for any SaaS-backed automation:
- JSON manipulation is first-class. You can drill into nested fields, map across arrays, and reshape payloads without a single workaround. Zapier needs Code steps for the same thing.
- Branching logic is visible. Make’s flowchart-style canvas lets you see at a glance what happens when a condition is met versus not. With Zapier you’re scrolling through steps trying to remember which path you’re in.
- Error handling is a real concept. Add a Break or Resume directive on any module. Configure exponential backoff. Route failures to a different path. Native, not a plugin.
We use Make for:
- Inbound webhook routing — Stripe events, GitHub webhooks, Sentry alerts that need transformation before landing in our internal Slack or DB.
- Cross-system reconciliation — e.g., when a customer signs up, create the workspace in our app, send to HubSpot, post to Slack, generate a welcome email.
- Daily ETL micro-jobs — pulling from a SaaS API, transforming, pushing into BigQuery or Postgres for our own analytics.
The flip side: Make’s UX is denser. New users routinely take a week to internalize the module/scenario/router/aggregator vocabulary. The learning curve is real.
Where Zapier wins (and why we still keep it around)
Zapier won the automation category by being approachable. The Zap creation flow is so frictionless that a marketing intern can build something useful in 20 minutes. Three things keep us coming back:
- The integration catalog is wider. Zapier supports more SaaS apps than Make — especially long-tail tools that haven’t built out a Make module yet. If “we need to connect FancyNewSaaS to our spreadsheet” is the requirement, Zapier wins by default.
- Onboarding non-technical teammates. Sales and customer success teams can build their own Zaps without engineering escalation. We never see them attempt the same thing in Make.
- “Quick and dirty” prototypes. When we want to validate a workflow idea before committing to it — e.g., “does this notification flow even make sense?” — Zapier’s drag-and-drop is faster than Make’s canvas.
We use Zapier for:
- Internal team notifications that don’t need transformation logic — “new lead in Pipedrive → ping #sales-leads.”
- Quick prototypes we’ll either delete or rebuild in Make once the workflow is validated.
- Connections to obscure tools Make doesn’t support yet.
Side-by-side at a glance
| Make | Zapier | |
|---|---|---|
| JSON / array transforms | Native, intuitive | Requires Code steps |
| Branching + routers | First-class, visual | Linear flow with Paths add-on |
| Error handling | Configurable per-module | Limited; mostly retry-and-fail |
| App catalog size | ~1,800 apps | ~7,000 apps |
| Learning curve | Steep (~1 week) | Gentle (~30 min) |
| Pricing for 10K ops/month | ~$16/mo (Core) | ~$50/mo (Professional) |
| Webhooks (custom) | Native, no extra cost | Premium plan only |
| Scenario versioning | Built-in revision history | Limited |
Pricing reality at small-team scale
Both have free tiers. Both punish you the moment you have any real volume. Make is dramatically cheaper at the same operations count — this is one of the bigger sleeper reasons we use it for production.
- Make Core: ~$10.59/month for 10,000 operations annual. Their pricing scales linearly with operations rather than complexity.
- Zapier Professional: ~$49/month for 2,000 tasks annual. Multi-step Zaps and premium apps are gated above the Starter tier.
If you’ll run more than 5,000 ops/month, Make pays for itself many times over. If you’re running fewer than 100 ops/month, Zapier’s free tier and faster setup might be the right call.
When you’d skip both
For high-volume, low-latency workflows, both tools become expensive and fragile. If you’re moving more than 100,000 events/month or need sub-second processing, you should be writing a small Cloudflare Worker or AWS Lambda — not paying per-operation to Make/Zapier.
The mental model we use: “Will I be running this in 6 months?” If yes, it probably belongs in code. If no, it belongs in Make or Zapier — whichever maps to your team’s technical comfort.
Our actual stack at MAS Tradtech
We use:
- Make for ~80% of our automation: webhook processing, cross-system reconciliation, daily ETL jobs, anything our customers depend on.
- Zapier for ~20%: internal team notifications, quick prototypes, and connecting to long-tail tools we don’t want to wait on Make to support.
If we had to pick one and only one:
- If your team is engineering-heavy and you’ll touch more than 1,000 ops/month, pick Make.
- If your team is mostly non-technical and you mostly want simple “when X, do Y” automations, pick Zapier.
This post contains affiliate links to Make and Zapier. If you sign up through these links, we may earn a commission at no extra cost to you. Our editorial integrity is not affected by these relationships — we run both tools in production every day and would write the same review without them. Full disclosure on our Affiliate Disclosure page.
— The MAS Tradtech Team