Make.com & Zapier Workflows

Make.com (formerly Integromat) uses a visual canvas where your automation appears as a flowchart of connected circles called modules. Every scenario starts with a trigger module on the left and flows right through action modules. Branches, routers, and iterators extend the canvas in multiple directions, giving you a spatial representation of your logic that is far easier to audit and debug than a linear list of steps.

The fundamental unit in Make is the module, not the action. Each circle on your canvas is a module: a trigger, a search, a create, an update, or a utility operation. A scenario that reads a Google Sheet row, looks up a contact in HubSpot, and sends a Slack message uses three modules. This matters because Make bills by operations rather than by task executions. Each module run in a scenario consumes one operation, so a scenario that processes 100 rows through 3 modules consumes 300 operations. Understanding this before you architect a scenario prevents unexpected billing surprises.

The free plan gives you 1,000 operations per month with scenarios that run no more frequently than every 15 minutes. The Core plan at $9/month lifts the interval to 1 minute, adds 10,000 operations, and allows up to 3 active scenarios. For client work, the Pro plan at $16/month or Team plan at $29/month are typically the right tiers - they add more operations, team member access, and scenario scheduling flexibility.

Make scenarios have two key settings that affect how they process data. Sequential processing runs bundles one at a time in strict order, which is necessary when the order of operations matters (like processing invoices in chronological sequence). Parallel processing runs multiple bundles simultaneously, dramatically speeding up bulk operations but requiring that each bundle is independent. For most client scenarios, parallel processing is the right default.

The Router module is Make's branching mechanism. It splits a scenario into multiple paths based on conditions, similar to n8n's IF node but with the ability to add many paths visually. Each path has a filter that defines which bundles travel down it. A router might send premium customers down one path that creates a HubSpot deal and triggers a personalized email sequence, and free customers down another path that just adds them to a Mailchimp list.

Make's most valuable advanced feature for agency work is the Iterator and Aggregator pair. Iterators break an array down into individual items so you can process each one separately, and Aggregators collect the results back into a single bundle. The pattern appears everywhere: iterate over each line item in an order to check inventory, aggregate the results into a fulfillment summary, then send that summary to a warehouse system. Once you understand this pattern you will reach for it constantly.

The HTTP module connects Make to any API without a native module - and there are thousands of SaaS tools with undocumented or unofficial APIs that work perfectly with a simple HTTP GET or POST. When a client uses a niche CRM or industry-specific platform that does not appear in Make's module library, the HTTP module combined with the platform's API docs is your path to integration. Configure the URL, method, headers (usually an Authorization header with the API key), and body, then map the response fields to downstream modules.

Make's ChatGPT and OpenAI modules add AI reasoning to any point in a scenario. The most practical pattern for agency work is AI-assisted data extraction: a client sends an email with unstructured text (a vendor quote, a customer complaint, a meeting summary), and a Make scenario passes that email body to GPT with a prompt like "Extract the vendor name, quoted price, and delivery date from this text and return them as JSON." The extracted fields then flow into a Google Sheet row or CRM record automatically. This eliminates manual data entry from a category of tasks clients genuinely hate.

For Stripe and payment workflow integrations, Make handles the common patterns cleanly. Watch for new Stripe payment events, create corresponding rows in a Google Sheet or records in a CRM, trigger a Slack notification to the sales team, and kick off a customer onboarding email sequence. The Stripe webhook in Make activates instantly on payment events, so these scenarios fire within seconds of a successful charge. A client whose sales team previously checked Stripe manually every few hours gets immediate, automatic notification for every payment.

When delivering Make scenarios to clients, create a dedicated Make organization for each client and transfer the scenario ownership there before the engagement ends. Scenarios built in your agency account under your subscription cannot be easily migrated to a client's account after the fact. Start every client project in their organization from day one to avoid this problem.

Zapier's simplicity is its main advantage for clients who will manage their own automations after you build them. The interface is genuinely approachable for non-technical users, the app library is the largest in the category (6,000+ integrations), and the documentation for common app connections is extensive and well-maintained. When a client wants to own and modify their automations themselves, Zapier is usually the right choice.

Every Zap starts with a trigger - an event in one app that starts the automation. New email received. Form submitted. Deal stage changed in a CRM. New row added to a spreadsheet. Zapier's trigger library covers virtually every event type across major business applications. The second step is one or more actions - things Zapier does in response to the trigger across other apps.

Multi-step Zaps chain multiple actions together. A single trigger can kick off five, ten, or twenty sequential actions. A new Typeform submission might trigger: add to Mailchimp list, create contact in HubSpot, send a Slack notification, add a row to Google Sheets, and send a welcome email via Gmail - all automatically. Each action runs in sequence, and the data from earlier steps is available to map into later ones.

Filter steps are how you add conditional logic to a Zap. A Filter stops the Zap mid-execution if a condition is not met. Add a Filter step after your trigger and set the condition: "Only continue if the form response includes a company with more than 50 employees." Submissions from solo freelancers stop at the filter and nothing downstream runs. Submissions from qualifying companies continue through all the actions. Filters are binary - continue or stop - and that covers a surprisingly large percentage of the conditional logic clients actually need.

Formatter is Zapier's built-in data transformation utility. It handles the formatting work that would otherwise require custom code: splitting a full name into first and last name fields, converting a date to a different format, capitalizing text, extracting a number from a text string, looking up a value in a list. Formatter steps sit between your trigger and actions and reshape data into whatever format the downstream actions expect. Most real-world Zaps need at least one Formatter step because data rarely arrives in exactly the format your destination app requires.

The make-vs-zapier-vs-n8n decision comes up in every client conversation, and having a clear decision framework protects you from over-engineering or under-delivering. The choice comes down to three variables: who will maintain the automation after delivery, how complex the logic is, and what the client's budget tolerance is.

Use Zapier when the client will own and manage the automation themselves and has no technical staff. Zapier's interface is genuinely self-service for non-technical users. When a Zap breaks or a new app needs to be added, a business owner with no automation background can usually figure it out with the documentation. The per-task pricing is higher than Make or n8n, but for low-volume automations the monthly cost is predictable and modest. Zapier is also the right choice when the integration the client needs is niche or obscure - Zapier's 6,000+ app library has a much wider coverage tail than Make's.

Use Make when the automation involves complex multi-step logic, data transformation, or AI modules, and the client has a slightly technical person who can manage it or is comfortable with you on a maintenance retainer. Make's visual canvas makes complex scenarios easier to understand than Zapier's linear editor, and the operations-based pricing is significantly cheaper for high-volume automations. Make is also the right choice when the client needs custom error handling paths and scenario versioning.

Use n8n when you are building something the client pays you to maintain, when the automation requires self-hosted data control, when AI agent capabilities are central to the use case, or when the client's volume would make Zapier or Make prohibitively expensive. n8n's monthly cost is fixed (the VPS cost) regardless of execution volume, which makes high-frequency workflows dramatically cheaper at scale.

White-labeling considerations matter when you want the automation platform to feel invisible to the client. n8n supports white-labeling the UI with custom branding on enterprise plans. Make and Zapier do not offer white-labeling, so the client sees the Make or Zapier interface if they ever need to access it. For clients who care about a seamless brand experience, n8n on a custom-branded subdomain is the cleanest option. For clients who just want the automation to work, the platform brand is irrelevant and choosing based on feature fit is the right priority.