Make.com Tutorial for Beginners: Build Your First Scenario in 30 Minutes

# Make.com Tutorial for Beginners: Build Your First Scenario in 30 Minutes

Automation doesn't have to mean writing code or paying a fee every time a task runs. Make.com — formerly known as Integromat — gives you a visual canvas where you drag modules into place, connect them with arrows, and watch your data flow in real time. It's one of the most powerful automation tools available, and the free plan is genuinely useful.

By the end of this tutorial, you'll have a live Make.com scenario running: every new Gmail you receive gets automatically logged to a Google Sheet. You'll understand exactly how Make.com works, what all the moving parts are called, and have five more scenario ideas ready to build the moment you're done.

This is the third post in a tutorial trilogy. If you haven't already, it's worth reading the n8n tutorial and the Zapier tutorial — they cover the same Gmail-to-Sheets pattern on different platforms, so you can directly compare the experience. You can also read a full breakdown in n8n vs Zapier vs Make.com.

Let's build it.

What Is Make.com?

Make.com (formerly Integromat) is a visual automation platform that lets you connect apps and automate workflows without writing a single line of code. Where Zapier uses "Zaps" and n8n uses "workflows," Make.com uses scenarios — and instead of nodes or steps, everything is built from modules.

Here's what makes Make.com worth learning:

- Visual drag-and-drop canvas — scenarios are built on a visual stage. You see every module and every connection laid out in front of you

- Operations-based pricing — Make.com charges per *operation* (one module execution), not per task or per Zap. The distinction matters: a scenario with 3 modules running 100 times uses 300 operations, not 100 tasks. Often significantly cheaper than Zapier for complex workflows

- Free plan: 1,000 operations/month — enough to run meaningful automations without paying anything

- Iterators and aggregators — Make.com handles looping over arrays of items natively, which is a superpower for data processing that Zapier struggles with

- Routers — built-in branching logic lets one scenario follow different paths depending on conditions

- Advanced data manipulation — built-in functions for text, numbers, dates, and arrays without needing a separate code step

Make.com vs. Zapier: Zapier is simpler to start with — the step-by-step editor is more forgiving for beginners. Make.com has a steeper learning curve but rewards you with more flexibility and lower cost at scale. If you're doing complex multi-branch logic or processing large volumes, Make.com wins.

Make.com vs. n8n: n8n is self-hostable and free with no operation limits if you run it on your own server. Make.com is fully hosted — nothing to install or maintain. If you don't want to manage infrastructure, Make.com is the better choice. For a side-by-side breakdown, see n8n vs Zapier vs Make.com.

Getting Started: Create Your Account

Go to make.com and click Sign up free. No credit card required. Enter your email and a password, then verify your email address.

Once you're in, you'll land on the Make.com dashboard. Here's what you're looking at:

Left sidebar:

- Scenarios — your list of automations, both active and inactive

- Templates — pre-built scenario templates from Make.com and the community

- Connections — the app accounts you've authenticated (OAuth tokens and API keys)

- Team — user management if you're working with others

Main area:

- A green Create a new scenario button in the top right corner — this is where everything starts

- Your existing scenarios listed below, with status indicators showing whether each is active or inactive

The Connections tab is worth a quick look before you build: this is where Make.com stores your authenticated app accounts. Every time you connect a new app in a scenario, Make.com saves the credential here and reuses it across future scenarios. You only authenticate each app once.

Make.com Building Blocks

Before you build your first scenario, get familiar with the key concepts. These come up constantly, and understanding them upfront saves a lot of confusion.

Modules

A module is a single step in your scenario. Every module either triggers the scenario or performs an action. There are two types:

- Trigger modules — the module that starts the scenario. In Make.com, trigger modules have a small clock or lightning bolt icon. They watch for something to happen: a new email, a new form submission, a new row in a spreadsheet

- Action modules — do something in response: create a record, send a message, update a spreadsheet row, make an HTTP request

One scenario can have one trigger and as many action modules as you need, chained together or branching through a Router.

Connections

Connections are the authenticated accounts that link Make.com to your apps. When you add a Gmail module to a scenario, Make.com asks you to create a connection — you click through an OAuth popup, authorize access, and Make.com stores the token in your Connections tab. The next time you add a Gmail module anywhere, you just select that existing connection from the dropdown.

Connections are stored at the account level, not per-scenario. One authenticated Gmail account can be used across hundreds of scenarios.

Filters

