Make.com Automation Tutorial — Complex Workflows Guide

Make (formerly Integromat) is a visual automation platform that lets you build workflows — Make calls them "scenarios" — with branching logic, loops, and error handling that most beginner-friendly tools either can't do or charge extra for. This tutorial builds a real scenario from scratch: a form submission that routes to different actions depending on the value entered, the kind of conditional logic that trips up simpler tools. By the end, you will understand not just the click-by-click steps but the underlying execution model, so you can build your own scenarios instead of copying templates.

What makes Make different from a basic trigger-action tool

Most no-code automation tools follow a simple pattern: something happens, then one thing happens in response. That covers a lot of ground, but it breaks down the moment your workflow needs to make a decision. "If the order is over $500, do this; otherwise, do that" is a branch, and branches are where cheap automation tools either charge a premium or simply refuse to cooperate.

Make was built around a visual canvas where modules connect via lines, and those lines can carry filters, routers, and loops natively. Zapier, historically the market leader, added conditional paths later and gates some of them behind higher-tier plans. Make bakes branching into the free tier's core mental model, per Zapier's own comparison of Make pricing, which acknowledges Make's cost advantage for logic-heavy use cases even while promoting its own product.

The practical result: a marketing operations person building a lead-scoring workflow, a solo e-commerce owner routing high-value orders differently from standard ones, or an agency managing dozens of client intake forms will hit fewer walls in Make before needing to write custom code.

Make's 2026 pricing overhaul renamed its billing unit from "operations" to "credits," but the accounting logic stayed close to the original: most standard module executions still cost one credit each, while AI and code-execution modules cost more. The free tier remains capped at 1,000 operations per month, per [Make.com pricing breakdowns tracked in mid-2026](https://thedigitalprojectmanager.com/tools/make-pricing/).

Why choose Make over Zapier: the honest trade-off

Before building anything, it helps to understand what you are trading. Make is not simply "Zapier but cheaper" — it asks more of you upfront in exchange for lower long-term cost and more flexibility.

Think of Zapier as an automatic transmission car: point it in a direction, and it handles the mechanics with minimal input. Make is more like a manual transmission with a torque display: you have direct control over exactly how power flows through the system, but you need to understand gears to use it well. Neither is objectively better — the right choice depends on whether your workflows need that control.

Table 1. Make vs. Zapier — feature and pricing comparison (2026)

Category	Zapier	Make
Starting paid tier	roughly $19.99–29.99/mo (Starter)	roughly $9–10.59/mo (Core)
Free tier task/op cap	100 tasks/month	1,000 operations/month
Native conditional branching	Paths feature, limited on lower tiers	Filters + Router, available from free tier
Native loops	Requires paid "Looping by Zapier" add-on	Built-in Repeater/Iterator, no add-on
App integrations	8,000+	2,500+
Visual workflow canvas	Linear list view (Canvas view added 2024)	Node-and-line canvas by default
Best fit	Non-technical users, breadth of integrations	Users comfortable with modules who want logic control and lower cost

Sources: Zapier and Make public pricing pages as summarized by Zapier's Make pricing analysis and DoIT Software's 2026 platform comparison.

Zapier's integration count is genuinely larger, which matters if you rely on a niche app that only Zapier supports. But for the mainstream tools most small businesses actually use — Google Workspace, HubSpot, Slack, Stripe, Shopify — both platforms cover the same ground, and the deciding factor becomes logic complexity and cost.

What does "operations" or "credits" actually mean in Make's pricing?

An operation (now sometimes called a credit) is counted each time a module in your scenario runs, not each time the whole scenario runs. A scenario with five modules that executes ten times in a month uses roughly 50 operations, not 10. This matters because a workflow that looks simple on the canvas can consume far more of your monthly allotment than expected if it has many steps or runs frequently.

Building your first scenario: a conditional lead-routing workflow

