Make.com is a visual automation platform that connects apps and moves data between them without code. For beginners, the key ideas are simple: you build a scenario on a canvas, it starts with a trigger module that watches for something new, and each following module does one action with that data, like adding a row to Google Sheets or posting to Slack. Once you understand scenarios, modules, bundles, mapping, routers and filters, you can build most business automations.
All the production automations I cite on this site were built in Make, so it is the tool I know best. This Make.com tutorial explains the concepts in plain language, walks through a first scenario and covers the mistakes that trip beginners up.
What is Make.com?
Make (formerly Integromat) lets you connect web apps through a drag-and-drop editor. Each app has modules that represent triggers, actions and searches. You link modules into a flow, map data from one into the next, and switch the scenario on. Make then runs it on a schedule or instantly when a webhook arrives.
Compared with Zapier, Make gives you more visual control over branching, looping and data handling, and is often cheaper per step. Compared with n8n, it is easier to start with and fully hosted. My n8n vs Zapier vs Make comparison covers the differences.
The core concepts
Scenario
A scenario is one automation: the full flow from trigger to final action. You can have many scenarios, organise them in folders, and switch each on or off.
Module
A module is one step. There are a few types:
- Triggers start the scenario, like "Watch Rows" in Google Sheets or "Custom webhook".
- Actions do something, like "Create a Message" in Slack.
- Searches look something up, like "Search Rows".
- Aggregators and iterators combine or split data.
Bundle
A bundle is one package of data moving through the scenario. If a trigger finds three new rows, it outputs three bundles, and each later module runs once per bundle. Understanding bundles is the single most useful thing for a beginner, because it explains why a scenario sometimes runs a module more times than you expected.
Mapping
Mapping is how you pass data from one module to the next. When you click a field in a module, Make shows the outputs of earlier modules, and you click to insert them. You can also use functions to format text, dates and numbers.
Router and filters
A Router splits a scenario into several paths. A filter on each path decides whether a bundle continues. For example, route leads with "budget over X" to Slack and everyone else to an email sequence.
Operations and credits
Make bills by usage. Each module run generally counts toward your usage allowance, which Make now expresses in credits on its pricing. Check the current Make pricing page for how it is counted on your plan. My post on Make.com pricing vs Zapier explains how to estimate it.
Make.com how to use: your first scenario
Let us build something useful: when a new row is added to a Google Sheet of leads, post a message in Slack.
- Create a scenario. In Make, create a new scenario. You land on an empty canvas with a big plus button.
- Add the trigger. Choose Google Sheets and the "Watch Rows" trigger. Connect your Google account, pick the spreadsheet and sheet, and confirm the sheet has headers.
- Choose where to start. Make asks whether to process existing rows or only new ones. For a first test, choose to start from a recent row so you have data to work with.
- Add the action. Click the plus to the right of the trigger, choose Slack and "Create a Message". Connect Slack and pick the channel.
- Map the data. In the message text field, type "New lead: " then click to insert the Name column from the Sheets module, then the Email column.
- Run once. Click "Run once" at the bottom. Make runs the trigger and the action. Check Slack for the message.
- Inspect the bubbles. Click the small bubble above each module to see what data came in and went out. This is how you debug everything in Make.
- Set the schedule. Click the clock on the trigger and set how often it should check, for example every 15 minutes.
- Switch it on. Toggle the scenario on. It will now run on schedule.
My Make.com Google Sheets guide goes deeper on the Sheets modules.
Instant triggers vs scheduled triggers
Some triggers are instant: they use a webhook, so the scenario runs the moment the data arrives. Others poll: they check for new data on a schedule. Instant is better for anything time-sensitive, like lead follow-up. Polling is fine for reports and syncs. When an app supports both, prefer instant. See my Make.com webhooks guide.
Beginner tips that save hours
- Name your modules. Right-click a module and rename it, like "Get lead row" or "Post to sales channel". Future you will be grateful.
- Use notes. Add a note to tricky modules explaining why they exist.
- Test with real-looking data. Empty test rows produce empty mappings.
- Watch bundle counts. If a module ran 50 times, it is because 50 bundles reached it. Use filters or aggregators to control that.
- Add error handling early. Right-click a module and add an error handler, at least a Slack alert, so failures do not go unnoticed. See Make.com error handling.
- Keep scenarios focused. One scenario per job is easier to fix than one giant scenario that does everything.
Common beginner mistakes
- Forgetting to switch the scenario on after testing with Run once.
- Processing all existing rows by accident on the first run, which floods Slack or sends duplicate emails.
- Mapping the wrong bundle after a router or iterator.
- Hard-coding values like channel names or email addresses that should come from data.
- Building inside one huge scenario until it is impossible to debug.
- No error alerts. A scenario that fails quietly is worse than no scenario, because people trust it.
What to build next
Once you are comfortable, good next projects for an agency are:
- A form submission that creates a ClickUp task and a Slack alert.
- A failed-payment email parsed into a Slack ping and a task. I built this as the failed-payment alerts scenario using a mailhook and pattern matching.
- A weekly summary from a Google Sheet posted to Slack.
- A new-client form that creates folders, docs and projects. My client onboarding build does this.
For more ideas, see my list of Make.com scenario templates.
How I build this
If you would rather have someone build your scenarios properly, with naming, error handling and documentation, that is what I do for agencies. See my workflow automation service or the fixed-price Automation Rescue if you already have a scenario that is misbehaving. You can also request a free 15-minute Loom teardown of what you have built so far.
FAQ
Is Make.com easy for beginners?
Yes, once you understand scenarios, modules and bundles. Simple two-step scenarios take minutes. Branching and data handling take more practice.
Is Make.com free?
Make offers a free plan with a limited monthly usage allowance, which is enough to learn and run small scenarios. Check the current pricing page for limits.
What is a bundle in Make.com?
A bundle is one package of data passing through a scenario. If a trigger outputs five bundles, each following module runs five times unless you filter or aggregate them.
What is the difference between Make.com and Zapier?
Both connect apps. Make gives more visual control over branching, looping and data handling and is often cheaper per step, while Zapier is simpler to start with and has a very large app library.