Make : Our opinion on this no-code Automation Software

We’ve been using Make for a long time at Salesdorado. Back then, it was still called Integromat. It was already a powerful, flexible and much more affordable tool than Zapier (which we never liked…).

Since then, Make has evolved considerably, without ever losing its initial strengths: a clear visual interface, fine-tuned automation logic and great flexibility.

It’s a platform we often recommend to those who want to do clean, large-scale automation without breaking the bank.

For us, Make ticks all the boxes: robust, mature, very complete, and above all, easy to use. Where Zapier is beginning to age (and fall seriously behind), Make remains a very solid choice.

And even if n8n is rising fast, n8n remains less accessible than Make for most teams.

Admittedly, Make’s interface can be a little intimidating at first, but once you’ve got the hang of it, it’s fluid, logical and very pleasant to use.

As with all software, there’s an unavoidable adaptation period. So, without further ado, check out our full review of Make.

Our opinion of Make in a nutshell

#1 Make’s key features

What sets Make apart from most other automation tools is its ability to combine power and accessibility.

The tool has been designed to automate complex processes (with conditions, loops, parallel routes, API calls, data processing, etc.) but without ever forcing the user to write a line of code.

And it’s clear that it works: the interface is clear, fluid and flexible enough to adapt to both simple needs and highly advanced automation.

Make has all the ingredients of a mature platform: a sophisticated visual editor, a variety of triggers, a rich template library, integrated AI modules and even a small internal database system.

It’s this functional depth, combined with real ease of use, that makes it one of the best tools on the market even today.

An ultra-flexible visual editor for building complex workflows

Make is based on a drag-and-drop editor, in the form of a dynamic graph. Each scenario is built by connecting blocks (called “modules”) representing actions, conditions, routes or processes.

Unlike other tools, where automations are often linear, Make lets you create tree-like structures, with conditional branches, loops, routers, aggregators…

What we particularly like is the freedom offered in scenario design. You can chain as many modules as you like, add conditions between each step, manipulate the data at each passag, all without ever leaving the interface.

It’s both easy to read and extremely powerful. Even with very complex automation, you always have a good overview.

And if something goes wrong, Make shows you exactly where it’s going wrong. Errors are contextualized, with detailed logs for each module.

You can partially replay a scenario, test an isolated module or view output values. For us, it’s one of the best integrated debugging tools we’ve tested on this type of platform.

A library of scenario templates to get you started quickly

Make also offers a gallery of pre-configured scenarios, which is very useful if you don’t want to start from scratch. To date, Make offers almost 10,000 scenario templates.

These templates are more than just examples: they are 100% modifiable, directly usable and often already well thought-out in terms of business logic (as each template responds to a precise use case).

With just a few clicks, you can adapt a scenario to your own context, test its operation and then enrich it according to your needs. This is particularly useful for less technical profiles who want to automate without starting from scratch, without reinventing the wheel.

What’s more, the Make community is very active, so you’ll regularly find new templates proposed by other users, often specializing in very specific business stacks or niches. In short, it’s a real favorite.

Fine-tuned trigger management to automate at the right moment

Make lets you trigger the execution of a scenario in a number of ways, with a level of granularity that’s quite rare in this type of tool.

You can choose a scheduled execution (every 15 minutes, once a week, on a specific date…), trigger a scenario via a webhook or react to a specific event on a connected application (for example, the receipt of an email or the submission of a form).

But where Make stands out is in the combination of these triggers. You can imagine scenarios that run only if certain conditions are met, or that wait for the simultaneous arrival of several events.

And above all, you keep control over the pace and volume of execution: very useful if you’re working on large volumes of data or with sensitive integrations, so as not to explode your quota of operations.

Integrated AI modules to automate intelligent tasks

Make clearly passed a milestone in 2025 by integrating advanced artificial intelligence capabilities that are transforming the automation experience.

The tool no longer simply connects apps or executes scenarios: it can now reason, decide and orchestrate entire workflows autonomously.

