Make.com Tutorial: From Your First Workflow to Automation Pro

Make.com (formerly Integromat) is one of the most powerful no-code automation tools on the market. This tutorial will take you from zero to a working workflow with concrete examples and best practices.

What is Make.com?

Make.com is a visual automation platform. You connect apps, define logic, and let data flow automatically.

What Make can do:

• 1,500+ app integrations
• Complex logic (If/Else, Loops, Filters)
• Data transformation (JSON, XML, Text)
• HTTP requests for any API
• Scheduling (time-based triggers)

Part 1: The Basics

Creating an Account

Go to make.com

Click "Get started free"

Verify your email

You now have: 1,000 operations/month for free

Understanding the Interface

+-------------------------------------------------------------+
|  [Scenarios] [Templates] [Data] [Team]          [Run once]  |
+-------------------------------------------------------------+
|                                                             |
|                    +---------+                              |
|                    | Trigger |                              |
|                    |  (App)  |                              |
+----+----+
+----v----+
Action
(App)
+----+----+
+----v----+
Action
(App)
+---------+
[+] Add module
+-------------------------------------------------------------+

Key Terms:

• Scenario: A complete workflow
• Module: A building block (Trigger or Action)
• Connection: Link to an app (OAuth)
• Operation: Each module execution counts
• Bundle: A data record passing through

Your First Workflow: Google Sheets to Slack

Goal: When a new row appears in Google Sheets, send a message to Slack. Step 1: New Scenario

Click "Create a new scenario"

An empty canvas opens

Step 2: Add Trigger

Click the large "+"

Search for "Google Sheets"

Select "Watch New Rows"

Connect your Google account

Select Spreadsheet and Worksheet

Click "OK"

Step 3: Add Action

Click the small "+" to the right of the Google Sheets module

Search for "Slack"

Select "Create a Message"

Connect your Slack workspace

Select Channel

Write the message:

New row: {{1.Column A}} - {{1.Column B}}

Click "OK"

Step 4: Test

Click "Run once"

Add a row in Google Sheets

Check Slack

Step 5: Activate

Toggle "Scheduling" to ON

Choose interval (e.g., every 15 minutes)

Click "Save"

Done! Your first workflow is running.

Part 2: Intermediate Concepts

Filters: Only Let Certain Data Through

Example: Only process rows where column "Status" = "New"

Click on the connection line between modules

Click "Add a filter"

Condition:

- Field: {{1.Status}}

- Operator: "Equal to"

- Value: "New"

[Google Sheets] --[Filter: Status=New]--> [Slack]

Router: Multiple Paths

Example: Different actions based on status

After the trigger: "Add module" -> "Flow Control" -> "Router"

Multiple paths branch from the Router

Each path has a filter

