The Only Video You'll Need to Master Make.com & AI Workflows (Beginner to Pro)

Key Concepts

• make.com: No-code automation platform for connecting apps and automating workflows.
• Scenarios: Individual workflows or automations built in make.com.
• Modules: Individual steps within a scenario (e.g., API calls, data transformations).
• Connections: Integrations with third-party software, often using API keys or OAuth.
• Triggers: Mechanisms that initiate a scenario (e.g., webhooks, scheduled polling).
• Webhooks: Real-time data pushes from external services to make.com.
• Operations: Individual executions of modules, used for billing.
• Data Types: Strings, numbers, dates, booleans, binary data.
• Data Structures: Arrays (lists), JSON objects (bundles), collections (arrays of objects), nested objects.
• Iterators: Modules that split a single bundle containing an array into multiple bundles, one for each item in the array.
• Aggregators: Modules that combine multiple bundles into a single bundle, often containing an array.
• Filters: Conditional checks that allow bundles to pass through a route based on specific criteria.
• Routers: Modules that split a scenario into multiple paths based on different conditions.
• HTTP Requests: Custom API calls to services not natively integrated with make.com.
• Scraping: Extracting data from websites or social media platforms.
• Error Handlers: Mechanisms for managing errors and preventing scenario failures.
• Functions: Built-in tools for data transformation and manipulation.
• Text Parsers: Modules for extracting specific data from text strings, often using regular expressions (regex).
• AI Integration: Using AI models (e.g., OpenAI, Gemini) to enhance automation workflows.
• Prompting Frameworks: Structured approaches to writing prompts for AI models to ensure consistent and reliable results.

1. Introduction to make.com

• Ben introduces himself as an AI automation agency owner since 2023, having built hundreds of make.com automations for clients.
• The video aims to provide a comprehensive make.com course, covering everything from basic concepts to advanced features like AI integration, APIs, scraping, and text parsing.
• The goal is to equip viewers with the knowledge to build and sell automations on make.com.
• The course will cover beginner to advanced topics, allowing experienced users to skip to relevant sections using the video chapters.

2. Course Overview

• Overview of make.com: Introduction to the platform, its purpose, key concepts, and user interface.
• Data Types and Structures: Explanation of data types (strings, numbers, dates, booleans, binary data) and data structures (arrays, JSON objects, collections, nested objects). Understanding these is crucial for debugging and efficient automation building.
• Essential Modules and Skills: Coverage of triggers, webhooks, filters, routers, connections, HTTP requests, iterators, aggregators, tools, and error handlers.
• AI Integration: Integrating AI into workflows, including setting up AI modules, prompting techniques, prompt chaining, and use cases.
• Advanced Features: Functions, text parsers, regular expressions (regex), and other advanced skills for complex automations.
• Practical Example: Building a lead generation automation from scratch to demonstrate the application of learned concepts.

3. What is make.com?

• make.com is a no-code automation platform for automating tasks and workflows across thousands of software applications.
• AI has significantly enhanced the power of these automations, enabling more complex processes.
• Example: Traditional lead form automation vs. AI-powered lead qualification and enrichment.
• make.com offers a drag-and-drop interface and built-in modules for working with various data types and structures.

4. Why Use make.com?

• Automate tasks and workflows across numerous software applications.
• Leverage native integrations with popular software for easy connectivity.
• Automate business processes to improve efficiency.
• Capitalize on the enhanced capabilities of AI-powered automation.
• Create opportunities for providing automation services to businesses.
• Examples of automations: newsletters, social media content, lead qualification, personalized email campaigns.

5. make.com vs. Other Automation Platforms

• Comparison with Zapier and n8n: Zapier is the easiest to use but less flexible and more expensive. n8n is more technical but offers greater customization and is cheaper. make.com lies in the middle, leaning towards n8n in terms of price and customization.
• Recommendation: make.com is suitable for non-technical users due to its ease of use and flexibility.
• make.com has over 2,000 native integrations, simplifying connections to various software applications.

6. Key Concepts and Terminology

• Scenarios: Workflows or automations.
• Modules: Steps within a scenario.
• Connections: Integrations with software applications.
• Webhooks and Triggers: Mechanisms for activating scenarios.
• Operations: Individual module executions, used for billing.

7. make.com UI Overview