The key new feature is the introduction of goal-oriented AI agents. In concrete terms, rather than manually breaking down each step of a process, you define a goal (e.g. “Notify my team as soon as a priority lead is identified on LinkedIn”) and the AI agent builds the scenario itself.

It selects the modules, conditions and tools to be activated, taking into account the constraints of your environment. This greatly facilitates the design of automation scenarios.

 

There are also ready-to-use AI modules, such as ChatGPT (OpenAI) and Perplexity.

You can generate or summarize texts, classify messages, translate, extract key information from an email or a contract… All this integrates natively into your workflows, just like any other standard module.

And it’s not just cosmetic: Make can also intelligently transform your data (sorting, enrichment, aggregation, scoring, etc.), automate error management (with AI-driven corrective actions) and trigger real-time decisions based on business criteria. AI isn’t just a gadget here, it’s a real logic brick at the service of automation.

A Data Store for easy storage and reuse of your data

Finally, Make integrates a small internal database system, which they call the “Data Store”. The idea is simple: you can store data between two scenarios, keep track of a status or centralize information without having to resort to a third-party tool.

This is particularly useful, for example, when you want to build multi-stage workflows or cross-reference data at different points in time.

For example, you can record a lead ID when a ticket is created, then reuse it several hours later in another scenario. You can also keep a list of contacts “to be excluded” from a campaign, without touching your main CRM.

It’s not a data warehousing tool, of course, but for many B2B use cases (lead tracking, enrichment, multi-source qualification…), it’s a real plus.

#2 Handling and user experience

The first impression when you open Make is that the interface is both clean and a little intimidating. Everything takes place in a blank canvas visual editor, where you build your scenarios by hand.

Once you’ve grasped the logic (a scenario = a series of interconnected modules), the experience quickly becomes very fluid. It’s a pleasure to test, adjust and visualize.

Each module displays the data it receives and sends, making testing and debugging much easier. And you can deactivate, duplicate or isolate parts of a scenario without breaking everything.

The internal search engine lets you quickly find the applications or modules you need, and configuration options are all accessible without ever leaving the editor.

Even execution logs are well integrated into the interface: you can replay an execution, inspect errors module by module or compare two different runs. This is one of the few tools where the UX doesn’t deteriorate as scenarios become more complex.

On the other hand, Make is not a “plug and play” tool in the sense that you need to spend a little time getting to grips with its logic, and certain concepts (such as aggregators, conditional routes or API calls) require a little more skill. But once you’ve got the hang of it, you’re totally autonomous, which is exactly what most advanced users are looking for.

For slightly technical teams, or those who are simply curious, it’s an excellent compromise between accessibility and power. You can build cutting-edge automations without ever touching a line of code, but without feeling constrained by an overly rigid interface. In short: a true “no-code” UX, but designed for people who want to go the distance.

#3 Integrations and APIs

Make offers over 2,100 native integrations, covering most SaaS tools on the market: CRM, marketing automation, messaging, no-code tools, e-commerce platforms, databases, cloud services and more.

The quality of these integrations is quite good: each module is well documented, fields are customizable and you can combine several actions or triggers for the same tool.

But where Make really makes a difference is in its ability to go beyond “official” integrations.

The tool offers several generic modules for interacting with any external API: custom HTTP requests, sending or receiving webhooks, processing data in JSON, XML or even SOAP…

You can connect to (almost) anything, without waiting for Make to propose a dedicated connector.

And that changes everything in a B2B environment, where technical stacks are not always very standard. Need to push information to an obscure business tool, or retrieve internal data via a home-grown API? Make knows what to do.

Even better: once the call is working, you can model your response, parse the data, filter it, enrich it and inject it elsewhere, all within the same interface.

#4 Support & resources

Make offers several levels of support, but as is often the case, the experience varies according to your subscription plan. On free plans or the first paid levels, you have to go through an online support center, with a ticket system. Responses are generally relevant, but delays can be a little long.

Conversely, on Enterprise plans, support is much more responsive and personalized, sometimes with a dedicated contact.

