Make

Trying to decide what's right for your business? Schedule a 30-minute call and we will help you cut through the noise. talk to us

Make (formerly Integromat) is a visual workflow automation platform that lets teams build complex, multi-step automation scenarios connecting hundreds of apps and services. It is known for its visual flow builder, powerful data transformation capabilities, and pricing model that makes it more affordable than Zapier for high-volume automation needs.

This review covers what Make does, who it fits, and where its limits are.

Key Takeaways

• Visual scenario builder: Make uses a canvas-based builder where each step and connection is visualised, making complex automation flows easier to understand and debug than list-based automation tools.
• Operations-based pricing: Make charges by the number of operations (steps executed), not by the number of automations, which makes it cost-effective for high-volume workflows.
• Advanced data transformation: Make has strong built-in tools for transforming, formatting, filtering, and routing data within a scenario without needing a separate data processing tool.
• Best for technical teams and operations managers: teams that need complex multi-step automation with conditional logic, iteration, and data transformation are the core audience.
• Free plan available: 1,000 operations per month; paid plans start at $9/month.

What Is Make and What Does It Do?

Make is a visual automation platform that lets teams build complex multi-step workflows connecting hundreds of apps, with advanced data transformation, conditional routing, iteration over data sets, and error handling, all configured through a drag-and-connect canvas without writing code.

Make goes significantly beyond the two-step trigger-action model of simpler automation tools.

• Scenario canvas builder: connect modules (apps and functions) on a visual canvas by drawing lines between them; each line represents data flowing from one step to the next; the canvas shows the full automation scenario at a glance.
• Data transformation and routing: use built-in functions to transform text, numbers, dates, and arrays; split data flows with routers that send different records down different paths based on conditions; aggregate and iterate over arrays of records.
• Advanced modules and integrations: connect to over 1,500 apps including Google Workspace, Slack, HubSpot, Salesforce, Airtable, and custom APIs via HTTP modules; handle authentication, pagination, and rate limiting without manual coding.

Make is most useful for teams that need automation that involves multiple steps, conditional logic, and data transformation between the trigger and the final action.

Who Is Make Built For?

Make is built for operations managers, marketing automation specialists, developers, and agency teams who need to build complex, reliable multi-step automation workflows that go beyond what simple trigger-action tools like Zapier's basic plans support.

The platform rewards users who take time to understand its capabilities.

• Operations and RevOps teams: teams that automate CRM data synchronisation, lead routing, reporting, and operational workflows use Make's advanced data handling and conditional routing to build reliable, complex automation without custom code.
• Marketing automation specialists: marketers who build complex lead nurturing flows, multi-channel campaign triggers, and data sync between advertising platforms, CRM, and email tools use Make's visual builder to manage the complexity.
• Agencies building client automations: digital agencies that build and maintain automation workflows for clients use Make's scenario organisation and cost-effective pricing to handle multiple client automations without the per-zap costs of Zapier.

Non-technical users who need simple app connections without data transformation will find Make's interface more complex than necessary; Zapier is more accessible for straightforward trigger-action automations.

How Does Make Work?

You create a new scenario, add a trigger module that starts the automation, connect action modules that perform steps using the trigger data, configure data transformation and routing between steps, test the scenario with real data, and activate it to run on a schedule or in real time.

The canvas-based workflow is distinctive from list-based automation tools.

• Trigger configuration: add a trigger module (webhook, schedule, or app event) that starts the scenario; configure the trigger's connection and settings; the trigger output becomes the data that flows into the next module.
• Module chain: add action modules by clicking the plus button after each module; connect them by clicking on the output handle of one and the input of the next; configure each module with the data from previous steps using the field mapping panel.
• Routing and error handling: add a router to send data down multiple paths based on conditions; configure filters on each path to define which records follow which path; add error handlers that catch failures and route them to a notification or retry logic.

Building a five-module scenario from scratch takes 30 to 60 minutes for a new Make user; complex scenarios with iteration and error handling take longer.

What Are Make's Real Strengths?

Make's biggest strengths are the visual canvas that makes complex automation comprehensible, the operations-based pricing that is significantly cheaper than Zapier at high volume, the advanced data transformation that handles complex data manipulation without code, and the iteration and aggregation capabilities that process lists of records in a single scenario.

For teams with complex automation needs, these advantages create meaningful capability differences.

• Visual canvas for complex logic: seeing the full automation flow on a canvas rather than a linear list makes it possible to build and debug scenarios with multiple routing paths, loops, and error handlers; this is Make's most important advantage for complex workflows.
• Operations-based pricing: paying per operation rather than per workflow makes Make dramatically cheaper than Zapier for high-operation-count scenarios; teams that hit Zapier's pricing ceiling often move to Make for cost savings alone.
• Iterator and aggregator modules: processing a list of records, running a step for each one, and aggregating the results back into a single output is straightforward in Make and difficult or impossible in simpler automation tools.
• HTTP module for any API: Make's built-in HTTP module connects to any REST API without a native integration; teams can automate any tool with an API, including internal systems, without waiting for a native Make connector.

These strengths make Make the right choice for any automation that involves more than a simple two-step app connection.

Where Does Make Fall Short?

Make has a steeper learning curve than Zapier, scenario organisation can become complex at scale, the interface requires careful attention to avoid configuration errors, and some users find the operations count model harder to predict than per-workflow pricing.

These limitations matter for non-technical users and large teams.

