Beginning
Imagine this: You've already create a Make.com account (from Lesson 1), and you know why Make best from Zapier and n8n for this course (from Lesson 2). You are ready to build your first automation — but that time you open your dashboard, you're met with a sidebar full of unfamiliar words: Scenarios, Modules, Connections, Webhooks, Data Stores.
If you don't know what these mean, even the simplest automation can feel confusing. So before we build anything, let's slow down and actually understand the control area you'll be working in.
By the end of this lesson, you'll be able to open Make.com and know exactly what every button, tab, and icon works — so when we build your first real automation in Lesson 4, there nothing to a single surprise.
In this lesson, you'll learn:
- What every part of the Make.com sidebar actually works
- The difference between a Scenario, a Module, and a Connection
- How to open the scenario builder and recognize what you're looking at
- Common beginner mistakes when first exploring the dashboard
Core Concept: The Control Room Analogy
Think of Make.com as a control room, not just a complete website. Every button in that page has one specific task/work — and once you know what each one work for, the whole page stops feeling overwhelming.
Here are the three most important terms you'll hear constantly in this course:
Scenario
This is Make's main part for one complete automation. If Lesson 1's example was "when an email arrives, add it to a Google Sheet," that entire flow — from start to finish — is called a Scenario.
Module
A Module is a one step inside a Scenario. Each Scenario is really just a chain of Modules connected together. The first Module is always the Trigger (the "when this happens" step), and every Module after it is an Action.
Connection
A Connection is how Make securely logs into another app on your behalf — like Gmail or Google Sheets — so it can watch for triggers and perform actions. You create a Connection only once time , and Make reuses it every time when you need that app again.
Once these three words click, the entire interface/UI stops looking like a foreign language.
Tool Walkthrough: Exploring Your Dashboard
Now let's actually open Make.com and walk through what you're looking at, piece by piece.
The Sidebar
On the left side of your screen, you will see a vertical menu. This is your main navigation, and it never moves no matter where you are in Make. Here's what each section does:
- Org — your organization/workspace settings
- Scenarios — a list of every automation you've built
- AI Agents — a newer section for building AI-driven agents (we won't touch this until later in the course)
- Credentials — where your saved logins for other apps live
- Webhooks — a special type of trigger we'll cover in Lesson 8
- MCP Toolboxes — advanced connections for AI tools (not needed yet)
- Templates — hundreds of pre-built Scenarios you can explore or copy
- Data Stores — Make's built-in mini-database for storing information between runs
- Devices and Data Structures — advanced features you won't need as a beginner
- Custom Apps — for connecting apps Make doesn't officially support yet
Creating a Blank Scenario
When you click "Create a scenario," you will redirect on an empty canvas — just a plus icon sitting in the middle of the screen. This is where every automation starts. Nothing is worry for about this blank page; it's simply waiting when you add your first Module In empty canvas.
Adding a Module
Clicking that plus icon opens a modules search popup where you can type the name of any app — Gmail, Google Sheets, Slack, OpenAI, and thousands more. Selecting an app here is you add a new Module to your Scenario.
How Modules Connect Visually
Once you have more than one Module, Make draws a line connecting them, showing the order they'll run in. This visual flow is exactly the Trigger → Action concept from Lesson 1, just drawn out on screen.
The Connections Tab
Under "Credentials," page you will find every login you've given Make to access. This is where you can see, for example, that your Gmail account is already connected — so you never have to re-enter your password and other data every time when you build something new.
Every time a Scenario runs — whether automatically or manually — Make keeps a log execution history. This is where you go and see if an automation doesn't behave which you expected; it exactly show you what happened at each step.
Screenshot
Real Example: Reading a Template Like a Pro
Let's put this new vocabulary to work. Open the same template from Lesson 1 — "Generate ChatGPT Completions from Google Sheets Rows."
Now, instead of just looking at it, identify each piece using what you just learned:
Get inputs (Watch New Rows) → this is the Trigger Module. It's the "when this happens" step.
Generate ChatGPT completion → this is an Action Module. It runs after the trigger fire's.
Paste completion (Update a Row) → this is a second Action Module, the final step in the chain.
All three of these Modules together make one Scenario. And behind the scenes, this Scenario is using two Connections modules— one to Google Sheets and one to OpenAI.
This is exactly how you should read every template from now on: Trigger first, then each Action in order, connected by Connections you cannot see but that are quietly doing their work.
Common Mistakes
Mistake 1: Clicking "Run once" without understanding what it does
New users often click this button out of curiosity before they've even finished building a Scenario, then they get confused by errors. Only run a Scenario once every Module is properly set up.
Mistake 2: Creating duplicate Connections
It's easy to accidentally create a brand-new Gmail or Sheets connection every time when you build a new Scenario. Always check the Connections tab/history first — then reuse an existing Connection is faster and keeps your account cleaner
Mistake 3: Using a template without customizing it
Templates are a basic starting automation point , not a ready to use product. Clicking "Use this template" and leaving everything exactly as-is (with someone else's example data or settings) is a common beginner mistake — always adjust the Modules to fit your own use case.
Try This Yourself
Before moving to Lesson 4, complete this short hands-on exercise:
- Log into your Make.com account and click "Create a scenario" — just look at the blank canvas, don't build anything.
- Open any template from the Templates section and see how many Modules it has in connection
- Identify which Module is the Trigger and which ones are Actions
- Delete/remove the blank scenario you created (no need to save it)
Key Takeaways
- A Scenario is one complete automation; a Module is only a one step inside it and Connection is how Make logs into another app
- The sidebar has a specific place for everything — Scenarios, Templates, Credentials, Webhooks, and more
- Every Scenario always starts with one Trigger Module, followed by one or more Action Modules
- Templates are the fastest way to practice identifying the Triggers and Actions in a real automation building
- Reusing Connections and customizing templates (instead of duplicating or copying blindly) will save you time and confusion later
Frequently Asked Questions
Do I need to memorize all the sidebar sections right now?
No. You'll naturally use Scenarios, Templates, and Connections the most in this course. The other sections (AI Agents, Data Stores, Custom Apps) will make more sense once we reach the lessons for use them.
What happens if I accidentally delete a Connection I'm using?
Any Scenario using that Connection will stop working until you reconnect the app. It's easy to fix — just click the Module using that app and reconnect — but it's best to avoid deleting any Connections you are not sure about that.
Can I have more than one Connection for the same app?
Yes. For example, you could connect two different Gmail accounts separately, which is useful if you manage automations for multiple email addresses or clients work.
Next Lesson Preview
In Lesson 4, we finally stop looking around and start building. You'll create your very first real automation from scratch — connecting Gmail to Google Sheets — using everything you've learned about Scenarios, Modules, and Connections in this lesson and from previous lessons.