Skip to content
Learni
View all tutorials
Automatisation

How to Automate Your Workflows with Make in 2026

18 minINTERMEDIATE
AutomatisationNo-codeWorkflowsMakeIntegromat
Lire en français

Introduction

In 2026, Make (formerly Integromat) is the most powerful no-code/low-code automation tool, outshining Zapier with its flexibility and native AI integration through OpenAI modules. Imagine syncing Google Sheets leads to a HubSpot CRM in real-time, filtering urgent alerts to Slack, or scraping RSS data without writing a single line of code. This intermediate tutorial walks you through mastering importable JSON blueprints, key to scaling your workflows. Why does it matter? Businesses save 30% of time on repetitive tasks, freeing developers for innovation. We start with a basic RSS-to-Email scenario and build up to complex flows with iterators and error handling. Every blueprint is 100% functional: just copy-paste and import into Make. Ready to transform your processes? (142 words)

Prerequisites

  • Free Make account (make.com) with email verification.
  • Access to test services: Gmail, Google Sheets, Slack (API keys if needed).
  • Basic knowledge of HTTP/JSON and APIs (intermediate level).
  • Modern browser (Chrome recommended for the drag-and-drop interface).

Blueprint 1: Basic RSS to Email

blueprint-rss-email.json
{
  "name": "RSS to Email",
  "flow": [
    {
      "id": 1,
      "module": "rss:WatchRssFeed",
      "version": 1,
      "parameters": {
        "url": "https://example.com/rss"
      },
      "mapper": {},
      "metadata": {
        "designer": {
          "x": 0,
          "y": 0
        }
      }
    },
    {
      "id": 2,
      "module": "gmail:SendAnEmail",
      "version": 1,
      "parameters": {},
      "mapper": {
        "to": "votre@email.com",
        "subject": "={{1.title}}",
        "content": "={{1.description}}"
      },
      "metadata": {
        "designer": {
          "x": 300,
          "y": 0
        }
      }
    }
  ],
  "metadata": {
    "version": 1,
    "scenario": {
      "roundtrips": 1,
      "maxErrors": 3
    }
  }
}

This blueprint watches an RSS feed and sends each new article via Gmail email. Import it via 'Import blueprint' in Make, replace the RSS URL with yours (e.g., Hacker News), and connect your Gmail account. Pitfall to avoid: Check OAuth permissions for Gmail, or the module will fail silently.

Step 1: Import and Run the First Scenario

Log in to make.com and click 'Create a new scenario.' In the visual editor, click the Import icon (upward arrow) and paste the JSON from Blueprint 1. Make automatically parses the modules: RSS as input (blue fish), Gmail as output (green fish). Click each module to configure: RSS URL = 'https://news.ycombinator.com/rss', Gmail = OAuth link. Test with 'Run once': a bundle appears if successful. Activate with the top toggle. Analogy: Like a garden hose—RSS pushes the water, filters direct it, Email receives it. Estimated time: 2 minutes. This flow handles 100+ articles per day effortlessly.

Blueprint 2: Adding a Conditional Filter

blueprint-rss-filter.json
{
  "name": "RSS to Email avec Filtre",
  "flow": [
    {
      "id": 1,
      "module": "rss:WatchRssFeed",
      "version": 1,
      "parameters": {
        "url": "https://news.ycombinator.com/rss"
      }
    },
    {
      "id": 2,
      "module": "builtin:BasicFilter",
      "version": 1,
      "parameters": {},
      "mapper": {
        "condition": "={{contains(lower(1.title); "javascript")}}"
      }
    },
    {
      "id": 3,
      "module": "gmail:SendAnEmail",
      "version": 1,
      "mapper": {
        "to": "dev@equipe.com",
        "subject": "JS News: {{2.title}}",
        "content": "={{2.description}}"
      }
    }
  ],
  "metadata": {
    "version": 1
  }
}

Adds a filter that only sends articles containing 'javascript' (case-insensitive). Connect it after RSS, before Email. Use the contains(lower()) function for matching. Pitfall: Make syntax is ={{ }}—forget the double braces and the bundle fails.

Step 2: Add Filters and Routers for Advanced Logic

In the Make editor, drag a 'Filter' between RSS and Email (funnel icon). Edit the condition: {{contains(lower(1.title); "javascript")}}—'1' refers to the previous RSS module. Test it: Only JS titles pass through. Add a Router (fork icon) for multiple paths: one for urgent Slack alerts (if >100 upvotes), one for Email. Visual: The interface shows connected lines; red means error. Powerful Make functions: length(), parseJSON(), formatDate(). Real example: Filter {{1.pubDate > now - 1d}} for 24-hour fresh content. Scale to 10k executions/month for free.

Blueprint 3: Incoming Webhook for Custom Triggers

blueprint-webhook-slack.json
{
  "name": "Webhook to Slack",
  "flow": [
    {
      "id": 1,
      "module": "webhook:CustomWebhook",
      "version": 2,
      "parameters": {
        "runAs": "deterministic"
      },
      "mapper": {}
    },
    {
      "id": 2,
      "module": "slack:SendAMessage",
      "version": 2,
      "parameters": {
        "channel": "#alerts"
      },
      "mapper": {
        "text": "Nouveau lead: {{1.body.name}} - {{1.body.email}}"
      }
    }
  ],
  "metadata": {
    "version": 1,
    "webhook": {
      "url": "https://hook.make.com/your-hook-id"
    }
  }
}