This walkthrough builds a workflow that watches a Google Form for new submissions, checks the dollar amount entered, and routes high-value leads to a CRM while sending lower-value leads a follow-up email. This is a genuinely common small-business pattern — sales teams do not want their CRM cluttered with every $50 inquiry, but they also do not want to manually triage every submission.

Step 1: Create your account and first scenario

Go to make.com and click "Sign up free." You will need an email address, a password, and an organization name — no credit card is required for the free tier. Once inside the dashboard, click "Create a new scenario" and name it something specific, like "Form to CRM — Lead Scoring," rather than "Scenario 1." You will thank yourself later when you have a dozen scenarios running.

You land on an empty canvas with a plus sign in the center. Every Make scenario starts from this blank state: you add a trigger module first, then chain actions, filters, and routers off of it.

Step 2: Connect the trigger

Click the plus sign, search "Google Forms," and select "Watch Responses." Make will ask you to sign in with Google and authorize access — this is a standard OAuth flow, the same mechanism your browser uses when you "Sign in with Google" on any third-party site. Select the specific form you want to watch, or create a quick test form with a name field, an email field, and a numeric amount field if you do not have one handy.

Once connected, Make polls that form on whatever schedule you set later. It does not need the form to "push" data to Make; Make checks in.

Step 3: Add a filter for conditional logic

This is the step where Make's architecture pays off. Hover over the connector line below your trigger module and click "Add a filter," which appears directly on the line. Set the condition: left side is the amount field from your form, the operator is "greater than," and the right side is 1000.

The logic Make executes here is straightforward:

If amount > 1000 → continue down this path
If amount ≤ 1000 → this path stops; a separate branch handles it

Filters in Make are attached to connections between modules, not to the modules themselves, which is a subtle but important distinction. It means the same trigger can feed multiple different filtered paths simultaneously, each evaluating independently.

Step 4: Build the high-value path (CRM deal creation)

After the filter, click the plus sign to add an action. Search "HubSpot" (or your CRM of choice — Pipedrive and Salesforce work the same way), select "Create a Deal," and authorize the connection. Map your fields: deal name pulls from the form's name field, the amount maps directly, and you can hardcode a deal stage like "Negotiation/Review" for anything that clears your threshold.

Table 2. Field mapping for the HubSpot deal-creation module

HubSpot field	Source
Deal name	{{name}} + " — Deal"
Amount	{{amount}}
Deal stage	"Negotiation/Review" (static)
Contact email	{{email}}

Caption: Curly-brace syntax in Make references data pulled from earlier modules in the scenario — a pattern shared with most no-code platforms.

Step 5: Build the lower-value path (automated email)

Go back to the connector coming off your trigger and click on the other branch (the one where the filter condition was not met, or build a second explicit filter for "amount ≤ 1000"). Add a Gmail module, select "Send an Email," and configure it to send to {{email}} with a subject like "Thanks for your interest" and a short templated body referencing the submitter's name.

This is the branch that keeps your CRM clean: leads under the threshold get acknowledged automatically without a human — or your CRM's storage — ever touching them.

Step 6: Test before you go live

Click "Run once" in the top-left corner. Make executes the scenario using either live data (if a real form submission is waiting) or a sample you provide, and each module lights up green on success or red on failure. Check both downstream systems: did HubSpot actually create the deal, did Gmail actually send the email. If a module fails, the two most common causes are an expired authorization (re-authenticate the connector) or a field mapping typo (the variable name in curly braces has to match exactly).

Step 7: Activate and set your polling interval

Toggle "Scheduling" in the bottom left to "On," and choose how often Make checks for new form responses. Every minute gives the fastest response time but consumes your operations budget faster since every check counts, whether or not it finds new data on some plans, so many users choose a 15-minute interval for non-urgent workflows. Flip the master toggle in the top right to activate, and your scenario now runs unattended.

Beyond filters: routers, loops, and error handling

A single filter gets you two paths: yes or no. Real business logic often needs more than two branches, and this is where Make's Router module becomes genuinely more capable than most competing tools at the same price point.

How does Make's Router module handle more than two conditions?