+--[Filter: Status=New]--> [Slack: #new]
[Google Sheets] --> |
     (Router)       +--[Filter: Status=Done]--> [Slack: #done]
                    |
                    +--[Filter: Status=Error]--> [Email: Alert]

Iterator: Loop Through Arrays

Example: An API returns 10 results. Process each one individually.

"Add module" -> "Flow Control" -> "Iterator"

Select array: {{1.results}}

Next module receives individual items

[HTTP: Get Items] --> [Iterator] --> [For each: Create Record]
     (Array)           (Split)         (Single Item)

Aggregator: Combine Multiple into One

Example: Summarize 10 individual results into one email

"Add module" -> "Flow Control" -> "Array Aggregator"

Source: The module that produces multiple bundles

After that: A module that processes the array

[Iterator] --> [Process each] --> [Aggregator] --> [Email: Summary]

Error Handling

What happens when errors occur?

Click on a module

Click "Add error handler"

Options:

- Resume: Continue, ignore error

- Commit: Save changes, then stop

- Rollback: Undo changes, stop

- Break: Move to Incomplete queue, retry later

Best Practice: Always add error handlers to critical workflows

[Module] --+---> [Next Module]
           |
           +---> [Error Handler] ---> [Slack: Error Alert]

Part 3: Advanced Techniques

HTTP Module: Any API

Example: Call an API without native integration

"Add module" -> "HTTP" -> "Make a request"

URL: https://api.example.com/data

Method: GET

Headers:

Authorization: Bearer {{your_api_key}}

   Content-Type: application/json

Parse response: Yes (JSON)

POST with Body:

Method: POST
Body type: Raw
Content type: JSON
Request content:
{
  "name": "{{1.name}}",
  "email": "{{1.email}}"
}

Webhooks: Instant Triggers

Instead of polling (checking every X minutes) -> Instant (immediately when event occurs)

Create a Custom Webhook:

"Add module" -> "Webhooks" -> "Custom webhook"

Click "Add" -> Give it a name

URL is generated: https://hook.eu1.make.com/xxx

Enter this URL in your source app

Example: Typeform -> Webhook -> Make

Typeform sends data to webhook URL
    |
Make receives instantly
    |
Workflow starts immediately

JSON & Data Structure

Parse JSON:

"Tools" -> "Parse JSON"

Input: The JSON string

Output: Structured data for mapping

Create JSON:

"Tools" -> "Create JSON"

Define data structure or:

"JSON" -> "Create JSON" with manual string

Example: API expects complex JSON

{
  "contact": {
    "firstName": "{{1.firstName}}",
    "lastName": "{{1.lastName}}",
    "email": "{{1.email}}"
  },
  "metadata": {
    "source": "website",
    "timestamp": "{{now}}"
  }
}

Text & Data Transformation

Useful Functions:

# Text
{{lower(1.Name)}}           -> lowercase
{{upper(1.Name)}}           -> UPPERCASE
{{substring(1.Text; 0; 10)}} -> First 10 characters
{{replace(1.Text; "old"; "new")}}

# Date
{{formatDate(now; "YYYY-MM-DD")}}
{{addDays(now; 7)}}
{{parseDate(1.date; "DD.MM.YYYY")}}

# Numbers
{{round(1.price; 2)}}       -> 2 decimal places
{{sum(1.items[].price)}}    -> Sum array

# Logic
{{if(1.status = "active"; "Yes"; "No")}}
{{ifempty(1.name; "Unknown")}}

Data Stores: Internal Database

Make has a built-in database for persistent data.

Example: Avoid Duplicates

"Data store" -> "Add/Replace a record"

Key: Email address

Before the action: "Search records" - if found, skip

[Trigger] --> [Data Store: Search by Email]
                    |
              [Filter: not found]
                    |
              [Create Contact]
                    |
              [Data Store: Add record]

Scheduling & Optimization

Schedule Options:

• Every 15 minutes (default)
• Once a day (daily at X time)
• Custom cron expression

Save Operations:

• Apply filters early (before expensive modules)
• Aggregate instead of processing individually
• Use webhooks instead of polling where possible
• Utilize batch processing

Execution Limits:

• Max 40 modules per scenario
• Max 100MB file transfers
• Timeout: 40 minutes

Part 4: Practical Example

Complete Workflow: Lead Capture with Enrichment

Goal:

Lead comes in via Typeform

Enrich with Clearbit

Create in HubSpot

Notify team in Slack

Send welcome email

The Workflow:

[Typeform: Watch Responses]
        |
        v
[HTTP: Clearbit Enrichment API]
        |
   [Router]
        |
  +-----+-----+
  v           v
[Found]    [Not Found]
  |           |
  v           v
[HubSpot:  [HubSpot:
 Create     Create
 Contact    Contact
 + Company  Basic]
 Data]        |
  |           |
  +-----+-----+
        v
[Slack: New Lead Notification]
        |
        v
[Gmail: Send Welcome Email]

Step-by-Step Setup: 1. Typeform Trigger

Module: Typeform -> Watch Responses
Form: "Contact Form"

2. Clearbit Enrichment

Module: HTTP -> Make a request
URL: https://company.clearbit.com/v2/companies/find
Query: domain={{parseURL(1.email).host}}
Headers: Authorization: Bearer {{clearbit_key}}
Parse response: Yes

3. Router with Filter

Path 1 Filter: {{2.company.name}} exists
Path 2 Filter: {{2.company.name}} does not exist

4. HubSpot (Path 1 - with Company Data)

Module: HubSpot -> Create a Contact
Email: {{1.email}}
First Name: {{1.firstName}}
Company: {{2.company.name}}
Industry: {{2.company.category.industry}}
Employees: {{2.company.metrics.employees}}

5. HubSpot (Path 2 - Basic)

Module: HubSpot -> Create a Contact
Email: {{1.email}}
First Name: {{1.firstName}}

6. Slack Notification

Module: Slack -> Create a Message
Channel: #leads
Text:
New Lead: {{1.firstName}} {{1.lastName}}
Email: {{1.email}}
Company: {{ifempty(2.company.name; "Unknown")}}

7. Welcome Email

Module: Gmail -> Send an Email
To: {{1.email}}
Subject: Welcome to [Company]!
Content: [HTML Template with {{1.firstName}}]

Part 5: Best Practices

Naming Convention

[Area] - [Purpose] - [Details]

Examples:
"Sales - Lead Enrichment - Typeform to HubSpot"
"Support - Ticket Routing - Zendesk"
"Marketing - Social Posting - Blog to LinkedIn"

Folder Structure

Sales
   +-- Lead Enrichment
   +-- Deal Alerts
Marketing
   +-- Social Automation
   +-- Email Sequences
Operations
   +-- Reporting
   +-- Notifications

Error Handling

Always include:

Error handlers on critical modules

Slack/Email alerts on errors

Logging in Data Store for debugging

Template for Error Handler:

[Module]
   |
   +--[Error Handler: Break]
          |
          +--[Slack: "Warning: Error in {{scenario.name}}: {{error.message}}"]

Testing

"Run once" for each build step

Run through with test data

Test all paths (Router)

Edge cases: Empty fields, wrong formats

Test error handlers

Documentation

In each scenario:

Add a Notes module at the beginning with description

Name modules (Right-click -> Rename)

Comment on complex logic

Conclusion

Make.com is powerful, but only as good as your understanding of it.

Learning Path:

Simple Trigger -> Action workflows

Understand filters and routers

HTTP requests for any API

Implement error handling

Complex data transformations

Next Steps:

Build your own scenario

Browse examples in the Make Community

Use and customize templates

Test the limits, evaluate n8n as an alternative

---

Want to use Make.com for your business but need support? We build your workflows from concept to production system.