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.
• Credits: Each time a module in a scenario is fired, it consumes a credit or multiple credits, depending on its complexity. Make’s pricing is based on the number of credits.
• Operations: An operation is a single module run to process data or check for new data. When you run a scenario, each of its modules runs one or more times, resulting in one or more operations.
• 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.

What’s the difference between credits and operations?

The platform recently changed how it bills usage, so “credits” now replace “operations” as the billing unit. Credits are the new currency for what you pay for; operations remain a metric for what happened internally during a run (how many modules fired and how much data processed).

The old “one operation = one billing unit” model treated all module runs equally. In reality, some operations are much heavier than others. The new credits model lets Make price “heavier” or more resource-intensive tasks more accurately.

In practice for you, this means that if you use heavy workflows and AI modules, you’ll notice a difference in the costs of your workflows, as now they use more credits. This change comes alongside Make's recent move towards AI.

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 at some of the things that make it different.

Comprehensive Integration Ecosystem

As of writing this post, Make boasts 3,000+ 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 how to use 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. 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.”

Make previously had an AI assistant that I found quite helpful with this. But Make retired it in October, so you won’t be able to locate it in your workflow builder. They claim the new AI experience will replace it. As of this writing, I can’t see a direct replacement for the AI support assistant, which is disappointing for people who rely on its help to create flows.

Gumloop, a Make competitor, also has a great (or even better) AI assistant. Read more in my Gumloop review.

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.

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 and Building AI Agents

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 a scenario, and walk you through the entire automation.

Make has also recently added the ability to use AI agents to help you build workflows. I'll walk you through how that went, too.

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 on 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. This would provide 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.

Using Makes AI Agents

Make launched AI Agents in April 2025. It's a significant shift from their traditional workflow builder. Instead of mapping out every single conditional branch manually, you can now describe what you want in natural language and let the agent figure out how to execute it.

Make’s AI Agents are automated workers that can think, decide, and perform tasks inside your Make workflows. Instead of just following step-by-step instructions, they use AI to understand context, analyze information, and choose the right action—similar to giving your automation a “brain.”

Let’s try it out in practice by building a simple support agent.

Testing My First Make Agent

Go to the new Agent’s tab and click on “Create a new agent”. You’ll be prompted to connect an LLM.

The list of LLM options is quite limited now (at least for my free account). I also didn’t see the option to use my own API keys.

Defining the Agent’s Prompt

The agent prompt should define the agent's purpose and any constraints and guardrails it should follow. For my agent, I’ll just use a basic customer service agent prompt:

You can also improve the agent's context with PDF, text, and CSV files, but each file should not exceed 20 MB. For instance, you can export your knowledge base as a CSV file and enrich the agent's knowledge.

Connecting Agent's Tools

Tools are the scenarios that your agent can access and execute. I’m not sure why Make decided to introduce new terminology here instead of just calling them scenarios, but that's what we're working with.

For my customer service agent, I'll create a scenario that pulls data from a Google Doc. It’s essentially a help doc that serves as the agent's knowledge base. This is smarter than manually uploading documents because the agent's knowledge stays current by automatically syncing with whatever's in the Google Doc.

To do that, we can use the Google Doc “Get Content of a Document” module connected to a Scenarios “Return output” module.

You also want to define the scenario’s output:

Once defined, select “text content” on the Scenarios “Return Output” module:

Lastly, activate the scenario, as agents can only work with active scenarios running on demand.

This scenario allows our agent to respond to people with up-to-date content.

Now we need one more scenario to enable the agent to send emails. For this, we’ll use the Gmail “Send an Email” module and define the dynamic customer data as scenario inputs. This way, the agent will know exactly who to send the email to:

Once those are in place, you can map them to the right fields in the Google “Send an Email” module. To do that, you need custom variables (available on Pro plans and above).

Go back to the agent and connect the scenarios as tools. Agent-level tools (scenarios) are always available, regardless of the task the agent is performing. In other words, this set of scenarios works as a bundle that the agent can access.

I’ll also add a bit more instructions to the prompt:

To ensure the agent works properly, use the chat test box. You can see how the agent prompts the attached scenarios and where it fails.

If you've been following along, you've probably noticed that creating an agent in Make is pretty manual. Unlike tools like Gumloop, which let you spin up agents with prompts, Make requires you to build everything step by step.

But what really holds Make's agents back is that you can't use them outside of a scenario. There's no way to embed the chat interface or deploy the agent on its own. I was hoping for something more plug-and-play that didn't force me into the scenario builder every time. As it stands, AI agents in Make are just an extension of their scenarios.

Another thing that disappointed me is that there aren’t any advanced settings to fine-tune agent behavior yet — e.g., guardrails, creativity level, tone, etc. You need to input all of these in your prompt.

Using Agents in Scenarios

In my scenario, I want the agent to respond to any new incoming support requests in Zendesk. I’ll use the Zendesk “Watch Tickets” module and connect it to a Make AI Agents “Run an Agent” module:

In the Make AI Agents, I’ll set up a message and map the fields from the Zendesk module, along with clear instructions for the agent.

This scenario will process any new Zendesk tickets and automatically respond to the customer via email using the knowledge from my Google doc. Quite neat!

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, plus a 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 $10.95 per month.

Each module action in a scenario, like adding a Google Sheet row or sending an email, counts as a credit in Make. This makes it easy to deplete your monthly credits quickly if you have complex scenarios. If you run out of credits, your scenarios will stop running!

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 and 10,000 credits only, which makes it more of a free trial.

The next plan, the Core tier, offers the essentials for solopreneurs with unlimited workflows and 10,000 credits for $10.59/month.

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).

Although not listed on the pricing page, you can purchase extra credits in fixed-price bundles for 1 or 10,000 credits if you exceed your monthly quota. To do that, go to Org from the left sidebar, then to the Subscription tab in My Plan. Note that if you do that regularly, it’s best to simply upgrade to a higher tier plan, as they have lower per-credit costs.

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 credits option, otherwise, unused credits 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 credits on a semi-regular basis. When you click on a scenario, you can see the day-by-day graph with the number of credits 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.

Not sold on Make? Check out our n8n Review to see how it compares.