That said, for most users, the online documentation is more than sufficient. It’s rich and well-structured, with step-by-step guides, video tutorials and detailed explanations for each module.

There are also plenty of concrete examples, including advanced integrations and custom API calls.

Another strong point is the community. The official forum is active, exchanges are of a high standard and the database of shared scenarios continues to grow.

You’ll also find plenty of resources on YouTube, Reddit or LinkedIn, where Make consultants regularly share tips, use cases and best practices.

Finally, Make has recently launched an “Academy” with training courses structured according to user level. It’s still early days, but it shows a clear desire to support users’ skills development. And given the richness of the tool, that’s a good thing.

In short, even if customer support isn’t yet at the level of more mature tools like Zapier or Airtable, the Make ecosystem is lively, the documentation solid and the learning curve well supported.

#5 Prices and value for money

Make works on a pricing model based on the volume of operations performed by your scenarios. Every action, every API call, every routing or data transformation counts as an operation.

This model, which is more granular than traditional “per job” pricing, makes the tool highly competitive once you start automating on a large scale.

For equivalent functionality, Make is considerably less expensive than Zapier.

But it has to be said: the “operations” metric is a bit tricky. Even triggers (which simply wake up a scenario) are counted towards the monthly quota. This means that poor design or too frequent triggers can quickly run up the bill.

Fortunately, Make provides precise tracking tools to keep an eye on your consumption, and well-thought-out logic usually allows you to optimize without too much effort.

Here is an overview of the different plans on offer, with our recommendations based on your profile:

In short, Make is extremely competitive, especially if you’re working on complex scenarios with several internal actions. The free plan is already very useful for getting started, the Core and Pro plans more than cover the needs of 80% of B2B teams, and the Enterprise plan is aimed at organizations that want to industrialize automation within a secure framework.

#6 Customer reviews and reputation

On Capterra, the platform has an average rating of 4.8/5 out of over 400 reviews, an excellent score that testifies to the satisfaction of regular users, particularly in professional settings. The strong points cited: the power of the visual editor, flexibility, modular logic and, unsurprisingly, value for money.

On Trustpilot, on the other hand, the average rating is low (2.9/5 out of a hundred reviews). Several users complained of billing problems, scenarios triggered by mistake, or difficulties reaching support. There is also some criticism of the learning curve and the interface, which is sometimes considered confusing at first.

In our opinion, these criticisms need to be put into perspective. Make remains a technical tool, but for teams who take the time to understand its logic (or who already have a little tech maturity) the experience is largely positive.

In B2B, the perception is also very good. Make is often cited as a reference by ops, growth or advanced no-code profiles. And it’s often the tool of choice when you’re looking for a serious alternative to Zapier that’s less expensive, more powerful and, above all, more pleasant to use on a daily basis.

Conclusion : Our opinion on Make

Make ticks virtually all the boxes of an excellent automation tool: powerful, flexible, affordable and pleasant to use on a daily basis. Where Zapier can quickly seem rigid or limited, Make offers a real working environment, capable of driving complex workflows without getting lost in the technicalities.

The visual editor is a real success, the modular approach allows fine-tuned control of scenarios and the tool remains surprisingly light in use, even in demanding contexts.

It’s a tool we’ve been using at Salesdorado for years, and continue to recommend without hesitation. The rise of competitors like n8n does little to change our position: Make remains simpler, more accessible and more than sufficient for 95% of B2B use cases.

And to make matters worse, prices are very competitive, especially for high volumes.

We recommend Make if:

• You’re looking for a serious (and cheaper) alternative to Zapier.
• You want to automate complex workflows, with several tools and a real business logic.
• You’ve got a little technical skill (or a desire to dig deeper) and you like to keep your hands on your automations.
• You’re a team player looking for a robust, collaborative and well-documented tool.

Avoid Make if you’re looking for a “plug and play” tool to perform one or two simple automations without ever touching the parameters. There is a learning curve, but it’s well worth it.