Make (Integromat): Visual Automation

Make (Formerly Integromat): Building Powerful AI Workflows

Make is a visual automation platform that connects apps and services without code. Where Zapier is linear (trigger → step → action), Make is a full workflow builder with branching, loops, error handling, and complex data transformation. Combined with AI tools, it enables automation workflows that would otherwise require custom development.

Make vs. Zapier: The Real Difference

Both tools connect apps without code. The practical differences matter:

Make: Visual flow builder, complex branching logic, loops, error paths, aggregators, iterators. Better for complex multi-step workflows. More affordable at scale. Steeper initial learning curve.

Zapier: Linear workflows only (though multi-step). Larger app library. Much easier to start. More expensive per task at scale.

When to choose Make:

• Your automation has conditional branches ("if customer is enterprise, do X; if SMB, do Y")
• You need to process arrays of data (send 20 emails based on 20 spreadsheet rows)
• You need error handling with fallback paths
• You're processing high volume (cost matters)
• You want to build workflows that feel like real software, not just chained app triggers

Make Fundamentals

Modules

Every step in Make is a "module" — a specific action from a specific app:

• Trigger: The starting event (new row in Google Sheets, webhook received, scheduled time)
• Action: Something that happens (send email, create Slack message, update CRM)
• Transform: Manipulate data without calling external APIs (format dates, parse JSON, filter arrays)
• Flow: Control logic (router for branching, iterator for loops, aggregator for combining)

Scenarios

A complete workflow is called a "scenario." Scenarios run when triggered, on a schedule, or via webhook.

Data Mapping

Between modules, you map data — taking output from one module and passing it to the next. Make has a formula language for transforming values:

{{formatDate(1.date; "YYYY-MM-DD")}}           — format a date
{{lower(1.email)}}                              — lowercase a string
{{if(1.status = "active"; "Yes"; "No")}}        — conditional value
{{parseJSON(1.raw_data)}}                       — parse JSON string

Building AI Workflows with Make

Connecting ChatGPT / OpenAI

1. Add an HTTP module → Make Custom API Call (or use the dedicated OpenAI module)
2. URL: https://api.openai.com/v1/chat/completions
3. Method: POST
4. Headers: Authorization: Bearer {{api_key}}
5. Body (JSON):

{
  "model": "gpt-4o",
  "messages": [
    {"role": "system", "content": "You are a professional business writer."},
    {"role": "user", "content": "{{your_dynamic_prompt}}"}
  ],
  "max_tokens": 1000,
  "temperature": 0.7
}

The response contains choices[0].message.content — map this to your next module.

Practical AI Workflow: Content Approval Pipeline

Trigger: New Google Form submission (content request) Step 1: ChatGPT generates the draft based on the brief Step 2: Route based on content type

• Blog post → send to writer for review via email
• Social post → check length, send to Slack for quick approval
• Email → create draft in Gmail for marketing manager Step 3: On approval → post to relevant platform

Practical AI Workflow: Lead Intelligence

Trigger: New lead added to HubSpot (or form submission) Step 1: Search for company on Clearbit/Apollo (enrich lead data) Step 2: Send to ChatGPT:

Based on this company profile, write:
1. A personalized first-touch email (3 sentences, our product is [X])
2. The best talking points for a sales call with this company
3. Priority: high/medium/low with one-sentence reasoning

Company: {{company_name}}
Industry: {{industry}}
Size: {{employee_count}}
Revenue: {{revenue}}
Tech stack: {{technologies}}

Step 3: Parse the JSON response Step 4: Update HubSpot deal with personalized email draft and call notes Step 5: If priority = high → notify sales team in Slack immediately

Practical AI Workflow: Customer Feedback Analysis

Trigger: New row in Google Sheets (weekly export from Intercom/Zendesk) Step 1: Iterator — process each feedback row individually Step 2: ChatGPT analysis per ticket:

{"category": "billing|technical|feature|other", 
 "sentiment": "positive|neutral|negative", 
 "priority": "urgent|high|medium|low",
 "key_issue": "one sentence summary",
 "feature_request": "specific feature request or null"}

Step 3: Aggregator — collect all classified items Step 4: Google Sheets — write results back to analysis tab Step 5: Filter for feature_requests that are not null Step 6: Append to a "Feature Requests" sheet with de-duplication check

Practical AI Workflow: Automated Onboarding Email Sequence

Trigger: New user created in your database (webhook from your app) Step 1: Wait module — delay until next business day Step 2: Fetch user's industry and role from your database (HTTP request to your API) Step 3: ChatGPT generates personalized onboarding email:

Write a personalized day-1 onboarding email for a new user.

User: {{name}}
Company: {{company}}
Role: {{role}}
Industry: {{industry}}

Our product: [your product description]

Email should:
- Reference their specific role/industry
- Highlight the 2-3 features most relevant to their use case
- Invite them to a quick setup call
- Be under 150 words, conversational, signed by [founder name]

Step 4: Create draft in Gmail or send via email API

Error Handling in Make

Make lets you add error handlers to modules:

1. Right-click any module → Add error handler
2. Options: Ignore, Resume, Rollback, Break

For AI workflows: add error handlers on the ChatGPT call to catch API errors, rate limits, or malformed JSON responses. Route failures to a "manual review" path rather than silently failing.

JSON Parsing in Make

ChatGPT returns unstructured text by default. For automation, you need structured data:

In your prompt: Always request JSON output and specify the exact schema:

Return ONLY valid JSON matching this exact structure, no markdown:
{
  "category": "string",
  "priority": "high|medium|low",
  "summary": "string"
}

In Make: Use the parseJSON function to extract fields from the response:

{{parseJSON(1.choices[0].message.content).category}}

Or add a JSON Parse module if the structure is complex.

Make Pricing

Free tier (1,000 operations/month, 2 active scenarios). Core ($9/month): 10,000 ops. Pro ($16/month): 10,000 ops + advanced features. Business for teams.

Operations = each module execution. A 5-module scenario run = 5 operations.

Next lesson: Zapier AI workflows — building AI-powered automations with the world's largest app connector.