---
title: Building Your First Simple Automation with Make
summary: Learn Make's core concepts, then build, test, and launch your first live automation step by step.
est_minutes: 20
sort: 4
---

#### LESSON 1: Make Fundamentals

Make is a visual automation platform. It connects your software apps and automates the hand-offs between them. Every automation in Make is called a scenario. Every scenario contains a trigger and one or more modules.

You need to understand three concepts before you can build anything. Once you understand these three, every automation you will ever build follows the same logic.

**Concept 1: Scenarios**

A scenario is a complete automation. It has a beginning (trigger), a middle (modules), and an end (final action or output). When you build an automation in Make, you are building a scenario.

Examples of scenarios:

- When a new lead fills out my intake form → Create contact in CRM → Send welcome email → Notify team in Slack
- When a client pays an invoice → Create onboarding task in ClickUp → Send onboarding email sequence via ActiveCampaign
- When I add a row to my Google Sheet → Use Claude to write a social media post → Post directly to LinkedIn

Each scenario runs automatically when its trigger fires. You build it once. It runs every time without you.

**Concept 2: Triggers**

The trigger is what starts the scenario. It watches for a specific event in a specific app and fires the scenario when that event occurs.

Trigger types:

- **Instant Triggers (Webhooks):** Fire the moment the event happens. Example: New form submission, new payment received, new email received with specific label. Use these when speed matters, lead follow-up, order confirmations, support tickets.
- **Scheduled Triggers (Polling):** Check for new data on a schedule you define, every 15 minutes, every hour, once per day. Example: Check for new rows in Google Sheets every hour. Use these when real-time response is not required.
- **Manual Triggers:** You run the scenario by clicking a button. Use these during testing and for one-off tasks that do not need to run automatically.

**Concept 3: Modules**

Modules are the individual steps within a scenario. Each module connects to a specific app and performs one action. You can chain as many modules as needed.

Module types:

- **Action Modules:** Do something: create a record, send an email, post to social media, add a row to a sheet, send a Slack message.
- **Search Modules:** Look something up: find a contact in your CRM, search for a document, look up an order.
- **Transform Modules:** Change data format: convert text to different case, extract a specific part of a string, format a date, parse JSON.
- **AI Modules (Claude/HTTP):** Send a prompt to Claude and receive the output as data you can route to any subsequent module in the scenario.

**The Make Scenario Anatomy**

Every scenario you build will follow this pattern:

1. Trigger
2. Data transformation (if needed)
3. Claude AI module
4. Review step (if needed)
5. Final action

Example:

1. New Typeform submission (Trigger)
2. HTTP module sends data to Claude with prompt (AI Module)
3. Gmail module sends Claude's output as an email (Action)

This is the core pattern for your Phase 1 automations. Learn this pattern and you can build the majority of what you need without any additional complexity.

**Make Account Setup**

Before building your first scenario, confirm the following:

- Make account created at make.com (free tier is sufficient for Phase 1)
- Primary business apps connected (Google Workspace, CRM, email platform)
- Claude API key obtained from console.anthropic.com and saved securely
- Claude HTTP connection configured in Make using your API key
- Your Claude API key location recorded somewhere secure
- Your Make workspace name confirmed

#### LESSON 2: Building Your First Workflow Step by Step

You are going to build Automation Priority #1 from your Module 2 stack as a live Make scenario. Follow each step exactly.

**Phase 1: Define the Scenario Before You Build**

Never open Make and start clicking before you have mapped the scenario on paper. Build on paper first. This prevents the most common beginner mistake, building something you cannot test because you forgot to plan a critical step.

Complete this before touching Make:

- Scenario name written out (descriptive)
- Trigger app identified
- Trigger event identified
- Trigger type chosen: Instant/Webhook, Scheduled (with interval), or Manual
- Module 1 (Trigger) defined
- Module 2 defined
- Module 3 (Claude AI) defined, including which prompt template runs here
- Module 4 defined
- Module 5 defined (if needed)
- Final output defined (what happens at the end of the scenario)
- Reviewer identified (who needs to review the output before it is used or sent)