Filters are conditional gates between modules. They only let data pass through if it meets a specified condition. You add a filter by clicking the small wrench icon on the arrow connecting two modules.

Example: add a filter between Gmail and Google Sheets that only passes emails where the subject contains "Invoice" — all other emails are ignored and no row is written. Filters are how you keep scenarios from creating noise.

Routers

A Router is a special module that splits one data stream into multiple branches. Instead of one trigger → one chain of actions, a Router lets you run different actions depending on conditions.

Example: a new Typeform submission routes to Branch A (create a Notion task) if the respondent selected "Yes" to a question, and to Branch B (send a "not interested" email) if they selected "No." Each branch has its own filter and its own chain of modules.

Bundles vs. Items

In Make.com, a bundle is one unit of data flowing through a scenario — one email, one form submission, one spreadsheet row. When a trigger fires, it may return multiple bundles (e.g., 5 new emails since the last run). Each bundle passes through the scenario independently. Most modules process one bundle at a time.

Items come into play with the Iterator module — an Iterator breaks an array inside a bundle into individual items so each one can be processed separately.

Operations Counter

Make.com's free plan gives you 1,000 operations/month. Every time a module processes a bundle, that's one operation. A scenario with 4 modules processing 10 bundles per run = 40 operations per run. The trigger module's first execution is counted separately.

What doesn't count: scheduling checks where no new data was found (the scenario wakes up, finds nothing new, and goes back to sleep — no operation consumed).

Your First Scenario: Gmail to Google Sheets

Here's what you're building: every time a new email arrives in Gmail, Make.com captures the subject, sender, and date, then adds a row to a Google Sheet automatically.

Before you start, open Google Sheets and create a new spreadsheet. Add three column headers in row 1: Subject, Sender, Date. Keep this tab open — you'll come back to it.

Step 1: Click "Create a new scenario"

From the dashboard, click the green Create a new scenario button in the top right. You'll land on the scenario canvas — a dark grid stage with a single empty circle in the center. This is where you'll build.

Step 2: Add the Gmail Trigger

Click the large "+" circle in the center of the canvas. A search panel opens on the right side of the screen — this is the module picker.

1. Type Gmail in the search box and select it

2. From the list of Gmail modules that appears, select Watch emails

3. A connection dialog appears — click Create a connection, then follow the OAuth popup to sign in to Google and authorize Make.com's access to Gmail. Once authorized, the connection is saved and named after your Google account

Step 3: Configure the Gmail Trigger

The Watch emails configuration panel opens:

- Connection — your Gmail connection is already selected

- Folder — set to All Mail to catch every incoming email, or select a specific label like "Inbox" to narrow it

- Criteria — leave as "All email" unless you want to filter by read/unread status

- Max Results — set to 5. This controls how many emails Make.com fetches per run. Setting it low prevents a flood of rows on the first run

Click OK to close the panel.

Step 4: Add the Google Sheets Action

Click the "+" button that appears to the right of the Gmail module on the canvas. The module picker opens again.

1. Type Google Sheets in the search box and select it

2. From the module list, select Add a Row

3. Click Create a connection → OAuth popup → sign in to the same Google account (or a different one) and authorize Sheets access

Step 5: Configure the Google Sheets Action

The Add a Row configuration panel opens:

- Spreadsheet — click the dropdown and select the spreadsheet you created before starting this tutorial. If it doesn't appear, click the folder icon to browse by Drive

- Sheet Name — select Sheet1 (or whatever your tab is named)

Once you select the sheet, Make.com reads your column headers and displays a field for each one:

- Column A (Subject) — click the field, then click the purple subject field from the Gmail data panel that appears on the left. You'll see `{{1.subject}}` appear in the field — this is Make.com's expression syntax referencing the subject field from module 1 (Gmail)

- Column B (Sender) — map to `{{1.from[].email}}` — click the sender field from the Gmail data panel

- Column C (Date) — map to `{{1.date}}` — click the date field

The data panel on the left shows all the fields available from your Gmail trigger. Click any field to insert its expression into the active column mapping.

Click OK to close the panel.

Step 6: Run Once and Watch the Data Flow

Look at the bottom left of the scenario canvas. You'll see a blue Run once button. Click it.

Make.com executes the scenario once manually. Here's where one of Make.com's best features kicks in: animated data-flow bubbles. You'll see small numbered circles travel along the arrows between modules in real time, showing exactly how many bundles are flowing and where they are in the sequence. Click any module after the run to see the exact input and output data for each bundle that passed through it.

