Make Review: A Deep Dive Into a Leading Automation Software

As a business owner and software entrepreneur, I've spent years chasing the dream of operational perfection, always hoping the next platform would finally be "the one." Eventually, I gave up. Instead, I’ve embraced a more practical alternative: connecting my best-in-class tools through a dedicated automation platform.

Make (formerly Integromat) is one of these automation platforms. It’s the digital glue that can hold your business together by connecting your scattered tech stack. Whether you're juggling marketing and sales tools like me, or project management software, inventory systems, or something else, Make can automate your workflow.

I’ve extensively tested Make in real business scenarios. It offers powerful integrations that will change the way you work. The downside is that it’s also more complex than some alternatives.

In this hands-on review, I’ll share what I discovered, including Make’s standout features, its actual usability (not just marketing claims), and whether its pricing makes sense for you.

Let’s dive in!

What Is Make?

Make is a no-code automation platform that allows you to build automated workflows using a visual drag-and-drop builder. You achieve this by connecting different apps and services to automate repetitive tasks, pass data between tools, and trigger actions in one app when something happens in another.

For instance, when someone submits a Google form, you can add their response to a Google Spreadsheet, create a record with their data in your CRM, and notify your team in Slack.

Understanding Make’s Terminology

Before diving into Make's features, I should clarify some of its unique terminology. It differs from competitors like Zapier and left me scratching my head before I figured it out.

Here’s a quick overview:

• Scenarios: Your actual automations or automated workflows. If you're familiar with Zapier, these are essentially the Zaps.
• Modules: The steps or building blocks of your scenario.
• Apps: Third-party software tools that Make integrates with (e.g., Airtable, Gmail, Google Forms), as well as built-in apps like Flow Control, Webhooks, Data Store, and others. You connect third-party apps under Connections. App connections support different modules.
• Operations (Ops): Each time a module in a scenario is fired, it uses an operation. Make’s pricing is based on the number of operations, so you can also think of them as credits.
• Flows: A path within a scenario, or the order in which modules will be executed within a scenario. One scenario can have multiple different flows.
• Bundles: A collection of related data records (could be lines, rows, items, etc.)
• Array: A single collection of multiple bundles. Primarily used when you do development-related automation, but you might see it used in other scenarios, too.

Key Features and What Differentiates Make

Once I had played around with Make a bit, I found that it stands out from other automation platforms in a few key ways. Let’s take a look.

Comprehensive Integration Ecosystem

As of writing this post, Make boasts 2,478 native integrations in its library. While this falls short of industry leader Zapier's massive 8,000+ connections, Make's catalog remains comprehensive enough to handle most use cases. You’ll only encounter limitations if you use a particularly unknown app or a newly launched software that hasn’t built an integration with Make yet.

Even then, you're not entirely out of luck. Make's robust Webhook module provides a viable workaround for connecting some unsupported apps. Of course, you can also create custom connections through the API feature, but this is only for developers.

Robust Support for Webhooks

Webhooks are a way for web applications to communicate with each other in real time using HTTP requests. These automated messengers deliver data from one application to another when specific events occur, acting as a bridge between applications that don't have direct native integrations. The best part is that Webhooks are completely free, so you don’t pay anything extra on top of Make.

Fortunately, with Make’s built-in Webhook module, they’re actually pretty easy to set up.

I encourage you to learn using webhooks. It vastly expands Make's connectivity beyond its native integration library.

Intuitive Visual Workflow Builder With Triggers, Actions, and Filters

The heart of Make.com is its intuitive Scenario Builder, where you create automated workflows by connecting different apps. You add modules and then drag and drop them to rearrange them.

Each scenario consists of three main types of modules:

• Triggers detect events and start a scenario, like new emails, form submissions, or new Notion database items.
• Actions respond to the triggers and perform different actions, such as updating spreadsheets, sending notifications, or creating/updating/deleting calendar events.
• Flow Control module is a special operational module that allows you to do things like routing (splitting the scenario into different flows), repeating, breaking the scenario, and more.

Each module must be connected for a scenario to work, and you need at least one trigger and action scenario.

Between connections, you can also set up filters. Filters are used to split the scenario into different lanes based on specific conditions. For instance, when a new Google form is submitted, you can filter it so that the record is added to Pipedrive if the submission comes from the U.S. If the submission doesn't come from the U.S., the record is added to ActiveCampaign.

You can also create as many filters as you like, giving you complete control over your automations. In the scenario below, there are three paths defined by filters:

1. A new Google Calendar event is created if one doesn’t exist for the Notion record.
2. If a Calendar event exists, it gets updated with the latest data from the Notion record.
3. If the Status column of a Notion record is changed to “Cancelled,” the event gets deleted.

There are lots of other features to help you visualize and work with scenarios. I especially like Explain Flow, which produces an animation of the flow of the Modules to help you understand them better.

Advanced Features for Scenario Testing and Troubleshooting

Not gonna lie: Make.com has a steep learning curve, and even creating seemingly simple scenarios can feel surprisingly challenging at first. Mastering how to test and troubleshoot your automations properly is absolutely essential before you can harness the platform's true power.

Make provides several features to help with that, the most important one being the “Run once” button at the bottom left. When clicked, it will run the scenario once and return the results.

It’s important to note that, unlike other automation tools, Make only works with real data when testing scenarios. In other words, when you use “Run once,” the scenario will run live, and changes will be made to your apps accordingly in real life.

Also, your apps must be set up in a way that allows you to test the scenario from start to finish. For instance, a scenario below will not run to the last module if the filter conditions are not satisfied.

I struggled when testing my scenarios, as I had to navigate different apps and records to ensure everything was set up correctly. This can become seriously problematic if you have a complex scenario with many apps and lots of data generated. I wish Make allowed for auto-generated dummy data and a sandbox mode so everything could be tested without leaving the Make interface, similar to how Zapier works.

When you finish running your Scenario, it'll either return a message that “the scenario was completed successfully,” or that there was an error. This is what a successful scenario looks like:

You can then click each bubble to see more data about your scenario.

And here’s what you’ll see when something is wrong:

Make notifies you of any issues in the execution log, which brings me to my first big frustration with the platform: The obscure language of the logs. The error notifications appear to be created exclusively for developers, not less technical users.

One way to minimize the troubleshooting chaos in such scenarios is to troubleshoot the scenario module-by-module. You can do this by clicking right on a specific module and selecting “Run this module only.”

Automated Error Handling

Error handling in Make is an advanced feature that helps you maintain smooth scenario execution by managing unexpected issues with your automations. When problems occur, the red exclamation mark displayed above the affected module will help you spot them instantly. You'll also receive an email notification.

Important: When an error occurs, Make will automatically stop your scenario.

Error handlers allow you to set up specific responses to problems so that workflows continue despite obstacles. I was quite impressed by this feature, as I haven’t seen it in other automation tools and visual builders before.

You can check out a practical reference of how error handlers work, but the most common one is “Ignore”. It allows you to continue the scenario if a bundle errors out.

For example, in the scenario below, data is sent from a Webhook to ChatGPT to process, and the results are added as a row in Google Sheets. In cases where ChatGPT experiences a timeout and fails to generate a response, implementing an Ignore module allows your scenario to continue operating seamlessly.

Scenario Scheduling

If you're wondering what that ticking circle icon next to your trigger is, that’s the Schedule setting, another useful Make feature that allows you to set when a scenario runs.

You can trigger your scenario immediately (as soon as the trigger event kicks in), at regular intervals, or at a specific time of the day, week, or month. I find this really handy, as it allows me to schedule multiple scenarios and avoid overlapping issues.

For instance, you can diversify your social media content strategy by building multiple scenarios. Let’s say you want to publish News updates on Mondays and Wednesdays, and Reviews on Tuesdays and Thursdays, creating a balanced and predictable LinkedIn presence.

In the example below, I have a scenario that monitors my WordPress blog every Monday and Wednesday, immediately detecting new publications in the News category. Each post is then processed through a Claude AI module that analyzes the content and automatically generates a concise, news-style post that is then shared on LinkedIn.

A (Surprisingly) Helpful AI Assistant

Make offers an AI assistant that can help you edit your scenario, create mapping and filters, write an email, and more.

While wrestling with module data mapping (a notoriously finicky process), I skeptically asked it to handle the connections between steps.

To my genuine surprise, it correctly mapped the fields without the usual trial-and-error headache.

Beyond just answering questions, Make’s AI implements changes directly in your scenario, which saved me considerable time troubleshooting those cryptic error messages I mentioned earlier. The AI assistant isn't perfect. It occasionally suggests impractical solutions for complex scenarios. Still, it’s a step in the right direction for bridging the knowledge gap that makes Make intimidating for newcomers.

Version History

Make's version control system became my safety net during complex scenario development. The platform automatically saves your workflow history, allowing you to view all previous iterations with precise timestamps. The feature encourages experimentation; you can freely test improvements, knowing you can always roll them back if they don’t work the way you want them to.