**Phase 2: Build in Make Step by Step**

1. **Create new scenario.** In Make, click Create a new scenario. Name it using this format: [Process Name] — [Date]. Example: Lead Follow-Up Email — Feb 2026. Good naming now saves confusion later.
2. **Add and configure your trigger.** Click the empty circle in the center. Search for your trigger app. Select the correct trigger event. Follow the app connection wizard. Test the trigger by submitting a real test event in the trigger app. Before continuing, confirm the trigger app is connected, the test trigger event was submitted, and the trigger data is visible in Make.
3. **Add the Claude HTTP module.** Click the + after your trigger to add a module. Select HTTP. Choose Make a request. Configure as follows:
   - URL: https://api.anthropic.com/v1/messages
   - Method: POST
   - Headers: Add three headers — anthropic-version: 2023-06-01, x-api-key: [your Claude API key], content-type: application/json
   - Body type: Raw
   - Content type: JSON (application/json)
   - Body: Paste this structure and replace the prompt text with your template:

   `{"model": "claude-opus-4-6", "max_tokens": 1024, "messages": [{"role": "user", "content": "[YOUR PROMPT TEMPLATE WITH VARIABLES MAPPED FROM TRIGGER DATA]"}]}`

   Confirm the Claude module is configured and that your prompt template is pasted with variables mapped.
4. **Add your final action module.** Click + after the Claude module. Select the app where Claude's output should go. Map Claude's output text to the correct field in the action module. Note the action app, the action type (send email / create record / send notification / etc.), and confirm Claude's output is mapped to the correct field.

#### LESSON 3: Testing, Error Handling, and Going Live

An automation that has not been tested is not ready. Testing is not optional, it is the step that separates automations that work from automations that silently fail while you assume they are running.

**The Three-Stage Testing Process**

**Stage 1: Module-by-Module Test**

Test each module individually before running the full scenario. Right-click any module in Make and select Run this module only. Confirm each module produces the correct output before connecting the next one. Record a pass or fail result for the trigger module, the Claude module, and the action module, noting any issue for failures.

**Stage 2: Full Scenario Test**

Run the complete scenario from start to finish using a real test event. Do not use fake or placeholder data, use a real example that mirrors what the automation will actually process. Review every output at every step. Confirm the full scenario test run completes without errors, that the Claude output quality is acceptable or needs prompt revision, and that the final action output is correct.

**Stage 3: Edge Case Test**

Run the scenario with at least two unusual inputs, incomplete data, longer than normal text, unusual characters, missing optional fields. Identify how the automation handles edge cases and whether they need to be addressed before going live. Note each edge case you tested and whether it was handled correctly or needs a fix.

**Basic Error Handling**

Every Make scenario should have basic error handling configured before going live. Errors will happen. Without error handling, they happen silently.

Minimum error handling setup:

- Add an error handler to your Claude HTTP module: right-click the module, select Add error handler, choose Resume or Rollback based on whether the scenario should continue or stop on error
- Add an email or Slack notification as the error action so you are alerted when a scenario fails
- Set the scenario's error notification settings to email you on consecutive errors

Before going live, confirm the error handler is added to the Claude module and that an error notification (email or Slack) is configured.

**Going Live**

Before activating your scenario, complete this final checklist:

- All three testing stages passed
- Error handler configured on Claude module
- Error notification set up
- Scenario named clearly with date
- Trigger scheduling confirmed (instant / every X minutes)
- Review step documented, who checks outputs and how often
- Scenario activated (toggle in top right of Make scenario builder)
- Scenario go-live date recorded
- First week review scheduled

**Module 4 Completion Checklist**

Before taking the Module 4 Test, verify:

- Make account set up with Claude API connected
- Automation Priority #1 scenario built in Make
- All three testing stages completed
- Error handling configured
- Scenario is live and running
- Review schedule established for first week
