What is Make

Make is a cloud-based visual automation platform, formerly known as Integromat. For a business owner, it is a way to remove manual data transfer between services - orders, stock, reports - wherever a process has several steps and conditions instead of a single action. Technically, you build scenarios from modules: data arrives from Gmail, a CRM, or a webhook, passes through filters and branches, and goes to Slack, Google Sheets, Notion, or any other service. Below is what the tool is, how much it costs to use, how it works, and how it differs from Zapier and n8n.

What is this project

Make (before 2022 - Integromat) is a SaaS no-code/low-code automation platform founded in the Czech Republic in 2012. Celonis acquired the company in 2020, and in 2022 the product was renamed to Make and rebranded. Today it is one of Zapier's main competitors in visual integrations: 1000+ apps, millions of scenarios, and a focus on complex data routing.

The idea behind Make is similar to n8n and Zapier, but the terminology is its own. Zapier calls it a "zap", n8n calls it a "workflow", Make calls it a scenario - a graph of modules. Each module is one action: read a row, send an HTTP request, transform JSON, branch the flow. Connections between modules show how data moves through the chain; the visual editor resembles a flowchart.

Make runs only in the cloud - there is no self-hosted version. That is a plus for teams without DevOps and a minus for those who need full control over data on their own server.

Why this matters to a business owner

For a business owner, Make is not a separate technology but a way to remove manual work wherever data has to pass through several steps and checks before landing in the right place: order - stock check - invoice - customer email - accounting entry.

Example: an online store handles 300 orders a month. A manager manually checks stock, prepares the invoice, and emails the customer - about 10 minutes per order, roughly 50 hours a month. At $12/hour that is about $600 a month of manual work. A Make scenario with a few conditions and API calls fits a $20-30/mo plan - the subscription pays for itself within the first month.

What this gives the business:

• No developer needed for complex logic - Router and Iterator replace the conditions and loops you would otherwise have to write in code.
• Fewer errors in multi-step processes - every step of the scenario runs the same way, without skipped checks or human oversight.
• Predictable costs as you grow - the plan is billed by operations, usage is visible in the dashboard, and you can forecast the monthly budget in advance.
• Faster reaction to conditional events - an order, ticket, or lead lands in the right branch immediately instead of waiting for manual sorting.

There is also what to weigh before subscribing: Iterator multiplies the operation count by the number of array elements, so on high volume the bill can grow faster than it looks at the start; all data passes through Make's cloud, which matters for regulated industries; and very complex business logic is still cheaper in code than assembled from dozens of modules. The "Who Make is for" section below can help you judge whether this is your case.

How a scenario is structured

In short: a scenario is a pipeline where data comes in from one service and a finished result goes out to another; what happens in between is described by the steps below.

A Make scenario consists of:

• Trigger - entry point: webhook, schedule, new email, event in Airtable, Stripe, etc.
• Modules - processing steps: filter, router, iterator, aggregator, HTTP, JSON parser.
• Connections - lines between modules; they carry bundles - data packages with named fields.

Data in Make is bundles (a data package with fields, e.g. one spreadsheet row or one email), not an array of items like in n8n. Each module receives one or more bundles, processes them, and passes them on. For batch operations you use Iterator - it splits an array into individual elements and runs each through its own branch.

Expressions and field mapping are done through the visual interface: you click a field from a previous module and insert it into the next. For complex logic there are built-in functions - similar to spreadsheet formulas - plus a JSON module for parsing and building structures without separate code.

Router is a strong side of Make: one data stream can be split into several branches by condition without duplicating the trigger. Filter cuts off unwanted bundles before expensive API calls - important with operation-based pricing.

Key features

Integrations

More than 1000 ready-made apps: Google Workspace, Slack, Notion, HubSpot, Shopify, Stripe, Telegram, Airtable, OpenAI, Anthropic, and hundreds more. If there is no ready connector - HTTP and Webhook cover any REST API. Make also supports OAuth for most popular SaaS without manual token setup.

Data Store

Data Store is built-in key-value storage inside Make. Useful for intermediate state: counters, ID cache, event deduplication, simple queues between scenario runs. For lightweight stateful logic you do not need an external database.

Error handling

Each module has configurable error handlers: ignore, retry with delay, go to a fallback branch. For production scenarios this reduces the risk of the whole chain failing silently because of one API timeout.

Templates and teams

Templates - ready-made scenarios from the community and the Make team. Teams let you share scenarios, credentials, and folders inside an organization. Organizations - for enterprise with SSO and centralized billing.

AI modules

Make added modules for OpenAI, Anthropic, Google Gemini, and other LLM providers. A typical pipeline: incoming webhook - text classification via GPT - Router by category - write to different spreadsheets or reply to the customer.

Make vs Zapier and n8n

Zapier - faster start for linear "if A then B" scenarios. Make - stronger where there are many branches, JSON work, and batch processing without writing code. n8n - the choice for self-hosting, unlimited webhooks on your own hardware, and full data control.

Who Make is for

Make fits well for scenarios such as:

• Marketing and sales ops - lead from a form - enrichment via Clearbit or HTTP - HubSpot record - Slack notification.
• E-commerce - Shopify order - stock check - invoice creation - customer email - sync with accounting.
• Content and media - RSS - keyword filter - post to social and Notion.
• Support - ticket from Zendesk - classification via LLM - routing to the right team.
• Mid-size teams without DevOps - visual automation out of the box without server administration or an in-house developer.