Scenario Inputs to Help With Internal Tasks and Onboarding

If manual employee onboarding is part of your routine, Make's scenario inputs feature offers a game-changing solution that I found quite powerful.

Instead of adding a new team member to each platform in your system, like Asana, JIRA, Slack, Google Drive, etc., you can set up a form within Make to collect these essential details.

Scenario inputs allows you to create a data structure for this information.

This data can then be used as dynamic mapping under “Custom and system variables”:

When you click "Run once” to run the scenario, you’ll be prompted to fill in the form with information. This will kick off the automation, and Make can create accounts for the new employee across various platforms.

The only drawback I found is that only a few apps support an “Invite a team member” trigger. A viable workaround is to add a task and assign it to yourself (or another team member) to invite the employee manually. You can even create an entire onboarding project with tasks.

Here’s a finished scenario that uses inputs:

In the example scenario above:

1. The employee gets created as a record in our Airtable’s Team site.
2. They get invited to the ClickUp Workspace.
3. A task is created to invite them to Jira.
4. They get invited to Hubstaff to track their time.
5. Lastly, a personalized onboarding email is sent to them, depending on whether they are from the marketing or sales team.

Lots of Helpful Templates

Make has an impressive gallery with hundreds of pre-built automation scenarios.

Each template comes with an in-app guide that takes you through each module setup step by step.

I find these walkthroughs helpful in demonstrating how to set up the scenario, but it still felt like they lacked the “why.” They don’t illustrate the business context and often also fail to explain why exactly something has been implemented the way it is.

For instance, in a template syncing Airtable records with Google Calendar events, one of the columns in Airtable was used as a data point to match the records with the events. However, this was not communicated in the guide, so I had to figure out the importance of this column by trial and error.

My Experience Using Make.com: Creating a Scenario From Scratch Step-by-step

So, what did I think of Make? A lot of people have said Make is really hard to use. I agree. That’s why I wanted to show a step-by-step guide on how I created this scenario, and walk you through the entire automation.

I tested Make in all kinds of ways, so let’s run through one way I learned to leverage it to create a scenario that streamlines my business operations.

My AI Lead Scoring Workflow

Level: Intermediate Business Type: High-ticket service or software as a service Apps Used: Form tool like Typeform, AI agent (ChatGPT or Claude), Google Sheets

Scenario Goal: At my software business, we receive many requests for demo calls, but they're not all from qualified buyers. With this scenario, I want to qualify my leads based on a lead scoring system.

Here’s how I did this in Make step by step:

Step 1. Create a Lead Qualification Form

I have a simple lead qualification form in Typeform with questions about the lead’s revenue and business type.

Step 2. Create a Google Spreadsheet With the Data

I collect all lead responses in a Google sheet with columns that match the questions of the form:

Step 3. Set Up the Typeform Trigger

I have mapped all Typeform questions as items in my “Watch for responses” Typeform module in Make.

Step 4. Use an AI Action to Analyze and Score Responses

Now I can use these responses as mappable data points for my AI assistant to score them. I’m using Claude because that’s the one I prefer and have a paid subscription for (you need credits for this), but you can use any other AI model like ChatGPT.

Here’s my prompt:

“You are my lead scoring expert assistant.

Your job is to analyze the quality of the leads that want to book a call for my software business, Encharge.

We are targeting SaaS businesses with annual revenues exceeding $1 million.

Below is the lead data: [Add the responses as mappable answers]

Score the lead between 1 and 10 based on the lead's quality, with 1 being a low-quality lead and 10 being a high-quality lead.

Your answer must be the score number and nothing else.”

How (the Heck) Mapping Works One of the most powerful yet challenging aspects of Make is data mapping, the process of connecting and assigning data values from one module or step to another. For example, if your scenario starts with a form submission and your next step is to send a confirmation email, the submitter’s name and email address need to be mapped from the form module to the email module.

As someone who's worked with dozens of tools, I've found that mapping is where many automations either succeed brilliantly or fall apart completely. The difficulty lies in understanding how each platform handles data. What appears as a simple "name" field in one app might need to be split into "first_name" and "last_name" in another. JSON arrays from one API might need transformation before they can be used in a spreadsheet. These inconsistencies create friction points that require careful planning and tons of testing.

Unfortunately, Make doesn’t help us in this process. While Make provides access to all of the data transmitted by every tool (super powerful), it delivers this data raw, without any formatting or structure. This means you’re often left looking at a big list of data where it’s not always clear what each piece is or where it should go.

