Make: A Reference Tool for Automation

In the world of no-code tools, Make holds a special place. It’s the tool you open when you want to automate something quickly, without sinking a full week into it, and with the confidence that it will hold up, even as the volume grows.
At Fenxi, it has become a reflex: the moment we see a client spending more than 10 minutes a day copying and pasting something somewhere, we know there’s value to unlock. And Make is our go-to tool for just that (of course, there are others too, like Zapier or n8n. A full benchmark of their strengths and weaknesses will be the subject of another article).

But if you’re here, maybe you just want to understand what Make actually does, how it works, and how much it can simplify your life. No need for a PhD in automation, I promise, we’ll keep things simple.

Before we start, I recommend you go ahead and create a Make account. It’s free, and the free plan is more than enough to get started.

So, what exactly is Make?

Make (formerly Integromat) is a visual automation platform. In short, it lets you connect different services (emails, files, databases, CRMs, internal tools…), and create scenarios that replace repetitive tasks.

People often talk about workflows, pipelines, no-code automation, but the idea is actually very simple:

Make acts like a robot that does the work for you.

You don’t need to know how to code. Everything is visual: you drag modules, define your logic, and Make executes it all in the background.

The core concepts

If you understand these four concepts, you understand Make.

1. The Scenario

A scenario is where you define your entire business logic.
One scenario = one automation.
A scenario is: a starting point → a chain of actions → a result.

Some examples:

• When an email arrives in a Gmail inbox, add a row in a Google Sheet with the subject, sender, and date.
• Automatically save Google Forms responses into Notion.

To create a scenario, just click the “Create a new scenario” button. A blank scenario looks like this:

2. The Module

Each step of a scenario is a module.
A module can be:

• a trigger
• an action
• a filter
• a built-in tool (math functions, text formatting, etc.)

Where Zapier uses “steps,” Make uses “modules,” but the logic is the same.

3. The Trigger

This is what launches your scenario. Make needs to know when your automation should run. It waits for an event.

Examples:

• “Every time an email arrives”
• “Every 10 minutes”
• “When a new row is added in a Google Sheet”
• “When a file is added to a folder”

We’ll use one of these in our example.

4. Data

In Make, you manipulate data flows.
Each module receives data… and outputs new data.

If you understand:

• what you’re getting,
• what you need to output,
• what you need to transform in between,

you can build anything 😎

In the screenshot below, you can see what the data looks like after being captured by an email watcher. In Make, each “batch” of data transmitted by a module is called a Bundle.
So if your watcher detects 4 emails in the last 10 minutes, you’ll get a list of 4 bundles.

A simple example : automatically logging incoming emails in a Google Sheet

Goal:
Every time a Gmail message arrives, extract the subject, sender, and date, and store them in a Google Sheet.

No need to create new accounts: Gmail + Google Sheet, everyone has those.

This example is useful because:

✔️ It’s a real-world use case
✔️ It’s easy to reproduce
✔️ It shows Make’s logic without overwhelming complexity

Step 1: Create a new scenario

In Make, click “Create a new scenario.”

You’ll land on an empty canvas.

Add your first module:

Gmail → Watch Emails

Useful parameters:

• Create a connection: If this is your first time using Make, you’ll need to create a Gmail connection. This authorizes Make to access your inbox. I recommend naming the connection after the email address, e.g., john@company.com.
• Label: optional but useful
• Folder: Inbox
• Criteria: “All emails”
• Mark as read: No (unless you want Make to treat them as handled)

This module becomes our trigger, and it’s a polling trigger, meaning Make regularly checks Gmail for new messages.
With polling triggers, you can define how often Make checks for new data.
The more frequent the checks, the more Make credits you spend.

Step 2: Add a Google Sheets module

Second module:

Google Sheets → Add a Row

You’ll need a Sheet with a simple structure, for example:

Nothing more.

Create a Google Sheets connection (same recommendation: name it after the email account).

Now comes the interesting part.
First, select the spreadsheet.
Then select the sheet tab.
Finally, map each column:

To recap, in the Google Sheets module you:

• choose the file
• choose the sheet
• map the fields

Make will suggest values from the previous module:

• Date = Date
• Sender = From
• Subject = Subject

Save the module and you’re done.

Step 3: Activate the scenario

This is the step most beginners forget.
When everything is set → switch the scenario on.

Send yourself a test email.
A couple seconds later, if everything is correct:

✅ A new row appears in your Google Sheet
✅ Your scenario runs automatically
✅ And you just replaced a daily manual task with a 24/7 automation

What this example teaches you

Even though it looks simple, this example covers the three pillars of Make:

1. Logical structuring

Event → action.
You start thinking in “circuits.”

2. Data mapping

You see that each module outputs raw data you can reuse.

3. Standardization

You define your output format.
This forces you to structure your process, which is exactly what you’ll need when you move to more advanced automations:

• multi-branch logic
• conditional steps
• webhooks
• …

And if you want to extend this scenario later, you could add:

• a filter (only keep certain emails)
• a text-cleaning module
• an automatic Gmail label
• a Slack or WhatsApp notification
• a backup in Notion

The same scenario can grow naturally as your needs evolve.

Why Make remains a must-have tool

Make is a standard not just because it’s pretty or trendy.
It’s because it checks three critical boxes for businesses:

1. It reduces time spent on low-value tasks

Someone spending 1h/day copying and pasting = 20 hours a month.
Make gives that time back instantly.

2. It makes execution reliable

An automation:

• doesn’t forget steps
• doesn’t run too early or too late
• does exactly what it’s supposed to do, nothing more, nothing less

3. It lets you prototype fast (very fast)

When a client explains a process, we can often build a functional version in 30 to 60 minutes.
This is often the difference between an idea and a solution.

Conclusion

Make is a way to take back control of your time, improve operational reliability, and stop repeating tasks a machine can do for you. If you’re just getting started, begin with small scenarios like this one.

Five minutes to understand, fifteen minutes to configure, and you’ve saved yourself hours every month.