Triggers, modules, and connections

Triggers define when a scenario runs. ✓

• Triggers can be instant (for example, a webhook) or polling/scheduled. ✓
• For modules to work, you must connect/authorize external accounts (for example, Google or Slack). ✓

Data mapping and logic inside scenarios

As data moves through a scenario, you map outputs from one module into inputs of the next. This is data mapping. ✓

For control flow and conditional paths:

• Routers and Filters provide branching and conditional logic within scenarios. ✓
• Iterators help you loop through lists (handle repeated items). ✓
• Built-in functions support data transformation such as date formatting, calculations, and string manipulation. ✓

Testing and monitoring

Make.com includes a test mode and run visibility so you can validate and troubleshoot scenarios.

• Use Run once to execute a scenario with sample data and inspect each module’s inputs/outputs. ✓
• Use execution history/logs to monitor runs and debug issues. ✓

Templates and pricing context

If you don’t want to start from scratch, templates are available so you can start from pre-built automations. ✓

Make.com also offers a free tier with a stated operations allocation (example mentioned: 1,000 operations/month). ✓

To follow along with the rest of this guide, you can create a free Make.com account.

Make.com, scenarios, and modules

• Make.com is a visual automation platform that connects apps and services into automated workflows called scenarios. ✓
• Make.com was formerly called Integromat. ✓
• A scenario is a workflow made of modules (steps). ✓
• A module is an individual step that represents an app and the action it performs inside a scenario. ✓

To follow along as you learn these concepts, you can get started with Make.com.

Trigger → actions → logic (the core workflow pattern)

Make.com scenarios typically follow a trigger → actions → logic pattern:

• Trigger: starts a scenario run. ✓
• Actions: the modules that perform tasks after the trigger. ✓
• Logic: how you branch or control what happens next using routers and filters. ✓

Triggers (instant vs scheduled)

Triggers define when your scenario runs. ✓

• Instant triggers use webhooks (event-driven). ✓
• Polling/scheduled triggers check on a schedule. ✓

Actions (what your scenario does)

An action is a task performed by a module after the trigger (for example, creating, updating, sending, or posting something in a connected app). ✓

Because modules interact with external services, you must connect/authorize external accounts (such as Google or Slack) for modules to work. ✓

Routers and filters (branching + conditions)

• A router lets you split a scenario into multiple branches (branching logic). ✓
• A filter applies conditions to control whether a route runs (conditional logic). ✓

Together, routers and filters provide branching and conditional logic within scenarios. ✓

Data mapping (passing fields between modules)

Data mapping (field mapping) is how you pass outputs from one module into the inputs of the next module. ✓

This is how values from a trigger or earlier action become usable fields later in the scenario. ✓

Run once (test mode)

Run once is Make.com’s test mode for executing a scenario with sample data and inspecting each module’s inputs and outputs. ✓

Templates

Templates are pre-built automations you can start from instead of building a scenario from scratch. ✓

Execution history / logs

Execution history (logs) lets you monitor scenario runs and debug issues by reviewing what happened during execution. ✓

Iterators and functions

• Iterators help handle repeated items by looping through lists. ✓
• Built-in functions support data transformation such as formatting dates, calculations, and string manipulation. ✓

Free tier operations

Make.com includes a free tier with a stated operations allocation (example mentioned: 1,000 operations/month). ✓

Make.com is a visual automation platform that connects apps and services into automated workflows called scenarios. ✓

A scenario is a workflow made of modules (steps). ✓ Each module represents an app and an action you want that app to perform. ✓

Steps

• Create an account ✓

  • To follow along, you can create a free Make.com account.

• Open the dashboard

  • From the dashboard, you’ll be able to start building scenarios (your automations) and access templates to start from pre-built workflows. ✓

What you’ll build from the dashboard

As you move beyond setup, most scenarios follow a trigger → actions → logic pattern. ✓

• Triggers start a scenario run. ✓
  • Triggers can be instant (webhook) or polling/scheduled, depending on when you want the scenario to run. ✓
• Actions are the modules that perform tasks in connected apps. ✓
• Logic is added with routers and filters for branching and conditional paths. ✓

Once you start adding modules, you’ll also need to connect/authorize your external accounts (Google, Slack, etc.) for modules to work. ✓