Once you get advanced with Make (or you have developer knowledge), you can use functions like array aggregators and text formatters to reshape data.

Step 5. Filter the Responses

Once the scoring is done by AI, I want to put leads into three different lanes based on their score: high quality (7-10), medium (4-7), and low (0-3). For this, I’m going to use a router with three paths and a filter for each.

To set up the filters, I’m going to use:

• For High: Numeric operator - Greater than or equal to 7

• For Medium: Greater than or equal to 4 AND Less than 7

• For Low: Less than 4

Step 6. Add Variables

Next, I use the Tools Set variable module in Make to specify the variable that will be passed to the Google Sheet.

Step 7. Add a Row to the Google Sheet

The last step is to add the Google Sheet modules and map the data from the other modules:

Step 8: Assess the Results

This is the final result: The scenario populates the lead score and lead type with the help of my AI assistant.

This is just one scenario, but I learned how to use triggers and actions, how to move data between apps, how to use variables, and how to personalize the flow with routers and filters. And this is just scratching the surface! There are dozens of ways I could expand this scenario.

For example, I could gather Claude's comprehensive analysis on top of the lead score data, providing my sales team with essential context for each prospect in one unified view.

Or I could add different modules for the three types of leads, personalizing the flow further:

• For my high-value leads, I can create a single-use scheduling Calendly link and populate that link in a personal call invite email that can also be generated with AI.
• I can add my medium-quality leads to my email list on ActiveCampaign and put them into an automated sequence.
• I can push the lead score of all leads to my CRM and other communication platforms like my support desk.

And the list goes on.

4 Other Real-Life Use Cases for Make

Make's flexibility enables so many automations beyond those I’ve already covered. Before you jump into Make to create your automations, I recommend that you take a step back to look at the big picture and map out the processes and customer journey you want to create. You can use a visual map tool like Miro or a simple notepad to sketch your workflow and identify all the touchpoints.

Once you do that, you need to think on a micro level about what data needs to be used to create the automations, which data fields and records need to be accessible, and how exactly the apps will communicate. That's one of the big challenges with Make: it's a bit like visual programming. It's powerful, but you must know how to use it properly to avoid frustration, or at least minimize it.

Now, let's examine four real-world workflows created by Make users that showcase the platform's versatility and may inspire ideas for addressing your own business challenges.

1. Automate Beautiful Contracts for Your Clients

Level: Intermediate Business Type: Services Apps Used: Webhooks (or a natively integrated form), CRM, contract generator (like PandaDoc, Docusign)

Creating contracts is pretty repetitive stuff, but a Make automation can do most of the heavy lifting. This particular Make Scenario comes from business owner and automation expert Jono Catliff (he considers it one of his most powerful automations), but you could use it for all kinds of contracts.

Here’s how it works:

1. Sales staff complete client calls and fill out a form with client details (for his wedding business, this includes event dates, locations, and timing).
2. Make then automatically generates an invoice number, updates the CRM (he's using GoHighLevel), and creates appropriate line items based on the sales conversation.
3. The Make Scenario assembles everything into a professional PandaDoc contract with all client information, pricing, and selected services.
4. When clients finally sign and pay, another Make scenario captures the final approved items and updates all systems with the exact figures.

This automation is particularly valuable for service businesses, agencies, and consultants who regularly create custom client documents.

2. Automate Team Video Calls and Webinar Processes

Level: Intermediate Business Type: Any business that relies on calls Apps Used: Zoom (or any video recording tool), Vimeo or Youtube, Airtable (or any app that keeps records), ChatGPT (optional)

If you create a lot of webinars or Zoom recordings, this automation from AI automations expert Drake Surach shows how you can process Zoom recordings without human intervention. The automation triggers the moment a Zoom Cloud recording completes, then works through three parallel processes:

1. It downloads the call transcript and creates a searchable text record in Airtable.
2. It downloads the MP4 recording and automatically uploads it to Vimeo, storing the video link for easy access.
3. It captures the chat log with all participant messages and links shared during the meeting.
4. It consolidates these elements and uses ChatGPT to generate meeting summaries and extract important information. This is used to create posts for Surach’s Skool community.

This workflow is ideal for sales teams reviewing prospect conversations, learning communities archiving educational content, or any organization conducting regular virtual meetings that require thorough documentation.

3. Generate Personalized Outreach Messages

Level: Beginner Business Type: Any business doing cold outreach Apps Used: Google Spreadsheet, AI model, cold outreach tool (Clay, Lemlist, etc.) Marketers know that cold outreach is a volume game, but also one where a personalized message can improve your odds of a conversion. These factors make automation especially valuable in this area. In this Make Scenario, digital marketer Charlie Barber transforms cold outreach with personalized messages at scale.

Here’s how it works:

1. The automation monitors a Google Sheet for new leads, then feeds each prospect's Instagram URL (or any social media URL), name, and bio to ChatGPT. Keep in mind that you need to first scrape the social profiles or find another way to extract the person’s data before you can use this scenario.
2. The AI analyzes each profile and crafts unique opening messages referencing specific details from the prospect's bio, turning generic outreach into highly relevant communication. For example, "Hey Laurel, I saw that you're known as the realtor extraordinaire at Barkley's Real Estate Group."
3. Running continuously, this three-step automation automatically adds personalized messages back to the spreadsheet, ready for immediate use in outreach campaigns with a cold email tool.

This solution is perfect for sales teams, agencies, and freelancers looking to improve response rates without the time investment of manual personalization.

4. Put Payroll for Freelance Contractors on Autopilot

Level: Advanced Business Type: Any business that works with hourly freelancers Apps Used: Time management app like Harvest, HubStaff, or Toggl, Wise (for payments), Airtable, or Google Sheets, Currency converter module (if you pay out in different currencies)

Paying contractor invoices is another task that can be automated with Make. In fact, business process automation expert Nick Saraev created a workflow that completely eliminates finance department tasks for contractor payments. This solves a key challenge for his content writing company, which pays writers hourly while charging clients fixed, per-word rates.

Here’s what it looks like:

1. The system connects to Harvest time-tracking software, where contractors log their hours. Twice a month, it automatically lists all users (freelancers), calculates pay periods, collects time entries, and generates invoices in PandaDoc.
2. A second scenario is triggered when the invoice is signed. It fetches rates from Airtable, handles currency conversions for international team members, and queues payments in Wise.

This automation transforms 10 hours per week of finance work into less than 30 seconds of oversight. It works exceptionally well because financial processes involve standardized operations based on structured data.

The solution is ideal for businesses managing contractor payments, remote teams working across currencies, or service companies tracking billable hours.

Make’s Pricing

Make offers five different plans, and each one scales with the number of operations you execute per month, starting from 10,000 to millions of operations. Pricing ranges from free to $34 per month.

The Free tier offers access to the core workflow builder and all apps, allowing users to experiment before committing. However, **it's limited to two active scenarios only, which makes it more of a free trial. **

The Pro plan, priced at $18.82 per month, is where I find the sweet spot of Make. Here, you’ll get access to helpful features like scenario inputs and custom variables (the ability to manage and edit data across multiple scenarios simultaneously).

One annoying limitation with all plans is the minimum 1-minute interval between scheduled scenario executions. This could create annoying bottlenecks if you have a lot of scheduled scenarios that run on an ongoing basis. Your scenarios could end up queuing up and waiting for their turn, which slows everything down.

This issue is especially problematic if you have any customer-facing scenarios. Imagine a new hot lead potentially having to wait 5 minutes to receive a lead magnet they downloaded on your website! (Note that this limitation only applies to scheduled scenarios - trigger-based scenarios run immediately when a new row is added to the spreadsheet).

Tips for Getting the Best Deal with Make

• Start with the lowest operations option, otherwise, unused operations will expire at the end of the month. You can always upgrade if you cross the ops limit. (Make sends notifications before this happens.)
• Keep track of your operations on a semi-regular basis. When you click on a scenario, you can see the day-by-day graph with the number of operations and data transfer.

Using Make: Pros and Cons

Is Make Right for You?

I absolutely love Make for its incredible flexibility and power. But there are also things I don’t like, such as the unnecessarily complex data mapping (it could be a lot simpler).

Overall, Make is a brilliant tool that gives you automation superpowers beyond anything else I've seen on the market. Combined with its remarkably affordable pricing, it's a fantastic platform for serious users who want to create sophisticated, multi-step automations that truly transform their business operations.

That said, if you're looking to automate just one or two simple workflows, a more straightforward solution with a shorter learning curve, such as Zapier, might be a better fit. Make rewards those willing to climb its steep learning curve with unparalleled capabilities, but you need to decide if the investment in learning the platform aligns with your automation goals.

For me, the answer was a resounding yes! The time I invested in mastering Make will pay dividends many times over through the hours I could save. There’s nothing as satisfying as seeing a complex scenario live and working.