The Router module replaces a simple filter with multiple named routes, each carrying its own condition, all branching from a single point on the canvas. For a three-tier lead-scoring system — VIP, standard, and low-priority — you would add a Router after your trigger, then define three routes: one where amount is $5,000 or more, one where it falls between $1,000 and $4,999, and one where it is under $1,000. Each route connects to its own chain of actions, and Make evaluates all of them, sending the item down whichever route's condition matches.

This differs from a chain of nested if/then filters in an important way: the routes are visually parallel on the canvas, which makes a five- or six-branch workflow much easier to audit at a glance than a nested chain would be.

What are Repeater, Iterator, and Aggregator modules used for?

These three modules handle a category of task that trips up beginners because it does not map neatly to "if this, then that." A Repeater runs a bundle of actions a fixed number of times — useful for sending the same notification to five team members. An Iterator breaks an array (say, twenty rows returned from a spreadsheet) into individual items so the rest of the scenario can process them one at a time. An Aggregator does the reverse: it collects multiple items back into a single bundle, useful when you have processed twenty rows individually and now want to email a single summary report rather than twenty separate emails.

Table 3. Make's core module types and their function

Module type	What it does	Typical use case
Trigger	Starts the scenario when new data appears	New form response, new email, new payment
Filter	Evaluates a single condition on a connector line	"Continue only if amount > 1000"
Router	Splits into multiple parallel conditional paths	VIP / standard / low-priority routing
Repeater	Runs a set of actions a fixed number of times	Send the same alert to 5 team members
Iterator	Breaks an array into individual items	Process 20 spreadsheet rows one by one
Aggregator	Combines multiple items into a single bundle	Turn 20 processed rows into 1 summary email
Error handler	Catches a failure and defines a fallback action	Retry a failed API call, then alert Slack if it fails again

Caption: These seven module types cover the large majority of logic patterns needed in a typical small-business automation stack.

How does error handling work in Make compared to Zapier?

Every module in a Make scenario can have an error handler attached directly to it — right-click the module and add one. You can configure Make to retry the failed step automatically after a delay, ignore the error and continue, resume from a specific point, or stop the whole scenario and alert you. This granularity, attached per-module rather than as a single global setting, is one of the more meaningful differences from Zapier, where error handling historically has been less configurable at the individual-step level, according to comparisons from DoIT Software's 2026 platform breakdown.

In practice, this means a scenario with ten steps and one flaky API call does not need to fail entirely just because that one step occasionally times out. You can tell Make: retry this specific module three times with a 30-second gap, and only alert me if all three attempts fail.

A realistic multi-branch example: e-commerce order processing

Small demonstrations are useful for learning the interface, but the value of Router-based branching becomes clearer at slightly larger scale. Consider an online store that wants different handling for VIP orders versus regular ones:

Trigger: Shopify → New Order
│
├─ Router splits by order value
│
├─ Route A: order ≥ $500 (VIP)
│    ├─ Create deal in Pipedrive
│    ├─ Send VIP thank-you email
│    └─ Post notification in Slack #vip-orders
│
└─ Route B: order < $500 (Standard)
     ├─ Create contact in HubSpot
     ├─ Send standard confirmation email
     └─ Log order to Google Sheets

This scenario runs six actions across two branches every time an order comes in, but because Make only counts the operations that actually execute — a standard order never touches the Pipedrive or Slack modules — the operations cost stays proportional to actual usage rather than the theoretical maximum complexity of the scenario. Building the equivalent workflow in a tool without native branching typically means either duplicating the entire automation twice (once per condition) or paying for a premium "Paths" add-on, both of which inflate cost and maintenance burden.

Make pricing in practice: what a real workflow costs

Pricing pages rarely tell you what you will actually pay once a scenario is live and processing real volume, so it helps to work through a concrete estimate.

Table 4. Make pricing tiers and realistic monthly capacity (2026)