• Dashboard: Overview of operations used.
• Users: Invite team members.
• Subscription: Manage paid plans.
  • Free plan: Limited to two active scenarios, 5-minute execution time, and 5MB file size.
  • Pro plan: Recommended for serious users, offering unlimited scenarios, longer execution times, and larger file sizes.
• Scenarios: Where automations are built.
• Templates: Template library (generally not very usable).
• Connections: List of integrated software applications.
• Webhooks: Manage webhooks.
• Scenario Settings:
  • "Allow storing of incomplete executions": Important for error handling.
• Scenario Menu Bar:
  • "Run once": Manually activate the automation.
  • "Save": Save the workflow.
  • "Settings": Configure scenario settings.
  • "Notes": Add notes to the workflow.
  • "Previous version": Undo actions.
  • "Auto align": Automatically align modules.
  • "Export blueprint": Export the scenario as a JSON file.
  • "Import blueprint": Import a scenario from a JSON file.

8. Data Types and Structures

• Importance: Understanding how data is passed between modules and how modules expect data to be structured.
• make.com simplifies data handling by providing an easy-to-read interface for input and output data.
• Data Types:
  • Strings: Text (e.g., names, messages). Identified by double quotation marks in raw data.
  • Numbers: Numerical values (e.g., ages, budgets). Without quotation marks in raw data.
  • Dates: Specific date formats.
  • Booleans: True/false conditions. Represented by checkboxes in make.com.
  • Binary Data: Files or audio.
