Make

Complex, multi-step workflows

If your automation needs go beyond linear "trigger-action" sequences, Make excels with flexible, visual scenario building. It uses a node-based interface (modules connected by lines) that allows branching, looping, and advanced data handling in one workflow. For example, you can route data conditionally or aggregate and iterate through lists natively. Tasks like multi-approval processes or processing survey data with complex logic are where Make really shines.

Balance of power and accessibility

Make is often described as the perfect in-between for automation tools. It offers far more flexibility and creative potential than Zapier, without requiring the coding expertise of n8n. In practice, mid-sized teams or power users who outgrow Zapier's simplicity but aren't ready to self-host a tool like n8n might find Make to be the right balance. Make is more powerful than Zapier, easier than n8n.

Cost and volume of operations

Make's pricing model is operation-based, which can be more cost-effective than Zapier's task-based model in many cases. The free plan already allows 1,000 operations per month, and paid plans start at $9 per month for 10,000 operations. If you anticipate high-volume automation, especially many small actions, Make will likely be cheaper than Zapier. N8n can be the cheapest of all at scale if self-hosted.

Integrations available

Zapier has the largest number of pre-built app integrations, while Make offers around 1,500+ connectors. If your workflow relies on very niche apps, Zapier might have direct support where Make doesn't. But Make provides tools like HTTP or SOAP modules to connect to any API, so you can integrate unsupported apps with a bit of configuration. If you're willing to tinker for those edge cases, Make's smaller app catalogue is not a deal-breaker.

Error handling needs

Make offers robust error handling features that outshine Zapier's. In Make, you can set up custom error handlers, rollbacks, and conditional routes when something fails. Zapier's approach to errors is more basic, usually just sending a notification or retrying later. If your processes need fine control over failure scenarios, Make provides that level of control out-of-the-box. N8n also allows granular error handling, but that requires more technical effort.

Data storage and history

Make stores all scenario execution data and allows you to inspect it, which aids debugging and auditing. Zapier does not retain data from runs in a user-accessible way. If having a history of runs and data is important, Make's approach is beneficial.

As a Zapier Certified Expert, I have used Zapier since 2014. I have also used Make in the past when it was still called Integromat, though only on the free version. This review is based on desk research, not extensive production use.

User interface and experience

Coming from Zapier, Make's interface felt both intriguing and intimidating. Make uses a visual canvas where you drag and drop modules and connect them to build a flow. This can be intuitive for those who think in flowcharts, but Zapier's linear interface is quicker for straightforward tasks. Make has a steeper learning curve. It requires more patience and a willingness to learn how the pieces fit together.

Features and flexibility

Make excels at creating multi-step, branched workflows all within one scenario. It supports routers, iterators, aggregators and advanced data manipulation. It also allows custom code steps in JavaScript. This covers most advanced no-code needs without requiring developers. Zapier cannot compete at this level of workflow complexity. However, if you need unlimited customisation, n8n still offers more.

Integrations and ecosystem

Zapier has more plug-and-play integrations, which is a strength if you're working with obscure tools. Make covers most popular apps and supports custom integrations via APIs. Its community is strong and provides templates and tutorials. N8n is the most flexible but requires the most effort to integrate tools.

Pricing

Make is significantly more cost-effective than Zapier for high-volume usage. You get more operations for less money, and the plans are granular. Zapier becomes expensive quickly. N8n is cheapest if self-hosted but requires technical overhead. For teams that cannot self-host, Make provides the best value.

Reliability and support

Zapier has strong reliability and premium support. Make has good documentation and community support, though paid plans provide more direct help. N8n is open source and relies heavily on community support unless you use their cloud offering. Make is a good middle ground here.

My verdict

Make is a powerful, flexible automation tool. I still prefer Zapier for its ease of use and n8n for ultimate flexibility, but Make covers most needs in between. If you are hitting limits with Zapier or want to avoid the cost, Make is a great step up. If you do not want to manage servers but want more than Zapier offers, Make is the sweet spot.

Sign up and choose a plan

If you’ve decided to give Make.com a try (either alongside or instead of Zapier or n8n), here’s how to start using it step-by-step. Head to Make.com and create a free account. The free tier is generous with 1,000 operations per month. You do not need a credit card for the free plan. Keep in mind the free plan’s limits: for example, maximum one scenario run every 15 minutes, and a limited number of active scenarios at once. These are fine for testing and small workflows. You can always upgrade later to a paid plan for more operations and faster scheduling.

Familiarise yourself with the interface

After login, you’ll land on the dashboard. From here, you can create and manage your scenarios. A scenario in Make is equivalent to a Zap in Zapier – it’s an automated workflow. Click the “Create a new scenario” button. You’ll be taken to the scenario editor, which is a blank canvas with a big plus button (this is where you’ll add your first module). The interface might look a bit different from Zapier’s step-by-step builder; it’s more like a canvas where you’ll place circles (modules) and connect them. Don’t be intimidated – everything still boils down to triggers and actions, just presented visually.