Make.com is a visual automation platform that connects apps and services into automated workflows called scenarios. ✓ Scenarios are workflows made of modules, where each module represents an individual app step or action inside the workflow. ✓

What you’re building in this step

A Make.com workflow typically follows a trigger → actions → logic pattern. ✓

• Triggers start a scenario run. ✓
• Actions (modules) perform tasks after the trigger fires. ✓
• Logic is added with routers and filters to create branching and conditions. ✓

Steps

• Create an account. ✓ To follow along, you can create a free Make.com account.
• Create a new Scenario. ✓
• Add a Trigger. ✓

Choosing your first trigger

Triggers define when a scenario runs. ✓

Common trigger types include:

• Instant triggers (webhooks): run immediately when an event happens. ✓
• Polling/scheduled triggers: check for new data on a schedule and run when conditions are met. ✓

After you add the trigger module, you’ll typically be prompted to connect/authorize the external account (for example, Google or Slack) so the module can access the app’s data. ✓

Optional: Start from a template

If you want a faster starting point, Make.com provides templates so you can begin from a pre-built automation and adjust the trigger and modules as needed. ✓

To use a module successfully, you must connect and authorize the external account that module will act on (for example, Google or Slack). ✓

What “connect” and “authorize” means in Make.com

In Make.com, scenarios are automated workflows built from modules. ✓ Each module is an individual step representing an app or action inside the scenario. ✓ When a module needs access to an external service, you must authorize that connection so the module can run. ✓

Where account connections fit in a scenario

Make.com workflows commonly follow a trigger → actions → logic structure:

• Trigger starts the run ✓
• Actions/modules perform tasks in connected apps ✓
• Logic is added with routers and filters for branching and conditions ✓

Steps: connect and authorize accounts

Use this sequence when building a scenario:

• Create an account ✓
• Create a new Scenario ✓
• Add a Trigger ✓
• Connect / authorize accounts ✓
• Add Actions / Modules ✓
• Map data between modules ✓
• Add Routers and Filters for logic ✓
• Test the scenario (Run once) ✓
• Turn it on / set schedule ✓
• Monitor executions and debug ✓

If you’re setting up your workspace for the first time, you can create a free Make.com account. ✓

Validate your authorization during testing

After connecting accounts, use Run once to test the scenario with sample data and inspect each module’s inputs and outputs. ✓ This helps confirm that authorized connections are working before you turn the scenario on or schedule it. ✓

Troubleshooting with execution history

If a connected module fails during a run, use the scenario’s execution history/logs to review what happened and debug the issue. ✓

Add actions/modules and map data between them

Make.com is a visual automation platform that connects apps and services into automated workflows called scenarios. ✓ Scenarios are workflows made of modules (steps). ✓ Modules are individual steps representing apps/actions within a scenario. ✓

To follow along, you can get started with Make.com.

Where actions/modules fit in a scenario

Most workflows follow a trigger → actions → logic pattern: triggers start runs, actions perform tasks, and logic is handled with routers/filters. ✓

• Trigger module: defines when the scenario runs (for example, instant webhook vs polling/scheduled). ✓
• Action modules: perform the work after the trigger (e.g., creating or updating something in a connected app). ✓
• Logic modules: routers and filters add branching and conditional behavior. ✓

Add actions/modules

After you add your trigger, you add one or more action modules to perform the next tasks in the workflow. ✓

• Make sure any external app used by a module is connected/authorized (Google, Slack, etc.) so the module can run. ✓

Map data between modules (data mapping)

Data mapping is how you pass outputs from one module into the inputs of the next module. ✓

• Map fields from the trigger or previous action module into the next action module’s input fields. ✓
• Use built-in functions for data transformation (for example formatting dates, calculations, and string manipulation) when the next module expects a different format. ✓

Test your mapping with “Run once”

Use the Run once test mode to execute the scenario with sample data and inspect each module’s inputs/outputs. ✓

• Run once to generate a real sample bundle of data from the trigger. ✓
• Open each module’s results to confirm the mapped values arrived as expected. ✓

Add logic when needed

Routers and filters provide branching and conditional logic within scenarios. ✓ Add them after your trigger or between actions when you need different paths based on the mapped data. ✓

Monitor and debug after adding modules

Execution history/logs are available to monitor runs and debug issues. ✓ Use them to verify that your modules are receiving the mapped inputs you expect and producing the outputs required for the next step. ✓