It fits less well if data cannot be stored in a third-party cloud, self-hosting is required, or operation volume is very high on a tight budget - then n8n on your own VPS is often cheaper.

How to get started

Minimal path:

1. Sign up at make.com - there is a free tier with an operation limit.
2. Create a scenario: choose a trigger (e.g. Webhooks - Custom webhook).
3. Add a processing module - Tools - Set variable or JSON - Parse JSON.
4. Add an action - Slack - Create a message or Google Sheets - Add a row.
5. Click Run once, send a test request to the webhook URL, check field mapping.
6. Enable Scheduling or leave the scenario active for a realtime trigger.

For production: set error handlers on critical modules, use Filter before paid API calls, monitor operations usage in the dashboard. Store credentials in the organization, not in a personal account of an employee who might leave.

Documentation: help.make.com. Active community - Make forum and templates in the gallery.

Summary

Make is a mature cloud visual automation platform with a strong focus on routing, batch processing, and JSON. It sits between simple Zapier and flexible self-hosted n8n: more control over data flow than linear zaps, but without running your own server.

If your integrations are chains with conditions, iterators, and several APIs without a dedicated backend developer - Make often pays off in build speed and having the whole scenario visible on one screen.

For a business owner, the key question is not "which modules does Make have" but how much an hour of manual multi-step processing costs the company and whether an operations-based plan pays off. For scenarios with conditions, loops, and several services the answer is almost always yes, and the subscription pays for itself within the first weeks of use.

If you need help with development, AI implementation, or website support for your project - contact me.

Frequently asked questions

Are Make and Integromat the same thing?

Yes. Integromat was renamed to Make in 2022 after rebranding under Celonis. The functionality is the same: scenarios, modules, operations. Old links and docs gradually moved to make.com; if you see Integromat mentioned in articles or courses - that is today's Make.

How much does Make cost?

There is a Free plan with a limited number of operations per month - enough for experiments. Paid plans start at around $9/mo (Core) and scale by operations and run frequency. Each module in a scenario usually counts as one operation; Iterator multiplies operations by the number of elements. For a business, this means costs are predictable at the start, but you should plan for the bill to grow with scale - before that happens, run the scenario in test mode and check real usage in History.

Do you need to know how to code to use Make?

No, for most scenarios: choosing modules, triggers, and field mapping is done in the visual interface with clicks. For edge cases - custom HTTP headers, non-trivial JSON assembly - basic understanding of REST APIs and data structures helps, but a dedicated developer usually isn't required. In-house code is only needed when the logic goes beyond what Router, Iterator, and the JSON module cover.

How is Make better than Zapier?

Make is stronger in complex scenarios: Router, Iterator, Aggregator, visual JSON mapping, Data Store. Zapier is easier for beginners and faster for "one trigger - one action". On higher tiers Zapier added Paths, but Make's visual model was built for non-linear flows from the start. On price for simple scenarios the difference depends on steps and operations - Make is often better for batch processing, Zapier for rare linear zaps.

Can Make be self-hosted?

No. Make is SaaS only. Data and scenario execution run in Make's infrastructure (cloud). If you need self-hosting and full control - look at n8n or your own scripts. Make is chosen when time-to-market and no DevOps matter more than local data storage.

Is it safe to store API keys in Make?

Credentials in Make are stored encrypted and tied to an organization or account. Recommendations: use Teams/Organizations, grant access by role, do not share scenarios with credentials externally, enable 2FA on the account, for webhook triggers - verify signature or secret in the first Filter module. For sensitive data (personal data, finance) check DPA and storage region against company policy - Make processes data as a processor on your behalf.

Terms in this article

CRM — Customer Relationship Management

Zapier — SaaS that connects apps with no-code automations

n8n — open-source workflow automation platform

no-code — building apps with visual tools, little or no programming

low-code — building apps mostly visually, with some custom code

SaaS — Software as a Service

self-hosted — software you run on your own servers

DevOps — Development and Operations

router — routes requests or dialog turns

dashboard — metrics/status panel

pipeline — sequence of processing stages

Airtable — spreadsheet-database hybrid for lightweight apps

REST API — HTTP API that exposes resources via URLs and verbs

HubSpot — CRM and marketing platform for inbound growth

production — live environment serving real users

stateful — keeps session or workflow state between requests

fallback — backup path used when the primary option fails

OAuth — Open Authorization

retry — automatic repeat of a failed request or job

fair-code — source-available license with commercial use limits

timeout — max wait before aborting

self-hosting — running software on your own servers

SSO — Single Sign-On

LLM — Large Language Model

webhooks — HTTP callbacks when events happen

GPT — Generative Pre-trained Transformer

e-commerce — online selling of goods or services

sales ops — operations that support the sales process

in-house — done by the company's own team

Zendesk — customer support and helpdesk platform

VPS — Virtual Private Server

backend — server-side logic, APIs and data layer

edge cases — rare inputs or scenarios that break the happy path

time-to-market — how fast a product reaches customers

2FA — Two-Factor Authentication

DPA — Data Processing Agreement