Add a trigger module

Every scenario starts with a trigger – the event that kicks off your automation. Click the plus on the canvas and search for the app that will provide the trigger. For example, if you want to react to new rows in a Google Sheet, select Google Sheets and then choose the specific trigger (such as “Watch new rows”). If it’s your first time using that app in Make, you’ll be prompted to add a connection (that is, authenticate your Google account, Slack workspace, etc.). Follow the prompts to connect the account – similar to how Zapier asks for account authorisation. Once connected, configure the trigger’s options. You’ve now got your trigger module on the canvas, represented as a circle with an icon.

Add action or search modules

Next, add subsequent modules for the actions you want to happen. Click the next plus icon that appears to the right of your trigger module (or drag a new module onto the canvas). Search for the app and action you need. For instance, if your trigger is a new spreadsheet row, maybe the action is to send a Slack message to alert the sales team. Add Slack and choose “Send a channel message” (or whichever action fits). Again, connect your Slack account if not done already. Configure the action’s details. This usually involves mapping data from the trigger into the action’s fields. Make will show a form with fields like “Message text”, “Channel”, and so on. For any field, you can type static text and insert dynamic data from previous modules. To insert data, click into a field and you’ll see a panel with available variables from earlier steps. Select the pieces of data to include them in the message. You can combine text and variables freely. This is similar to Zapier’s field mapping, but in Make you also have built-in functions for text and date formatting. Use these if you need to transform data – Make allows quite advanced data manipulations without needing a separate formatter tool.

Extend with more steps if needed

You can continue adding more action modules in series. For example, after the Slack message, you might add a CRM module to create a new lead. Keep clicking the plus after the last module to chain another. Make also supports parallel branches. If you want two things to happen from the same trigger independently, use a Router module to split the path. This is an advanced feature – it lets you create multiple branches of execution. For example, one branch sends Slack, another sends an email. To use it, drag a Router onto the canvas after the trigger; it will create multiple output paths where you can attach different modules. You can also insert Filters between modules to make actions conditional. Each module connection has a filter icon you can click to set conditions. These advanced controls are where Make really outperforms Zapier in workflow complexity. Leverage them if needed, but they’re optional for simple linear scenarios.

Test your scenario

Once you’ve configured your trigger and actions, it’s time to test. It’s highly recommended to run scenarios in Make using the manual run feature before activating them. In the scenario editor, click the “Run once” button while providing some sample trigger data. For example, add a new row in your Google Sheet so the trigger has something to pick up. Then click Run once. Make will execute the scenario on the available data and you’ll see live output for each module. Each module’s bubble will show how many operations were executed and you can click into them to see the input and output data that passed through. Verify that everything worked as expected. If not, adjust your module settings or mappings and run again. Debugging is easier in Make thanks to this step-by-step data view.

Activate the scenario

If the test looks good, save your scenario and turn it on. There’s a switch or “Enable” button. An active scenario will continually run either on schedule or when an event occurs, depending on your trigger. Triggers come in two types: polling triggers (which check for new data every few minutes) or instant triggers (webhooks that receive data in real-time). If your trigger is something like “New row in Google Sheet”, it likely polls. On the free plan, polling happens at minimum every 15 minutes, but you can set it to a longer interval if you don’t need instant response. If you need faster checks, that requires a higher plan. If you use an instant trigger, such as a Webhook trigger or one from an app with built-in webhooks, the scenario runs as soon as data is received. This can be real-time even on the free plan. Once turned on, Make will handle execution automatically. You can always come back and monitor the scenario’s runs in the execution history, where each run’s details are logged.

Monitor your usage

As your scenario runs over time, keep an eye on the operations count in your dashboard. Each step execution counts as one operation. The scenario editor often shows an estimate of operations per run. For example, if your trigger grabs 10 new rows and you process each, that could count as 11 operations – one for the trigger and 10 for the actions. Make’s operations usage page lets you see how many operations you’ve consumed in the month. If you approach your limit, you might pause less important scenarios or upgrade your plan. Make also allows purchasing extra operations á la carte. Unused purchased operations roll over for up to a year.

Explore templates and resources

To accelerate learning, check out Make’s pre-built templates and the Make community forum where users share scenarios and tips. There are also third-party tutorials for common use cases. The official Make Help Centre covers all key concepts such as triggers, actions, routers, and error handlers. If you get stuck, the community forum is very active. Search your question – odds are someone has asked it. For example, Make’s documentation provides a guided tutorial for a Google Sheets to Slack notification scenario, which is a great first project.

Final thoughts

By following these steps, you should have your first Make.com scenario up and running. Congratulations – you’ve tapped into a powerful automation platform that can save you countless hours. As you build more scenarios, you’ll discover the unique advantages of Make, from the visual builder to the fine-grained control it offers. You’ll also get a sense of where its limits are relative to Zapier or n8n, helping you choose the right tool for each job.

‍