Routers and Filters let you add branching and conditional logic inside a Make.com scenario. ✓ This is the “logic” part of the common trigger → actions → logic pattern in automated workflows. ✓

Where Routers and Filters fit in a scenario

• A scenario in Make.com is a workflow made of modules (steps). ✓
• Modules are individual steps representing apps/actions within a scenario. ✓
• Workflows typically follow a trigger → actions → logic pattern: triggers start runs, actions perform tasks, and logic is handled with routers/filters. ✓

What Routers do

Routers provide branching in scenarios, allowing the workflow to split into multiple paths. ✓

What Filters do

Filters provide conditions for those paths, so only the branch that meets the condition continues. ✓

Step in the build process

When you’re building a scenario, you’ll add Routers and Filters after you’ve added your modules/actions and mapped the data you want to evaluate.

• Add Routers and Filters for logic. ✓

Test your conditions

After adding branching and conditions, validate the logic with Make’s test mode.

• Test the scenario using Run once to execute with sample data and inspect each module’s inputs/outputs. ✓

To follow along, you can get started with Make.com.

Use **Run once** test mode to inspect inputs/outputs

Make.com is a visual automation platform that connects apps and services into automated workflows called scenarios. ✓ Scenarios are workflows made of modules (steps). ✓

What **Run once** is for

Use the Run once test mode to execute a scenario with sample data and inspect each module’s inputs and outputs. ✓ This helps you confirm that:

• Your trigger is producing the data you expect. ✓
• Data mapping between modules is passing the right values forward. ✓
• Any branching logic (routers/filters) is behaving as intended. ✓

Where this fits in the scenario workflow

In a typical Make.com scenario structure—trigger → actions → logic—the trigger starts a run, actions perform tasks, and logic is handled via routers/filters. ✓ Run once is used during testing before you turn a scenario on or schedule it. ✓

How to use **Run once** to debug mapping and logic

• Make sure required external accounts are connected/authorized for modules to work. ✓
• Click Run once to execute the scenario with sample data. ✓
• Open each module’s run details to inspect its inputs and outputs. ✓
• Verify the mapped fields between modules match what the next module expects. ✓
• If your scenario uses routers/filters, confirm the correct branch ran based on the condition. ✓

After the test

Once inputs/outputs look correct across modules, you can proceed to turn the scenario on or set a schedule, and then use execution history/logs to monitor runs and debug issues. ✓

To follow along in your own workspace, you can get started with Make.com.

Choose how your scenario should run (schedule vs webhook)

Make.com is a visual automation platform that connects apps and services into automated workflows called scenarios. ✓

A scenario follows a trigger → actions → logic pattern: triggers start runs, actions perform tasks, and logic is handled with routers/filters. ✓

Schedule vs instant webhook triggers

Triggers define when a scenario runs. ✓

• Instant triggers (webhooks) run as soon as an event is received. ✓
• Polling / scheduled triggers check for new data on a schedule you set. ✓

Your trigger type determines whether you need to set a schedule, or whether the scenario should be left to run on incoming webhook events.

Turn the scenario ON

After you’ve built modules (steps) and tested the scenario using Run once to inspect each module’s inputs/outputs, you can enable it for ongoing runs. ✓

In your scenario’s final setup:

• Turn it on / set schedule so it runs automatically based on your chosen trigger behavior. ✓

Monitor after activation

Once your scenario is ON, use execution history/logs to monitor runs and debug issues. ✓

• Review each execution to confirm the trigger fired as expected and downstream modules received the right mapped data.

To follow along directly in the product, you can get started with Make.com.

Execution history and logs help you monitor scenario runs and debug issues in Make.com. ✓

Make.com is a visual automation platform that connects apps and services into automated workflows called scenarios. ✓ Scenarios are workflows made of modules, and each module is an individual step representing an app or action inside the scenario. ✓

What execution history shows

Make.com provides execution history/logs so you can:

• Monitor when a scenario ran and what happened during each run ✓
• Debug issues by reviewing how data moved through modules in that run ✓

Because scenarios typically follow a trigger → actions → logic pattern, execution history is most useful when you review a run in that same order. ✓

Debugging with “Run once”

The most direct way to debug is to test with Run once.

• Use Run once test mode to execute the scenario with sample data ✓
• Inspect each module’s inputs and outputs to confirm mappings and results ✓

This is especially helpful when you:

• Map outputs from one module into the next module’s inputs (data mapping) ✓
• Add branching logic using Routers and Filters and need to confirm which branch executed ✓

What to check when a run doesn’t behave as expected

When reviewing execution history/logs, common checks include:

• Trigger configuration: confirm whether your trigger is instant (webhook) or polling/scheduled, and whether it fired as expected ✓
• Connections: confirm external accounts are connected/authorized for the modules you used ✓
• Module-by-module data: confirm the expected data appears in each module’s input/output during the run (especially around data mapping) ✓
• Logic outcomes: confirm Router/Filter conditions match the data that arrived in that run ✓

Where this fits in the build → test → deploy loop

Execution history and logs are used after you:

• Test the scenario (Run once) ✓
• Turn it on / set a schedule (for scheduled scenarios) ✓
• Monitor executions and debug ✓

To follow along in your own workspace, you can create a free Make.com account.

Make.com is a visual automation platform that connects apps and services into automated workflows called scenarios. ✓ Make.com was formerly called Integromat. ✓

Scenarios are workflows made of modules (steps). ✓ Modules are individual steps that represent apps and actions within a scenario. ✓

Common example automations

Below are common scenario patterns you can build yourself or find as templates.

• Form submission → Google Sheets → send email / notify Slack ✓
• Email/Gmail → post message to Slack ✓

These follow the standard workflow shape: trigger → actions → logic. ✓

• Triggers start scenario runs. ✓
  • Triggers can be instant (webhook) or polling/scheduled. ✓
• Actions perform tasks (modules that write data, send messages, etc.). ✓
• Logic is handled with routers/filters for branching and conditions. ✓

Using templates to start faster

Make.com provides templates so you can start from pre-built automations instead of assembling every module from scratch. ✓

When you use a template, you still typically need to:

• Connect/authorize external accounts (for example Google or Slack) so modules can access those services. ✓
• Map data between modules so outputs from one module become inputs to the next (data mapping). ✓

Testing a template-based scenario

Use Run once to execute a scenario with sample data and inspect each module’s inputs and outputs. ✓ This helps confirm the template’s mapping and logic are working as expected before you rely on it.

If the template includes conditional paths:

• Use Routers and Filters to implement branching and conditional logic within the scenario. ✓

Monitoring and debugging after you run it

After a scenario runs, use execution history/logs to monitor runs and debug issues. ✓

Notes on operations and common data-handling features

• Make.com scenarios can include Iterators to loop through lists of items. ✓
• Make.com includes built-in functions for data transformation (for example formatting dates, calculations, and string manipulation). ✓
• The free tier has a stated operations allocation (example mentioned: 1,000 operations/month). ✓

To follow along while you explore templates and example scenarios, you can get started with Make.com.

Pricing and operations limits

Make.com is a visual automation platform that connects apps and services into automated workflows called scenarios. ✓

Scenarios are workflows made of modules (steps). ✓ Each module represents an app/action inside the scenario. ✓

Operations allocation (what it impacts)

Make.com’s free tier has a stated operations allocation (example: 1,000 operations/month mentioned). ✓

In practical terms, this matters when your scenario runs frequently (for example, instant webhook triggers) or performs many modules per run, since each run executes a sequence of modules in a trigger → actions → logic pattern. ✓

If you’re planning for higher-volume usage, monitor scenario runs and troubleshoot using execution history/logs. ✓

To follow along in your own workspace, you can get started with Make.com.

Iterators (handling lists)

Iterators are a feature used for looping through lists of items so you can process repeated items. ✓

This is useful when a prior module outputs multiple items and you need to run one or more downstream modules for each item.

Built-in functions (data transformation)

Make.com includes built-in functions for data transformation, including:

• Formatting dates ✓
• Calculations ✓
• String manipulation ✓

These functions support data mapping, where you pass outputs from one module into inputs of the next. ✓

Scaling guidance (what to check as scenarios grow)

As you expand scenarios (more modules, more branching), focus on:

• Logic structure: Routers and Filters provide branching and conditional logic within scenarios. ✓
• Testing: Use Run once to execute a scenario with sample data and inspect each module’s inputs/outputs. ✓
• Monitoring: Use execution history/logs to monitor runs and debug issues. ✓

If you need to build or adjust scenarios at scale, try Make.com free to test changes with Run once before turning scenarios on.