Plan	Monthly cost (approx.)	Operations/credits included	Realistic capacity
Free	$0	1,000	Testing, one light scenario
Core	~$10.59	10,000	2–4 small automations
Pro	~$18.82	Higher tier limits, adds priority support	5–10 automations with moderate volume
Teams	~$34.12	Higher tier limits, adds collaboration features	Multiple team members, 10+ automations
Enterprise	Custom	Custom	High-volume, SLA-backed deployments

Source: pricing figures as tracked by The Digital Project Manager's 2026 Make pricing guide and Zapier's comparative analysis of Make; confirm current figures on Make's official pricing page before budgeting, as SaaS pricing tiers change frequently.

Using the six-module e-commerce scenario above as a worked example: if the store processes 2,000 orders a month split evenly between the two branches, that is roughly 2,000 trigger executions plus 2,000 router evaluations plus 3,000 downstream action executions (three actions per VIP order, three per standard order), landing somewhere around 7,000–8,000 operations for the month. That fits comfortably inside the Core plan's 10,000-operation allowance, whereas the same logical workflow on a per-task pricing model with add-on-gated branching could cost substantially more.

Make vs. Zapier vs. n8n: choosing the right tool for your team

Make is not the only alternative to Zapier, and it is worth being honest about where it sits relative to the third major option, n8n, an open-source workflow tool that has gained significant traction with technical teams.

Table 5. Three-way platform comparison

Factor	Make	Zapier	n8n
Conditional logic	Strong (Filter + Router native)	Improving (Paths, gated on some tiers)	Strong, full code access
Pricing model	Per-operation	Per-task	Per-workflow-execution (self-hosted: free)
Learning curve	Moderate — visual but requires understanding modules	Low — most linear and beginner-friendly	High — expects comfort with JSON/code
App integrations	2,500+	8,000+	400+ native, extensible via code
AI-native features (2026)	AI Agents (GA early 2026), Maia assistant in early access	Copilot, autonomous Agents across 8,000+ apps	LangChain integration, 70+ AI nodes, persistent agent memory (n8n 2.0, Jan 2026)
Cost at high volume	Moderate	Highest at scale	Lowest, especially self-hosted
Best for	Teams wanting visual logic control without code	Non-technical users prioritizing integration breadth	Developers and technical teams wanting maximum control and lowest cost at scale

Source: feature and AI-capability claims per DoIT Software's n8n vs. Make vs. Zapier comparison and Intuz's 2026 detailed guide, both published in 2026.

Cost researchers at DoIT Software found that for complex, high-volume workflows, n8n can run 80–90% cheaper than Zapier for a ten-step workflow executed 10,000 times a month, because n8n bills per workflow execution rather than per individual task or operation — but that cost advantage comes with a much steeper technical learning curve, since n8n expects users to be comfortable working with JSON payloads and, often, custom code nodes. Make sits in between the two: it delivers roughly 60% lower cost than Zapier for comparable logic-heavy workflows, per the same analysis, while keeping the visual, no-code interface that Zapier users expect.

If you are choosing among the three, the honest framework is this: pick Zapier if breadth of integrations and zero learning curve matter more than cost or logic depth. Pick Make if you want visual branching, loops, and error handling without writing code, and you are willing to spend 30 minutes learning the module system. Pick n8n if your team has developers on it and you are optimizing for cost at meaningful scale.

Common mistakes people make when starting with Make

A recurring failure pattern for beginners is treating Make like Zapier — expecting a single linear chain — and never using the Router or Filter modules at all, which erases the main reason to choose Make over a simpler tool in the first place. If your scenario is a straight line with no branches, you are likely paying for capability you are not using.

Another frequent mistake is leaving the polling interval at its most frequent setting (every minute) on every scenario, regardless of urgency. A newsletter signup form does not need minute-by-minute polling the way a payment webhook does; matching interval to actual urgency conserves your monthly operations budget meaningfully over a full month.

A third mistake is skipping the "Run once" test step before activating a scenario. Because Make scenarios often touch two or three external systems (a form, a CRM, an email provider), a single field-mapping typo can silently create malformed CRM records or send broken emails to real customers for days before anyone notices. Testing with sample data first catches the majority of these errors before they touch production data.

