Make.com 101

MAKE.Com 101 === Chelle: [00:00:00] You know that pile of repetitive tasks sitting on your to-do list? The ones you keep thinking "there has to be a better way to do this"? Yeah, those. Today we're fixing that with Make.com. By the end of this video, you'll understand what Make is, why it's powerful, and you'll build your first automation that actually works. No computer science degree required (though if you have one, you'll appreciate this even more). This matters because Make is the visual automation platform that lets you connect all your apps together without writing code. We're talking Google Sheets talking to Gmail, Airtable feeding into Slack, your entire digital toolbox working together while you sleep. Let's get started. Here's what you need: A free Make.com account—and yes, it's actually free, not a seven-day trial that expires right when you figure it out. You get a thousand operations per month on the free [00:01:00] plan, which is plenty for learning and honestly enough for small automations even after you know what you're doing. You'll also want at least two apps you use regularly. We're using Google Sheets and Gmail for this demo, but swap in whatever you've got. The principles work the same whether you're connecting Notion to Slack or Airtable to your email platform. Pause here if you need to sign up. Go to make.com, create your account, and meet me back here. Let's talk about what Make actually is and why you'd choose it over other automation tools. Make is a no-code platform that uses a visual canvas to build automations. Instead of Zapier's straight line of actions, you get to see your workflow spread out in front of you like a flowchart. When things get complex—and they will—this visual approach saves your sanity. Here's the vocabulary you need. Make calls automations "scenarios." Each scenario lives on a canvas where you drag and [00:02:00] drop "modules." Modules are individual actions like "watch for new spreadsheet rows" or "send an email." You connect modules together, and data flows between them following the paths you set up. Now here's where Make flexes compared to simpler tools. First, you can build complex logic without losing your mind. Routers let you send data down multiple paths simultaneously. Iterators let you process lists item by item. Aggregators collect data back together. Try doing that elegantly in Zapier—I'll wait. Second, Make has better built-in data handling. What takes three or four steps in other platforms often takes one module in Make. Your operation count will thank you, and on the free tier, operations matter. Third, you can actually see what's happening. When you have branches, conditions, and parallel processes, Make's visual layout means future you [00:03:00] won't be staring at a linear list wondering where things went sideways. The trade-off is that Make has a steeper learning curve than dead-simple tools. But stick with me for fifteen minutes, and you'll have the foundation you need to build pretty much anything. Time to build something real. We're creating a scenario that watches a Google Sheet for new rows and sends you an email when one appears. This is the foundational pattern you'll use for thousands of automations. Log into Make and click "Create a new scenario." You land on a blank canvas with a big plus button in the middle. That's your starting point. Click that plus button and search for "Google Sheets." Choose "Watch Rows"—this is a trigger module, meaning it kicks off your automation when something changes. Make asks you to connect your Google account. Click "Add," sign in, give the connection a clear name like "My Google Account." Future you needs [00:04:00] clear naming when you're managing fifteen scenarios and can't remember which connection goes where. Now configure what you're watching. Pick your spreadsheet from the dropdown, then pick the specific worksheet tab. Toggle "Table contains headers" to ON if your first row has column names—it probably does. Set the limit to 10. This tells Make how many rows to check each time it runs. Click OK. See that little clock icon on your module? That means it's a trigger—it's watching for changes. Right-click the module and choose "Run this module only." This tests whether Make can actually read your data. Success looks like seeing your actual spreadsheet data show up. Make calls each chunk of data a "bundle"—just roll with the terminology. Now let's add the action. Click the plus button after your Google Sheets module, [00:05:00] search for "Gmail," and choose "Send an Email." Connect your Gmail account—same process as before. For the "To" field, type your email address. For subject, type something like "New spreadsheet row alert." Here's where it gets fun. Click in the Content field. See all those fields from your Google Sheet showing up on the right? You can click any of them to insert that actual data into your email. Build something like: "New row added. Name:" click your Name column. "Email:" click your Email column. "Notes:" click your Notes column. Those curly braces around the field names mean "insert the real data here." This is how Make connects one app's output to another app's input. You're mapping data between modules. Click OK. Your scenario now has two modules connected by a line. That line is your data flowing from Google Sheets to Gmail. [00:06:00] This is the basic pattern for every automation you'll build—trigger, action, data mapping between them. Before we turn this loose to run automatically, we test it. This is non-negotiable. I've watched too many people skip testing and then wonder why their automations are sending blank emails or missing data. Click "Run once" at the bottom of the screen. Make runs through your scenario and shows you exactly what happened. Green checkmarks mean success. Numbers show how many bundles processed. The details panel shows the actual data that moved through. Go check your email. Did you get the test email with your spreadsheet data in it? If yes, you're golden. If no, click into your Gmail module and check the data mapping—Make shows you exactly what data is available. Now add a new row to your spreadsheet and click "Run once" again. You should get another email with the new row data. [00:07:00] This verifies your scenario works end-to-end before you set it to run automatically. This test-before-activate pattern will save you from so many headaches. Your automation can't send you a Slack message if you haven't given it the right API credentials. It can't add data to Airtable if your field mapping is wrong. Test everything before you flip that switch. Time to make this automatic. Click the little settings icon in the bottom left to open your scenario settings. Make's free tier lets scenarios run every fifteen minutes. Paid plans go down to one minute, but honestly? Fifteen minutes is fine for most workflows. Your newsletter subscribers can wait fifteen minutes for a welcome email. Your team can wait fifteen minutes for a Slack notification. Don't obsess over speed until speed actually matters. Set your schedule to every fifteen minutes and click OK. Now flip that switch at the bottom from OFF to ON. Your [00:08:00] scenario is live and will run every fifteen minutes, checking for new spreadsheet rows and sending emails when it finds them. Give this scenario a real name. Click that pencil icon and name it something useful like "Sheet Alerts" or "New Subscriber Notifications." When you have twenty scenarios running, "New Scenario 1" tells you nothing. Back on your dashboard, you'll see your active scenarios with that green ON badge. The operations counter shows how many times each scenario has run. On the free tier, you get a thousand operations per month. Each module uses one operation per run, so a three-module scenario uses three operations each time it executes. Do the math—a three-module scenario running every fifteen minutes uses about 8,640 operations per month. That's why you'll either need to schedule less frequently or upgrade [00:09:00] eventually. Want to level this up? Duplicate this scenario, swap the Gmail module for something else—Slack notification, Airtable update, whatever—and you've got multi-channel alerts from the same trigger. This is the Make advantage: build once, branch to multiple destinations. Quick troubleshooting because you will hit these issues. "My scenario isn't running"—Check that toggle switch is ON and your schedule is set. Make won't run scenarios that are turned off, and yes, I have done this more times than I'll admit. "The data isn't what I expected"—Click into any module and look at what data is actually available. If a field is empty, that data doesn't exist in the source. Make shows you exactly what's there—no guessing required. "I hit my operations limit"—Each module run equals one operation. Reduce your schedule frequency, simplify your scenarios, or upgrade to a paid plan. [00:10:00] Those are your options. "Error: Invalid access token"—Your app connection expired. Go to Connections in the left sidebar, delete the old connection, add it again. Apps make you re-authenticate sometimes. It's annoying but quick to fix. You just built and deployed your first Make scenario. You understand the pattern—trigger, action, test, activate. This pattern works whether you're connecting two apps or twenty. The visual canvas makes sense now. Those modules are just puzzle pieces that snap together. The data flows from left to right following the lines you draw. When things get complicated—and they will—you'll appreciate being able to see the whole workflow at once. Start simple. Build something that saves you five minutes a day. Then build another one. Make gets more powerful the more you experiment with it. Routers, iterators, error handling, API connections—they're all [00:11:00] waiting for you when you're ready. Give this a shot and let me know how it goes. Reply to the newsletter if you get stuck or just want to show off what you built. Now go automate something.