Go check your Google Sheet. You should see rows populated with email subjects, sender addresses, and dates from your Gmail inbox.

If rows appeared — your scenario works.

Step 7: Review the Bundle Output

Click on the Gmail module after the test run. A panel opens showing the Output for the last execution — each bundle is listed with all its fields: subject, from, date, snippet, body, and more.

Click on the Google Sheets module. You'll see the Input — the exact data that was written to each row. This is your debugging view. If something mapped incorrectly, you can see exactly what value arrived and which column it landed in.

Step 8: Set the Schedule

In the top left of the scenario canvas, there's a clock icon next to the scenario name. Click it. This opens the scheduling panel.

- Run scenario → select At regular intervals

- Interval → set to Every 15 minutes

This tells Make.com to wake up every 15 minutes, check Gmail for emails that arrived since the last run, and process any new ones.

Step 9: Save and Activate

Click Save (the floppy disk icon in the bottom toolbar) to save your scenario.

Then click the toggle switch in the bottom left of the canvas — it's currently set to OFF. Flip it to ON.

Your scenario is now live. Every 15 minutes, Make.com will check for new Gmail messages and automatically log them to your spreadsheet. No action required on your part.

5 More Scenario Ideas to Build Next

Now that you've done it once, the pattern repeats. Here are five scenarios worth building next — each one addresses a real pain point and follows the same trigger → module → action structure.

1. Typeform Submission → Notion Database Entry + Slack Alert

Trigger: Typeform — Watch Responses

Actions: Notion — Create a Database Item → Slack — Create a Message

Every new form submission creates a record in your Notion database with all fields mapped, then sends a Slack notification to a designated channel. Useful for lead intake, event registration, or client onboarding — the form submits, your CRM updates, and your team knows instantly.

2. New Stripe Payment → Google Sheets Row + Gmail Thank You

Trigger: Stripe — Watch Events (payment_intent.succeeded)

Actions: Google Sheets — Add a Row → Gmail — Send an Email

Every successful payment adds a row to your revenue tracker (amount, customer email, product, timestamp) and sends the customer a personalized thank-you email. Revenue log and customer follow-up, both automated off a single trigger.

3. New RSS Feed Item → Google Doc Summary Draft

Trigger: RSS — Watch RSS Feed Items

Action: Google Docs — Create a Document

Every time a competitor blog, industry news site, or YouTube channel publishes new content, Make.com picks it up from the RSS feed and creates a Google Doc with the title, link, and snippet. Useful for content research, competitive monitoring, or building a reading queue without manually checking multiple sites.

4. New Calendly Booking → Google Calendar Event + Personalized Gmail Confirmation

Trigger: Calendly — Watch Events

Actions: Google Calendar — Create an Event → Gmail — Send an Email

Every new Calendly booking creates a corresponding Google Calendar event (with the invitee's details and meeting link pre-filled) and sends a personalized confirmation email to the client. Eliminates manual calendar entry and the copy-paste confirmation you send after every booking.

5. New Airtable Row → Slack Channel Message

Trigger: Airtable — Watch Records

Action: Slack — Create a Message

Every time a new record is added to your Airtable base — a new client, a new project, a new support ticket — Make.com automatically posts a formatted message to a Slack channel with the key fields. Clean project intake, no manual copy-paste, team visibility built in.

Skip the Build — Get 10 Done-for-You Make.com Scenarios

If you want to skip the build-it-yourself phase, Stackd Store's Make.com Workflow Templates give you 10 production-ready scenarios you can import and activate in minutes.

Each template includes the scenario `.json` file — import it directly into Make.com with one click — plus setup documentation covering how to configure connections and customize the logic for your use case.

**Get the Make.com Workflow Templates — $27 →**

Or browse all automation templates → to see the full library across Make.com, Zapier, and n8n.

Keep Building

Make.com's visual canvas makes automation more approachable than any other tool at this level of power. When you can see your data flowing between modules in real time — watching those animated bubbles move along the arrows — automation stops being abstract and starts being obvious.

The hardest scenario is always the first one. The pattern clicks into place the moment you see your first row appear in Google Sheets because of something you built. From there, every new scenario is a variation: different trigger, different modules, same logic. The skills transfer directly.

Start today while the steps are still fresh. Pick one of the five scenario ideas above, build it, and turn it on before you close this tab. The automation habits that compound the most are the ones you start now.