Your First Make Scenario: How the Visual Canvas Works

Make (formerly known as Integromat) looks different from Zapier the moment you open it. Instead of a vertical list of steps, you get a canvas with circles connected by lines. It is more visual, and once you understand how it works, it is much more powerful.

This tutorial gets you from a blank canvas to a working scenario in one session.

The vocabulary Make uses

Make has its own terms for things. These are the ones you need before you start:

Scenario - this is what Make calls an automation. A scenario is a set of connected modules that runs when triggered.

Module - a module is a single step: connect to an app, get some data, do something with it. Every circle on the canvas is a module.

Connection - before a module can access an app, you connect your account. You do this once per app, and then all your scenarios can use it.

Bundle - when data flows through Make, it comes in bundles. One bundle is one item: one email, one form submission, one row in a spreadsheet. If your trigger returns five emails, Make processes five bundles.

Mapping - when you set up a module, you fill in fields using data from earlier modules. Choosing which earlier field to use is called mapping.

Router - a special module that splits a bundle into multiple branches based on conditions you define. This is where Make's power over Zapier really shows.

What you will build in this tutorial

A simple but complete scenario: when someone submits a contact form, their details get added to a Google Sheet and a notification goes to Slack.

Trigger: Google Forms (or Typeform, or any form tool you use) Action 1: Add a row to Google Sheets Action 2: Send a message to Slack

If you do not have a form set up, you can use Make's "webhook" trigger instead, which gives you a URL you can post test data to.

Step 1: Create a new scenario

1. Sign in to Make at make.com
2. Click "Create a new scenario"
3. You will see a blank canvas with a large circle in the middle labeled "Choose a starting point"

That large circle is your first module, the trigger.

Step 2: Add the trigger module

1. Click the large circle
2. Search for "Google Forms" (or your form tool)
3. Select "Watch Responses" as the trigger type
4. Connect your Google account when prompted
5. Select the specific form you want to watch
6. Set a limit (how many responses to process per run)

Make will now watch for new responses to that form and fire the scenario when one arrives.

Alternative if you want to test immediately: Search for "Webhooks" instead and choose "Custom Webhook". Make gives you a URL. You can send test data to that URL using a tool like Postman, or just use a simple HTML form.

Step 3: Add the Google Sheets module

1. Click the small circle on the right edge of your trigger module
2. Search for "Google Sheets"
3. Choose "Add a Row"
4. Connect your Google account
5. Select the spreadsheet and sheet where you want the data to go
6. Map the fields: click into each column field and select the corresponding form field from the earlier module

This is mapping in action. You are telling Make: put the value from the "Name" field in the form into the "Name" column in the sheet.

Step 4: Add the Slack module

1. Click the circle on the right edge of the Google Sheets module
2. Search for "Slack"
3. Choose "Create a Message"
4. Connect your Slack workspace
5. Select the channel to post in
6. Write the message text, using mapped fields to include the person's name and email:

New contact form submission from {{1.name}} ({{1.email}})
Message: {{1.message}}

The {{1.name}} syntax is how Make inserts data from earlier modules into text. The number refers to the module number on your canvas.

Step 5: Run it once to test

1. Click "Run once" in the bottom left of the screen
2. Submit a test response to your form (or trigger your webhook)
3. Watch the canvas light up as each module processes
4. Click on any module after the run to see exactly what data flowed through it

The bubble above each module shows how many bundles were processed. If it processed one bundle successfully, you will see a green "1".

If a module shows an error (red), click on it to see the error message. The most common issues are:

• A connection expired and needs to be re-authorized
• A required field was left empty during setup
• The mapped data does not match the expected format

Step 6: Turn it on

Once the test run looks right, click the toggle in the bottom left from "OFF" to "ON". Your scenario will now run automatically whenever a new form submission comes in.

Scheduling vs. instant triggers

Some triggers are instant (a webhook fires the moment something happens) and some run on a schedule (Make checks for new data every 15 minutes, or every hour, depending on your plan).

For Google Forms, Make polls for new responses on a schedule. If instant is important for your use case, use a webhook trigger instead and send form data directly to that webhook.

What to explore next

Once this scenario is working, here are three things to look at that will unlock Make's real power:

Filters - add a filter between two modules to only continue if certain conditions are met. A filter is a gate: the bundle only passes through if the condition is true.

Routers - split the data flow into multiple branches based on different conditions. An email classified as "billing" goes one way, "technical" goes another.

Error handling - Make lets you define what happens when a module fails, rather than just stopping. You can route errors to a separate log or send yourself an alert.

The next two tutorials in this course go into both of these in depth.