Make automation connects your apps so they exchange data automatically, without you writing code. A form gets filled out, your CRM updates, Slack pings your team, and a follow-up email goes out. You set it up once. It runs every time.
That’s what Make (formerly Integromat) does. You drag app icons onto a visual canvas, draw lines between them, and tell each one what to do when data arrives. Marketers love it because their stack is fragmented: CRM here, email tool there, spreadsheets everywhere. Make is the glue.
I started using Make after spending too many hours copy-pasting data between tools. The learning curve took me about a weekend. The time it saved me in the first month made it obvious I should have started sooner. 94% of workers say they perform repetitive tasks that could be automated. If that’s you, Make is one of the fastest ways to stop.
This guide covers how Make works, what it actually costs (the real math, not the marketing page version), and a step-by-step first scenario you can build today. If you want the broader picture of task automation solutions before picking a platform, start there.
What Make automation is and why marketers use it
Think of Make as a control room for your marketing stack. You have apps on one side (your form builder, CRM, email tool, Slack) and you draw connections between them. When something happens in one app, Make does something in another.
The technical name is “trigger-action model.” When X happens, do Y. Every automation platform works this way (the broader category is called intelligent workflow automation), but Make stands out for one reason: the visual canvas.
Where Zapier gives you a linear list of steps (step 1, step 2, step 3), Make gives you a map. You can see branches, loops, and error routes all at once. That matters the moment your workflow gets even slightly complex.
Make connects to 2,500+ apps as of 2026. If an app has an API (a way for software to talk to other software), Make can probably connect to it. And even if there’s no pre-built connection, you can use the HTTP module to talk to anything.
My take: Make is the right tool for marketers who need more than “if this, then that” but don’t want to learn Python. If your workflows have branches (“if the deal is over $5K, do this; if not, do that”), Make handles that visually where simpler tools can’t.
Gartner forecasts that low-code platforms will account for 75% of new app development by 2026. Make sits right in that wave. You’re not learning to code. You’re learning to connect the tools you already use. (If you’re figuring out which AI tools belong in your stack in the first place, the best AI for marketing guide covers the full lineup.)
How Make works (the scenario model)
Everything in Make starts with a scenario. A scenario is one automation, a chain of steps that runs when something triggers it.
The building blocks:
Triggers start the scenario. Two types. An instant trigger fires the moment something happens (a form submission, or a webhook, which is just a URL that receives data from another app). A scheduled trigger checks for new data at an interval you set, say every 5 or 15 minutes. That distinction matters for cost, and I’ll get to why in the pricing section.
Modules are the actions. Each module talks to one app and does one thing: create a contact in HubSpot, send a message in Slack, add a row to Google Sheets. You chain them together on the canvas.
Routers split the flow. And this is the part that makes Make worth learning. A router lets you branch: if the lead source is “website,” go one way. If it’s “referral,” go another. Zapier added something similar recently, but Make’s visual layout makes branching much easier to follow.
Filters sit between modules and only pass data that meets your conditions. “Only continue if the email isn’t blank.” Simple but powerful.
Error handling is built in. Every module can have an error route: what to do if this step fails. You can ignore it, retry, or stop the whole scenario. Most beginners skip this. Don’t. The first time a scenario fails silently at 2 AM, you’ll wish you’d set it up.
Make also connects to AI models natively. Make launched AI Agents in spring 2025, and you can add modules for OpenAI, Claude, or Google Gemini directly into your scenario. Feed in a lead’s message, get back a summary or a score. That’s the moment “make ai” stops being a buzzword and becomes a real workflow. If you’re curious about where this is heading, the generative AI workflow guide goes deeper.
A concrete example to make this real: a new lead fills out your contact form. That triggers the scenario. Module 1 creates a contact in your CRM. The router checks the form’s “budget” field. If it’s over $5K, Module 2 sends a Slack message to your sales lead. If it’s under $5K, Module 3 sends an automated email with your pricing page. All of that runs in about two seconds. You built it by dragging boxes and drawing lines.
For people exploring how to make AI part of their actual workflows, not just a chatbot you ask questions to, this is where it all comes together. You can wire AI into a real business process, visually. No code. The guide on building AI agents goes deeper if you’re ready.
What Make costs (real math, not marketing pages)
Automation websites like make.com show you a clean tier table. I’ll walk through the real numbers behind it, because what you actually pay depends on how you build.
The tiers:
| Plan | Price | Credits/month | Active scenarios | Best for |
|---|---|---|---|---|
| Free | $0 | 1,000 | 2 | Learning, testing |
| Core | $9/mo | 10,000 | Unlimited | Simple automations |
| Pro | $16/mo | 10,000 | Unlimited | Priority + advanced features |
| Teams | $29/mo | 10,000 | Unlimited | Multi-user |
Looks straightforward. It isn’t.
The credit shift. In August 2025, Make changed from flat “operations” to variable “credits.” Most actions still cost 1 credit. But AI features (the OpenAI module, the Claude module) cost multiple credits per action. A single AI call might eat 3 to 5 credits. That makes costs unpredictable for AI-heavy workflows.
Hidden cost 1: polling triggers. If your scenario uses a scheduled trigger that checks for new data every 5 minutes, that check costs a credit whether or not there’s new data. Count with me: 1 check every 5 minutes = 12 per hour = 288 per day = roughly 8,640 credits per month. Just from checking. Your Core plan’s 10,000 credits are almost gone before your scenario does any actual work.
Hidden cost 2: failed retries. When a module fails and retries, each retry uses credits. A flaky API that fails and retries three times just tripled the cost of that step.
Hidden cost 3: credit add-on packs. When you burn through your base credits, the add-on packs cost about 25% more per credit than your plan’s base rate. So going over budget gets expensive fast.
Real math example. Say you build a marketing scenario with 5 modules, running every 15 minutes. That’s 4 runs per hour, 96 per day, about 2,880 runs per month. At 5 credits per run (1 trigger + 4 modules), that’s 14,400 credits. The Core plan gives you 10,000. You’re already over.
My take: Make is still 3 to 5 times cheaper than Zapier at similar volume. But you need to architect carefully. Use instant triggers (webhooks) instead of polling wherever you can. That single change can cut your credit use by 60%.
For small business automation on a tight budget, the free plan is enough to learn and test. But plan to move to Core quickly once you’re running real workflows.
Build your first Make scenario (step by step)
This is the scenario I recommend starting with. It’s the most common marketing automation, and it touches every Make concept that matters: triggers, modules, routers, and data mapping.
What you’ll build: new form submission → CRM contact created → Slack notification to your team → confirmation email to the lead.
Step 1: Create your Make account. Go to make.com and sign up. The free plan gives you 1,000 credits and 2 active scenarios. That’s plenty for this.
Step 2: Create a new scenario. Click “Create a new scenario.” You’ll see a blank canvas with a plus icon in the center. That’s your starting point.
Step 3: Add your trigger. Click the plus icon, search for your form tool (Google Forms, Typeform, or Tally all work). Select the “Watch New Responses” trigger. Connect your account, pick your form. Every time someone submits, the scenario fires.
Step 4: Add your CRM module. Click the small plus icon that appears to the right of your trigger. Search for your CRM (HubSpot, Pipedrive, whatever you use). Select “Create a Contact.” Now map the fields: drag the form’s “email” field into the CRM’s email field, “name” into name. This mapping is the core skill. Once you understand it, you can connect anything.
Step 5: Add a router. Click the plus after your CRM module, and add a Router. This splits your flow. Set up two branches. On branch one, add a filter: “lead source equals website.” On branch two: “lead source equals referral.” You can use any field from the form to decide the path.
Step 6: Add your actions. On the website branch, add a Slack module (“Send a Message”). Pick the channel, write the message, and drop in form fields so the notification shows the lead’s name and email. On the referral branch, add an email module (“Send an Email”) with a confirmation message.
Step 7: Test it. Click “Run once” at the bottom left. Submit a test form entry. Watch the data flow through each module. Green circles mean success. If something’s red, click it to see the error.
Step 8: Activate. Toggle the scenario on. Set your schedule (instant is best if your trigger supports webhooks; otherwise every 15 minutes). Done.
That’s work automation, running. You just connected four tools without writing a line of code. Forrester found that automation deployments return 248% over three years. Even a simple scenario like this one starts compounding the moment you turn it on.
One tip from experience: treat each scenario like a product. Define what goes in (the trigger), what comes out (the final actions), and what happens when something breaks (error routes). That mindset saves you from building something fragile.
If you want someone to look at your scenario and spot what you’re missing, I do a free 15-minute spar. No pitch, just looking at your setup together.
Five Make scenarios worth building next
After the starter scenario, these are the workflows I’d build next. Sorted by impact. For a broader list, the business automation examples guide covers more use cases across platforms.
1. Lead scoring and routing Trigger: new form submission. Modules: AI module (score the lead based on company size, role, and message), Router (high score → Slack alert to your best sales rep, low score → nurture email sequence). Credits: roughly 8 per run (AI module costs more). Difficulty: medium.
That’s online business automation paying for itself. The AI module reads the form data and returns a number. The router does the rest. You’re not building a machine learning model. You’re just asking Claude or GPT to rate a lead from 1 to 10.
2. Content repurposing You publish a blog post, and an RSS trigger kicks off the scenario. An AI module writes a LinkedIn post, a tweet thread, and an email summary from the full text. Then a scheduling module (Buffer or Hootsuite) queues them up. Roughly 15 credits per run.
The AI modules do the heavy lifting here. Feed in the full blog post, get back three pieces of content in your voice. For a deeper look at this pattern, see the content automation guide.
3. Invoice automation A deal closes in your CRM, and Make generates the invoice, sends it to the client, and logs it in your accounting tool. About 5 credits per run. Easiest one on this list.
4. Review monitoring Set a trigger to check Google or Trustpilot every hour. New review comes in? Slack alert. Negative review? Auto-create a support ticket. Roughly 3 credits per run, plus polling costs for the hourly check.
5. Weekly reporting Every Monday at 9 AM, Make pulls numbers from GA4, your CRM, and your ad platforms, drops them into a Google Sheet, and emails the summary to your team. About 10 credits per run. The data mapping takes patience, but you only set it up once.
Each of these follows the same pattern you already learned: trigger, modules, router, actions. The maker automation skills from your starter scenario transfer directly. Start with one, get it stable, then add the next. If SEO is part of your workflow, you can also automate your SEO workflow with Make handling the connections between crawlers, rank trackers, and reporting dashboards.
Where Make hits its ceiling (and what to do about it)
I’d rather be honest about where Make stops being the right tool than pretend it does everything.
Complex scenarios get messy. Once a scenario has 20 or more modules, the visual canvas that was an advantage becomes a headache. It’s hard to navigate, hard to debug, and easy to break when you change one thing.
High volume eats credits. If you’re processing thousands of records daily, the credit costs add up fast. A batch job that runs through 1,000 rows with 5 modules each is 5,000 credits in one run. That’s half your monthly Core plan allocation in minutes.
Data transfer caps. Lower plans cap data transfer at 1GB per month. If you’re moving files (images, PDFs, CSVs), you hit that limit quickly.
AI costs are unpredictable. The variable credit pricing for AI modules makes it hard to forecast monthly costs. A scenario that costs $9/month today might cost $30 if you add two AI steps.
The honest stat: 42% of companies abandoned most AI workflow initiatives in 2024. Not because the tools were bad, but because complexity killed them. Make isn’t immune to that.
When to consider alternatives:
There are low-code automation options for every stage. n8n is self-hosted and has unlimited operations (no credit meter), but you need to be comfortable with a terminal. Zapier is simpler but more expensive at volume. Custom code gives you full control at the highest cost.
The approach I’ve seen work best: use Make for marketing automations under 15 modules. Graduate high-volume or complex processing to n8n or code. Don’t try to build everything in one platform. For more on the broader category of business workflow automation software, that guide compares the options.
Make vs. Zapier vs. n8n (the short version)
| Make | Zapier | n8n | |
|---|---|---|---|
| Integrations | 2,500+ | 7,000+ | 400+ native (API for anything) |
| Price at 10K actions | $9/mo | $20-30/mo | Free (self-hosted) or $20/mo (cloud) |
| Price at 50K actions | ~$29/mo | $100+/mo | Free (self-hosted) |
| Visual builder | Canvas with branching | Linear wizard | Canvas (technical UI) |
| AI features | Native modules (OpenAI, Claude, Gemini) | Native (OpenAI, others) | Full code access to any API |
| Learning curve | Medium (weekend to learn) | Low (hours) | Higher (needs some tech comfort) |
| Best for | Marketers who need branching | Non-technical users wanting simplicity | Dev-led teams wanting control |
The decision is simpler than it looks. I spent way too long comparing these three before I just picked one and started building.
If you need branching logic and want to keep costs reasonable, pick Make. If you’ve never automated anything and want the fastest start, pick Zapier. If you have a developer on the team and want unlimited volume, pick n8n.
Most teams don’t need to decide once and forever. Start with Make or Zapier for simple workflows. Move to n8n if volume or complexity outgrows them. The AI integration platform guide covers the full picture if you want to go wider.
How I can help
Picking a tool is the easy part. The hard part is looking at your actual stack, your actual workflows, and figuring out which automation will save you the most time with the least complexity.
That’s what I do in a free 15-minute spar. No pitch, no deck. You show me what you’re working with, I tell you what I’d automate first and how I’d build it. If it makes sense to work together after that, great. If not, you leave with a clear plan.
FAQ
What does Make automation do?
Make connects your apps so they exchange data automatically, following visual if-then scenarios you build on a canvas. When something happens in one app (a form submission, a new email, a CRM update), Make triggers actions in other apps. No code required. You set up the flow once, and it runs every time the trigger fires.
Is Make automation free?
Make has a free plan: 1,000 credits per month and 2 active scenarios. That’s enough to learn the platform and test basic workflows. For real production use, you’ll need the Core plan at $9 per month, which gives you 10,000 credits and unlimited scenarios. Just watch the credit math carefully. Polling triggers alone can eat most of your monthly budget.
Are Make and Zapier the same?
Both automate app connections, but they work differently. Make uses a visual canvas where you can see branches, loops, and error routes all at once. Zapier uses a linear step-by-step wizard. Make is cheaper at volume (3 to 5 times less at similar usage). Zapier has more pre-built integrations (7,000+ vs. 2,500+) and is easier to learn. Pick Make if your workflows branch. Pick Zapier if they’re straight lines.
What can I automate with Make?
Anything that follows “when X happens, do Y.” Lead routing, invoice creation, social media scheduling, data syncs between tools, AI-powered content processing, review monitoring, weekly reporting. If the task is repeated and rule-based, Make can handle it. The platform connects to 2,500+ apps, plus anything with an API through its HTTP module.
How many integrations does Make have?
Make has 2,500+ native integrations as of 2026, covering CRMs, email tools, social platforms, payment systems, project management, and more. For apps without a native connector, the HTTP and webhook modules let you connect to any service with an API. So the real number is closer to “anything you use.”