• Learning curve for non-technical users: Make's canvas, routing, and data transformation concepts require more time to learn than Zapier's simpler interface; non-technical users often find the first few scenarios difficult before gaining confidence.
• Operations counting requires careful planning: the operations-based model charges for every step executed; scenarios with large iterators or unexpected loop conditions can consume operations faster than planned, leading to higher-than-expected costs.
• Complex scenarios can become hard to maintain: large scenarios with many modules, routers, and branches can become visually complex and difficult for someone other than the original builder to understand and modify.
• Real-time triggering requires webhooks: many Make triggers are polling-based rather than real-time; for truly real-time automation, the trigger app must support webhooks, which not all apps do.

For teams with the technical capacity to manage these challenges, Make's advantages outweigh the limitations significantly.

How Much Does Make Cost?

Make's free plan includes 1,000 operations per month. Paid plans start at $9/month for 10,000 operations, with higher plans for more operations and team features.

Operations scale with plan upgrades or add-on purchases; estimate your operation count per scenario before choosing a plan.

How Does Make Compare to Other Automation Platforms?

Make competes with Zapier at the no-code automation end and with n8n at the technical, self-hostable end. It offers more power than Zapier for complex workflows and more accessibility than n8n for non-developers.

The right choice depends on workflow complexity, technical level, and volume pricing sensitivity.

Make wins for complex automation at competitive pricing. Zapier wins for simplicity and the widest native app library. n8n wins for developer teams that want full control.

Is Make Good for Marketing Automation?

Make is a strong platform for marketing automation workflows that involve multiple steps, conditional routing, and data synchronisation between advertising, CRM, and email tools, particularly for teams that have outgrown simple trigger-action tools.

Marketing automation is one of Make's most active use case categories.

• Lead routing from multiple sources: capture leads from Facebook Lead Ads, Google Ads, website forms, and other sources; use Make's router to assign leads to the right sales rep, CRM pipeline, and email sequence based on source and qualification criteria.
• CRM and email synchronisation: sync contact data between HubSpot, Salesforce, and Mailchimp automatically when a lead changes status, reaches a deal stage, or takes an action; Make handles the data transformation between each platform's field structure.
• Report automation: pull campaign data from advertising platforms, process it through Make's data transformation modules, and write structured reports to Google Sheets or send summaries to Slack automatically on a schedule.

At LOW/CODE Agency, Make is one of the automation platforms we use for client workflow automation when complexity and volume require more than Zapier's basic plans can handle.

What Are the Common Mistakes When Using Make?

The most common Make mistakes are building scenarios without error handling, not testing with real data before activating, and under-estimating the operation count before choosing a plan.

These mistakes create unreliable automation and unexpected costs.

• Not adding error handlers: scenarios without error handling stop silently when a step fails; always add an error handler to each module or at the scenario level that sends a notification when a failure occurs so the team knows immediately.
• Testing only with mock data: Make's scenario history shows exactly what data flowed through each module in real runs; always run the scenario with real input data and review the history to confirm each step processed correctly.
• Not counting operations before committing to a plan: estimate the number of operations per scenario run and the expected run frequency before choosing a plan; scenarios with large iterators can consume thousands of operations per run.
• Building without reviewing the Make documentation: Make has extensive documentation on its modules, functions, and advanced features; using the documentation before building complex scenarios prevents avoidable mistakes.

Adding error handling, testing with real data, and planning operation counts prevents the most common Make operational problems.

Conclusion

Make is one of the most capable no-code automation platforms available, with a visual canvas, advanced data transformation, and operations-based pricing that makes it the practical choice for teams that have complex workflow needs or high automation volume. The power to build sophisticated multi-step flows with conditional routing, iteration, and error handling puts it ahead of simpler tools for serious automation work.

It is not the right choice for non-technical users who need simple connections between two apps, or for teams that prefer the simplicity of Zapier's linear interface. For operations teams, agencies, and technical marketers who need to automate at scale, Make delivers more capability per dollar than most alternatives.

Need a Custom Automation System or Integration Built for Your Business?

Make handles complex automation effectively. When your business needs a custom integration between internal systems, an automation pipeline connected to your proprietary data, or a workflow built for production reliability at scale, professional development delivers what a no-code platform cannot.

At LOW/CODE Agency, we build scalable digital products and custom automation for businesses that need more than off-the-shelf tools. We have completed 450+ projects for clients including Medtronic, American Express, and Zapier.

If your automation needs a proper build, let's talk.

FAQs

What is Make used for?

Make is used to build complex, multi-step workflow automations connecting hundreds of apps, with data transformation, conditional routing, and iteration between steps.

Is Make free to use?

Yes. Make has a free plan with 1,000 monthly operations. Paid plans start at $9/month for 10,000 operations.

How does Make compare to Zapier?

Make is more powerful for complex workflows with data transformation and routing. Zapier is simpler and has a wider native app library for basic trigger-action automations.

What is an operation in Make?

An operation is a single action executed by a module in a scenario. A scenario with five modules processes five operations per run, plus additional operations for iterations.

Can Make connect to custom APIs?

Yes. Make's HTTP module connects to any REST API, allowing automation with any tool that has an API endpoint, even without a native Make integration.

Is Make good for agencies?

Yes. Make's operations-based pricing, scenario organisation, and multi-account management features make it cost-effective and practical for agencies managing automation for multiple clients.