Introduction to Make (formerly Integromat)
If you’re spending 10+ hours a week copying data between Shopify and QuickBooks, manually chasing client onboarding tasks, or hiring staff just to handle repetitive support tickets you already understand the cost of not automating. Make (formerly Integromat) is built to solve exactly that.
Make is a cloud-based, visual automation and integration platform that lets you connect over 3,000 apps and APIs and build multi-step workflows called scenarios without writing a single line of code. Originally founded in Prague in 2012 as Integromat, the platform was acquired by Celonis in 2020 and rebranded as Make in 2022. Today it serves everyone from solo operators to enterprise teams.
What separates Make from simpler tools like Zapier is its visual canvas approach. You literally see your data flowing through each step of a workflow. This makes it significantly easier to build, debug, and scale complex automations branching logic, conditional routing, error handling, and all.
Start free on Make – no credit card required (Free plan includes 1,000 operations/month).
Product Categories Overview
Make is not a single product it’s a platform with several distinct capability layers. Understanding what each one does helps you use it strategically rather than just reactively.
Visual Scenario Builder
The core of Make is the scenario builder: a drag-and-drop canvas where you connect app modules to form automated workflows. Each scenario starts with a trigger (e.g., a new Shopify order) and flows through a series of actions (e.g., create a QuickBooks invoice, send a Slack alert, update a Google Sheet). The visual layout is Make’s biggest differentiator it shows you the data at every step, making debugging far more intuitive than list-based automation tools.
Pre-Built Templates
Make’s template library includes over 7,000 ready-made automation templates covering common use cases across e-commerce, marketing, finance, CRM, and IT operations. For businesses just starting out, templates dramatically shorten the time to value. Search by app name (e.g., “Shopify”) and you’ll find pre-wired scenarios ready to configure in minutes.
Advanced Flow Control Tools
Make goes well beyond basic trigger-action automation. Its flow control toolkit includes routers (branch your workflow into multiple parallel paths), filters (only continue if conditions are met), iterators (process items in a list one by one), and aggregators (combine multiple data points into one). Combined, these tools let you model real business logic not just simple “if this, then that” connections.
Data Stores
Data Stores act as Make’s built-in lightweight database. You can store, retrieve, and update records directly within your scenarios useful for tracking state between runs, managing counters, or deduplicating entries without needing a third-party database tool.
Webhooks and HTTP Modules
For apps that aren’t in Make’s native library, the platform provides webhook receivers and a general HTTP request module. This means you can technically connect Make to any service that has an API giving you near-unlimited integration reach.
AI and Agentic Automation
As of 2026, Make has rolled out native AI modules supporting OpenAI, Claude, and Anthropic APIs, enabling no-code AI pipelines. The Make Grid environment (now available to all paid users) provides a visual interface for managing multi-agent automation a significant step toward AI-powered business operations without requiring engineering resources.
Explore Make’s full feature set and integrations – 3,000+ app connections available.
How to Choose the Right Plan
Make uses a credit-based pricing model where each module action in a scenario consumes one credit (called an “operation”). This is worth understanding before you pick a plan, because complex scenarios that loop through many records can consume credits quickly.
Here’s how the current plans break down:
- Free Plan: 1,000 operations/month, 2 active scenarios. Sufficient for testing and small personal automations. A permanent trial not time-limited.
- Core Plan: Starts at $9/month (billed monthly) for 10,000 operations. Suitable for solopreneurs and small businesses running a handful of workflows.
- Pro Plan: Starts at $16/month for 10,000 operations. Adds priority scenario execution important when your workflows are time-sensitive (e.g., order confirmations, lead routing).
- Teams Plan: Starts at $29/month for 10,000 operations. Built for collaborative use with shared workspaces, team permissions, and organisation-level controls.
- Enterprise Plan: Custom pricing. Includes advanced security, governance features, on-premise agents, and 24/7 dedicated support. Aimed at larger organisations with compliance requirements.
One important caveat: operations can run out faster than expected, especially with iterative workflows. A scenario that runs every 15 minutes with 5 steps consumes roughly 480 operations per day. Monitor your execution logs regularly once you go live. On any paid plan, you can also purchase additional operations in blocks if you hit your monthly limit.
For most solopreneurs and small digital agencies, the Core or Pro plan covers everyday needs. Teams managing multiple client workflows or running high-frequency automations should look seriously at the Teams plan or explore volume-based pricing with Make directly.
View full Make pricing details – compare plans and calculate your operations need.
Setup and Getting Started
Getting up and running on Make is straightforward, though the platform rewards those who invest a little time upfront learning its vocabulary.
Step 1: Create Your Account
Sign up for Make’s free plan no credit card required. Once in, explore the dashboard and spend a few minutes inside the scenario builder canvas before building anything. Familiarity with the interface pays dividends.
Step 2: Choose a Template or Start Blank
For first-time users, starting with a template is strongly recommended. Navigate to the Templates library, search by your app (e.g., “Shopify,” “Gmail,” “QuickBooks”), and select a scenario that matches your use case. Make’s guided setup walks you through each module sequentially you can configure any module in any order, and green icons confirm completion.
If you have a specific workflow in mind that no template covers, start a blank scenario and build from scratch.
Step 3: Set a Trigger
Every scenario starts with a trigger the event that kicks off the automation. Common triggers include: a new order in Shopify, a form submission, a new row in Google Sheets, a webhook call, or a scheduled time interval. Choose what fits your workflow.
Step 4: Add Action Modules
After the trigger, add action modules each one representing a task Make performs in another app. For example: create a customer in HubSpot, send a confirmation email via Gmail, log data to Airtable. Connect modules by clicking between them on the canvas.
Step 5: Map Your Data Fields
This is where Make differs from simpler tools. You explicitly map which data fields from one module feed into the next. For example, the customer email from a Shopify order maps to the “To” field in your Gmail module. The visual field mapper shows you live data from previous runs, making it easy to confirm you’ve wired things correctly.
Step 6: Add Filters, Routers, or Error Handlers
For more sophisticated workflows, add logic layers. A filter might say “only continue if the order value is over £100.” A router might split orders from UK customers and international customers into different paths. Error handlers define what happens if a step fails retry automatically, skip, or alert you via Slack.
Step 7: Test, Then Activate
Always run your scenario with sample data before going live. Review the execution log to confirm each module processed correctly. Once satisfied, activate the scenario it will now run automatically based on your trigger conditions.
Start building your first automation on Make for free – no code, no commitment.
Advanced Tips and Tricks
Once you’ve got the basics down, these techniques will help you build more powerful, cost-efficient workflows.
Use Filters Early to Save Operations
Place filters as early as possible in your scenario ideally right after the trigger. If a scenario processes 500 records but only 20 meet your criteria, filtering at the start means only 20 records flow through the rest of the workflow. This can cut your credit consumption dramatically.
Enable Operation Rollover
As of late 2025, Make introduced operation rollover on paid plans. Unused operations from one month carry over to the next. This is particularly valuable for businesses with seasonal or uneven automation loads.
Build Modular “Sub-Scenarios”
For complex workflows, break your logic into smaller, reusable scenarios that call each other. Make supports scenario-to-scenario calls, which keeps individual flows manageable and makes debugging much easier. Think of it like functions in code.
Leverage the Make AI Scenario Suggestions (Pro+)
Pro plan users and above now have access to AI-powered scenario suggestions. When you describe your use case in plain language, Make can propose a starting structure a useful shortcut for unfamiliar use cases or when you’re mapping new client workflows.
Use Data Stores for Cross-Scenario Memory
If you need one scenario to remember information from a previous run (e.g., tracking which records you’ve already processed), Data Stores are the answer. They persist between scenario runs and can be read and written across multiple scenarios.
Monitor Execution Logs Proactively
Don’t wait for something to break. Schedule a regular review of your execution logs weekly for active production scenarios. Catching a misconfigured filter or a failed API call early prevents silent data errors from compounding over time.
Troubleshooting Common Issues
Operations are running out faster than expected
This almost always comes down to iterative loops or high polling frequency. Audit your scenarios for any use of iterators or aggregators processing large data sets. Where possible, use filters before iterators to limit the data set. Also check polling intervals if a scenario checks for new data every minute but your trigger fires 50 times a day, reduce the polling frequency on lower-priority workflows.
Modules show errors mid-scenario
Use Make’s error handler module to catch failures gracefully rather than letting the scenario halt. Set failed scenarios to either retry (for transient API errors) or route to an error-specific path (e.g., log to a Google Sheet and alert you via email). The execution log shows the exact module and data state at the point of failure start there.
Data isn’t mapping correctly between modules
If data appears as empty or misformatted in a downstream module, the most common culprits are: the source field name changed in the upstream app, the data type is mismatched (e.g., date format), or you’re referencing a field from the wrong module bundle. Re-open the field mapper and select a recent execution record to see live data flowing through each module.
Scenario activated but not running
Check that the scenario is set to “On” (the toggle in the top-left of the scenario builder) and that your trigger is configured correctly. Webhook-based triggers require the webhook URL to be actively registered in the source app. Scheduled triggers require an explicit “Next run” time to have been set.
Steep initial learning curve
Make’s own community forum and YouTube channel are the fastest resources for getting unstuck. The official Make Academy also offers structured courses free for all users. For agency owners or operations managers deploying Make across multiple clients, investing a day in the Academy upfront pays back many times over.
Conclusion and Next Steps
Make (formerly Integromat) is one of the most capable automation platforms available in 2026, particularly for businesses that need to go beyond simple two-step automations. Its visual workflow builder, deep flow control logic, and expanding AI capabilities make it a strong fit for e-commerce operators, digital agencies, SaaS teams, and operations managers who need real flexibility not just a basic “if this, then that” tool.
The free plan is generous enough to validate your most important workflows before committing to a paid tier, and the credit-based pricing model scales predictably with your actual usage. The main investment is time: expect to spend a few hours learning the platform before you hit your stride. For most businesses, that investment pays off within the first week of automation running in the background.
The best next step is simply to start. Sign up for the free plan, find a template that matches one of your most time-consuming manual processes, and run it. Many users find their first working scenario within an hour.
Get started with Make for free today – 1,000 free operations/month, no credit card required
Compare Make pricing plans – Core from $9/month, Teams from $29/month