• Data Structures:
  • Arrays: Lists of values (e.g., a list of emails). Identified by square brackets in raw data.
  • JSON Objects (Bundles): Structured way to store and transfer data, containing multiple data points for one entity (e.g., email, name, company). Identified by curly brackets in raw data.
  • Collections (Arrays of Objects): Lists of JSON objects (e.g., multiple persons with multiple data points).
  • Nested Objects: Structured data inside of structured data (e.g., company information within a person's record).

9. Essential Modules and Skills

• Native APIs/Connections: Using pre-built integrations with software applications.
  • Connecting via API keys or OAuth.
  • Using the "Make an API call" option for actions not natively supported.
• Triggers and Webhooks:
  • Triggers: Initiate scenarios.
  • Pulling Triggers: Poll APIs for updates at specific intervals.
  • Instant Triggers: Trigger scenarios in real-time using webhooks.
  • Webhooks: Receive data from third-party software when specific events occur.
  • Setting up custom webhooks using the "Custom Webhook" module.
  • Web Hook Responses: Sending data back to the software that triggered the web hook.
• Filters and Routers:
  • Filters: Conditional checks to allow bundles to pass through.
  • Routers: Split workflows into multiple paths based on different conditions.
  • Fallback Route: A backup route used if the source data doesn't meet any of the defined filter conditions.
• HTTP Requests (Custom APIs):
  • Use Cases:
    • Integrating with software applications that don't have native integrations.
    • Accessing specific actions not available in native integrations.
    • Scraping data from websites or social media platforms.
  • API Fundamentals:
    • Endpoints: Specific URLs where the API is accessed.
    • HTTP Methods: Define the type of action (GET, POST, PUT, DELETE).
    • Headers: Carry important data about the request (e.g., Authorization, Content-Type).
    • Request Body: Contains the data being sent to the API (often in JSON format).
  • Using RapidAPI and other API marketplaces to find and use pre-built APIs.
• Scraping:
  • Types of Scraping:
    • Simple Page Scraping: Extracting data from basic web pages.
    • Sitemap Scraping: Extracting URLs from a website's sitemap.
    • Web Crawling: Extracting content from all pages of a website.
    • Social Media Scraping: Extracting data from social media platforms.
    • Google Scraping: Extracting data from Google search results.
    • Complex Page Scraping: Extracting data from websites with anti-scraping measures.
  • Methods for Simple Page Scraping:
    • HTTP GET Requests: Simplest method, but may not work on all websites.
    • Using scrapers from RapidAPI or Apify.
    • Firecrawl: A popular and effective web scraping tool.
  • Sitemap Scraping:
    • Using a sitemap scraper to extract URLs from a website's sitemap.
    • Using AI to identify specific pages (e.g., blog pages).
  • Web Crawling:
    • Using a web crawler to extract content from all pages of a website.
    • Example: Building an AI assistant trained on the make.com documentation.
  • Social Media and Google Scraping:
    • Using scrapers from Apify and RapidAPI for social media platforms.
    • Using the SERP API for Google scraping.
  • Complex Page Scraping:
    • Using advanced web scraping APIs like Ninja Scraper or Scraperfly to bypass anti-scraping measures.
• Iterators and Aggregators:
  • Iterators: Split a single bundle containing an array into multiple bundles.
  • Aggregators: Combine multiple bundles into a single bundle.
  • Understanding bundles is crucial for working with iterators and aggregators.
  • Text Aggregators: Combine multiple bundles into a single text string.
• Built-in Tools:
  • Set Variable: Create or modify variables.
  • Sleep: Add delays to scenarios.
• Error Handlers:
  • Importance: Preventing scenario failures and ensuring data integrity.
  • Break Module: Retry a module after a delay.
  • Ignore Module: Ignore errors and continue the scenario.
  • Enabling "Allow storing of incomplete executions" in scenario settings.

10. AI Integration

• make.com AI Tools: Built-in AI modules for common tasks like sentiment analysis, text categorization, and translation.
• Types of L&M:
  • Non-Reasoning L&M: Faster, cheaper, and better for simpler tasks (e.g., GPT-4o, Claude 3.5, Gemini Flash).
  • Reasoning L&M: Slower, more expensive, and better for complex tasks (e.g., GPT-4, Gemini 1.5 Pro).
• L&M Use Cases:
  • Extracting Data: Extracting specific data points from text.
  • Generation: Generating new content.
  • Classification: Categorizing text.
  • Evaluation: Evaluating sentiment or the quality of AI outputs.
  • Data Transformation: Transforming data into specific formats.
  • Decision Making: Making decisions within AI agents.
• Prompting Frameworks:
  • Importance: Ensuring consistent and reliable results from AI models.
  • Short Structured Prompting Framework (for non-reasoning L&M):
    • Role and Objective: Define the role and task of the AI.
    • Instructions: Provide rules and output formats.
    • Examples: Give input and output examples.
    • Variables: Add variables to the prompt.
  • Long Structured Prompting Framework (for non-reasoning L&M):
    • Role: Define the role of the AI.
    • Objective: Define the goal of the AI.
    • Context: Provide context about the task.
    • Instructions: Provide detailed rules and output formats.
    • Examples: Give input and output examples.
    • Variables: Add variables to the prompt.
    • Notes: Add additional instructions or reminders.
  • Prompting Reasoning L&M:
    • Use direct and simple prompts.
    • Avoid overly detailed instructions.
• Choosing L&M and Prompting Frameworks:
  • General guidelines for selecting the appropriate L&M and prompting framework based on the use case.
• Prompt Chaining:
  • Breaking down complex tasks into multiple AI steps.
  • Using the outputs from previous modules as inputs for subsequent modules.
• Building a Lead Generation System:
  • Using the Apify Apollo scraper to generate leads.
  • Scraping LinkedIn profiles and posts to gather additional data.
  • Using OpenAI to generate personalized LinkedIn Outreach messages.
  • Adding the data to a Google Sheet.

11. Advanced Skills

• Functions:
  • Built-in tools for data transformation and manipulation.
  • Text Functions:
    • length: Checks the length of a string.
    • lower: Converts a string to lowercase.
    • upper: Converts a string to uppercase.
    • trim: Removes whitespace from the beginning and end of a string.
    • substring: Extracts a portion of a string.
    • split: Splits a string into an array.
    • contains: Checks if a string contains a specific substring.
  • General Functions:
    • get: Retrieves a specific value from an array.
    • if: Performs a conditional check.
    • empty: Checks if a string is empty.
  • Math Functions:
    • Basic arithmetic operations.
  • Date Functions:
    • now: Returns the current date and time.
    • addDays: Adds days to a date.
  • Array Functions:
    • join: Joins the elements of an array into a string.
    • length: Returns the number of elements in an array.
    • map: Applies a function to each element of an array.
    • flatten: Flattens a nested array.
• Text Parsers:
  • Match Pattern: Extracts specific data from text strings using regular expressions (regex).
  • Using AI to generate regular expressions.

12. Conclusion

• The video provides a comprehensive guide to building automations on make.com, covering everything from basic concepts to advanced techniques.
• The course equips viewers with the knowledge and skills to build and sell automations, leveraging the power of AI and no-code tools.
• Ben encourages viewers to like and subscribe to the channel and join the community for further learning and support.