Creates a webhook URL (generated by Make) that forwards POST data to Slack. POST JSON like {name: 'John', email: 'j@ex.com'} to the URL to test. Ideal for custom forms. Pitfall: Activate the scenario to generate the webhook URL; inactive = 404.

Step 3: Webhooks and HTTP Modules for Custom Integrations

Webhook: Drag 'Webhooks > Custom webhook' as the first module. Make generates a unique URL (e.g., hook.make.com/abcd123). Test with curl: curl -X POST https://hook.make.com/abcd -d '{"name":"Test"}'. Map {{1.body.name}} to Slack. HTTP module: For APIs without native connectors, add 'HTTP > Make a request'. Example: GET GitHub API https://api.github.com/users/{{1.username}}, headers Authorization: token xxx. Security: Use 'Digest' for HMAC. Real use case: Stripe webhook → Slack for payments >$100. Execution logs show processed bundles (yellow=success, red=retry).

Blueprint 4: Iterator for Arrays (Multi-Row Sheets)

blueprint-iterator-sheets.json
{
  "name": "Sheets Iterator to Emails",
  "flow": [
    {
      "id": 1,
      "module": "google-sheets:SearchRows",
      "version": 4,
      "parameters": {
        "sheetId": "your-sheet-id",
        "tableId": "A:Z"
      },
      "filter": {
        "status": "new"
      }
    },
    {
      "id": 2,
      "module": "builtin:Iterator",
      "version": 1,
      "mapper": {
        "array": "={{1.rows}}"
      }
    },
    {
      "id": 3,
      "module": "gmail:SendAnEmail",
      "mapper": {
        "to": "={{2.Email}}",
        "subject": "Bienvenue {{2.Name}}"
      }
    }
  ],
  "metadata": {
    "version": 1
  }
}

Searches for 'new' rows in Sheets, iterates over the rows array to send personalized emails per lead. Replace sheetId with your Google Sheets ID. Use Aggregator as the inverse for batching. Pitfall: Iterator explodes arrays >1000; limit with slice().

Step 4: Handle Arrays with Iterators and Aggregators

For APIs returning arrays (e.g., Sheets 'Search rows'), the Iterator loops: map array: {{1.rows}}, then process modules per item ({{2.Name}} references the iterated item). Reverse with Aggregator afterward: collects into array/CSV. Example: Iterate 50 Sheets leads → 50 emails, then aggregate into a Slack report. Functions: map(), first(), add(). Performance: Parallel bundles speed things up (Iterator parameter). Visual: Dotted lines for multiple iterations. Pro use case: GitHub issues → iterated Trello cards.

Blueprint 5: Error Handling and Retries

blueprint-error-handler.json
{
  "name": "RSS avec Error Handler",
  "flow": [
    {
      "id": 1,
      "module": "rss:WatchRssFeed",
      "parameters": {
        "url": "https://news.ycombinator.com/rss"
      }
    },
    {
      "id": 2,
      "module": "gmail:SendAnEmail",
      "mapper": {
        "to": "alert@team.com",
        "subject": "Erreur RSS: {{1.title}}"
      }
    }
  ],
  "metadata": {
    "version": 1,
    "errorHandlers": [
      {
        "id": "eh1",
        "moduleId": 2,
        "maxAttempts": 3,
        "wait": "exponential",
        "fallbackScenario": false
      }
    ]
  }
}

Adds an error handler on Email: 3 exponential retries (1s, 2s, 4s) on failure. Falls back to an alert email. Edit via 'Add error handler' on the module. Pitfall: Without a handler, bundles are lost; always log {{error.message}}.

Step 5: Error Handlers and Advanced Monitoring

Error Handler: Right-click a module → 'Add error handler.' Choose retry (exponential) or fallback flow. Log {{error.code}} : {{error.message}} to Slack. Monitoring: The 'Executions' dashboard shows success rates (aim for 99%), bundles/min. Webhooks for Discord alerts. 2026 AI: OpenAI module for auto-summarizing errors. Scale: Team blueprints for collaboration (share via JSON URL).

Best Practices

  • Limit bundles: Use early filters to avoid quotas (free: 1000 ops/month).
  • Safe mapping: {{get(1.data; "key"; "default")}} prevents null crashes.
  • Secure secrets: Environment variables for API keys, not hardcoded.
  • Iterative testing: 'Run partially' for debugging without full runs.
  • Version blueprints: Export JSON to Git for rollback.

Common Errors to Avoid

  • Wrong bundle reference: {{2.field}} if module 1 → use {{1.field}}; check numbers on hover.
  • Expired OAuth: Reconnect accounts every 6 months; Make sends alerts.
  • Infinite loops: No recursive triggers (e.g., webhook self-call).
  • Large payloads: >8MB crashes; chunk with Iterator + sleep(1s).

Further Reading

  • Official documentation: Make Academy.
  • Community: Make Forum + Reddit r/Integromat.
  • Advanced: Custom JS/Python modules via the 'Code' tool.
  • Learni Training: No-Code AI Masterclass with Make (includes certification).