Finally, many users under-map error handling, leaving Make's default behavior (which typically stops the entire scenario on the first unhandled error) in place even for external API calls that are known to be occasionally flaky, like third-party rate-limited APIs. Attaching a retry-with-delay handler to those specific modules, rather than accepting default behavior, prevents a single transient network blip from silently halting an otherwise healthy automation.

Setup checklist

• Account created on make.com
• Trigger app (Google Forms, Shopify, etc.) authorized
• Downstream apps (CRM, Gmail, Slack) authorized
• Filter or Router configured with correct field names and operators
• Field mappings verified against actual form/source field names
• "Run once" test completed successfully on sample data
• Error handlers attached to any module calling an external API
• Polling interval matched to actual urgency
• Scheduling toggled on and scenario activated
• Real submission tested end-to-end after activation

FAQ

Q: Is Make.com the same company as Integromat? A: Yes. Integromat rebranded to Make in 2022 after being acquired by Celonis; the underlying platform and scenario-based architecture carried over, though the interface and feature set have expanded significantly since.

Q: Do I need to know how to code to use Make? A: No. The visual, module-based canvas covers the large majority of use cases without writing any code. Make does offer optional JavaScript and custom-function modules for advanced users who want to transform data in ways the built-in modules cannot handle.

Q: How many free operations does Make give per month? A: 1,000 operations (now sometimes labeled credits) per month on the free tier, according to Make's 2026 pricing structure as tracked by The Digital Project Manager. This is enough for light testing but most real business workflows outgrow it within the first month.

Q: What happens if a Make scenario runs out of operations mid-month? A: The scenario stops executing until either the next billing cycle resets your allowance or you upgrade your plan. Make does not silently overcharge you for overages the way some per-task tools do, but it also will not process new triggers until capacity is available again.

Q: Can Make connect to apps that don't have a pre-built module? A: Yes, through its generic HTTP and webhook modules, which let you call any REST API directly even without an official integration. This requires understanding basic API concepts like endpoints, authentication headers, and JSON payloads.

Q: Is Make better than Zapier for a total beginner with zero automation experience? A: Not necessarily. Zapier's linear, single-path interface is generally easier for a first-ever automation. Make becomes the better choice once your workflow needs a condition, a loop, or more than one possible outcome — logic that Zapier either restricts to higher-tier plans or requires paid add-ons to unlock.

Q: How does Make's Router module differ from just chaining multiple filters? A: A Router evaluates all of its routes from a single branching point on the canvas, making a multi-way decision visually explicit and easy to audit. Chaining individual filters accomplishes similar logic but spreads the decision across multiple sequential steps, which becomes harder to read as the number of conditions grows.

Q: Does Make support AI features in 2026? A: Yes. Make AI Agents became generally available in early 2026, buildable directly on the same scenario canvas as standard modules, and Make is rolling out an assistant called Maia that drafts scenario logic from plain-language descriptions, currently in early access, per DoIT Software's 2026 platform comparison.

Q: What's the single biggest reason to pick Make over n8n? A: The visual, no-code interface. n8n offers comparable or greater logic depth and typically lower cost at high volume, but it expects comfort with JSON structures and, for advanced cases, custom code — a barrier Make's module-based canvas avoids for non-developers.

The takeaway

Make earns its reputation as the more powerful sibling to Zapier by baking conditional logic, loops, and per-module error handling into its core architecture rather than treating them as premium add-ons. That power comes with a real cost: expect to spend meaningful time understanding modules, filters, and routers before a complex scenario feels intuitive, and expect to actively manage your operations budget as workflows scale. For anyone whose automations need to make decisions rather than just react, that trade-off is usually worth it.

---

Read next:

• Best Automation Tools for 2026 — Zapier vs Make vs n8n
• Zapier Step-by-Step Guide — First Automation in 15 Minutes
• Workflow Automation Examples — Real-World Use Cases
• API Basics for No-Code Automation — Webhooks Explained