Free preview · no sign-up required

Automation with n8n: full syllabus and an entire chapter

Design, build, bill, and maintain automation that can handle clients — with both tools on the same screen

This course starts with a question almost no other material answers: why does the same flow cost one thing in n8n and another in Make? Because the two count things differently. n8n charges per **workflow execution**, with unlimited steps inside it. Make charges per **module call**. A forty-step flow costs one execution on one side and forty credits on the other.

This isn't a billing detail: **it's what decides the flow's design.** And that's why this course isn't an "n8n course" or a "Make course" — both appear in the same chapter, compared task by task, which is how the decision actually happens.

From chapter 1 to 30, we follow the same person: Júlia, 29, provides automation services to three clinics and one e-commerce in Londrina. She started with Make because the interface is easy, and in chapter 1 she discovers that her lead-handling scenario eats a dozen credits per lead — the quota runs out on the 12th, and she can't tell the client whether it's the design's fault or the plan's. By chapter 30, she designs before building, chooses based on the flow's shape, knows what she can charge and what the license won't let her sell, and delivers a monthly report that renews the contract on its own.

30 chapters · 6 modules · 8+ hours

What you learn, chapter by chapter

Module 1: Automation Is Design, Not Tool

What a flow is, where it breaks, and the decision that changes everything before any click: the billing unit. Plus the discomfort that comes early — wrong automation doesn't fail once, it fails at scale and in silence.

  1. 1. The Billing Unit Decides Your Flow's Design

  2. 2. Anatomy of a Workflow: Trigger, Steps, and the Data That Flows Through

  3. 3. The event that arrives twice: automation fails at scale, silently

  4. 4. The flow has no memory — and that's why it duplicates

  5. 5. Sketch on a sheet before building on screen

Module 2: n8n and Make Inside Out ⚠️ dated chapter

Plan, quota, limit, and version, with the reading date next to each number. This is the module that ages on purpose — including what n8n 2.0 broke in old tutorials.

  1. 6. n8n: plans, executions, and what the Community delivers

  2. 7. Make: credits, scenarios, and the limits that hit first

  3. 8. The same automation in both, with the bill on the table

  4. 9. Self-hosting: What's Free and What Only Looks Free

  5. 10. What n8n 2.0 broke, and why yesterday's tutorial no longer works

Module 3: Building a Flow That Survives

Trigger, transformation, API call without a ready-made node, error and retry, versioning, and credentials. This is the craft module: what you open the screen and do.

  1. 11. Triggers: webhook, scheduling, and periodic checks

  2. 12. Transform data without coding — and when Code is worth it

  3. 13. HTTP Request: the key that opens any system without a ready-made node

  4. 14. Failing Well: Retry, Queue, and the Alert That Reaches You

  5. 15. Publish, version, and store credentials

Module 4: Agent Inside the Flow

The step that decides on its own: AI Agent, tools exposed via sub-workflow and MCP, human approval before irreversible action, and the cost that stops being linear once AI enters.

  1. 16. The step that decides on its own: the agent node

  2. 17. Giving the agent tools: sub-workflow and MCP

  3. 18. Human approval before irreversible actions

  4. 19. Make AI Agents and the Grid: stop picking sides

  5. 20. The cost of the agent: when credits stop being linear

Module 5: Law, Data, and Risk

The license that separates what you can charge from what you can't, where client credentials and data live, what European labeling requires of automation that publishes, and what to do when the provider changes the rules mid-contract.

  1. 21. The license that decides what you can charge

  2. 22. Client credential and data: where they live and who sees them

  3. 23. Automation that publishes: the labeling that became mandatory

  4. 24. When the provider changes the rules mid-contract

  5. 25. The workflow you deliver: who owns it, and who pays the bill

Module 6: This Becomes a Service

Price by outcome, define who owns the flow and who owns the account, monitor in a way that renews contracts, and the three best-selling flows, designed from trigger to delivery.

  1. 26. Pricing by Outcome, Not by Hour or by Execution

  2. 27. Monitoring in a Way That Renews the Contract

  3. 28. The Three Workflows That Sell the Most, Designed

  4. 29. Choosing the tool by process segment

  5. 30. The quarterly check-in that keeps all of this true

Chapter 1 in full

This is the complete chapter, just like the one inside the course — text, images, and videos.

Overview

You built a flow in Make, it worked, and on the 12th of the month the quota ran out. The fault isn't the plan — it's the design. The two most-used automation tools count things differently: n8n charges per workflow execution, Make charges per module call. The same 40-step flow costs 1 execution in one and 40 credits in the other. Whoever doesn't know this designs the right flow in the wrong tool and then blames the plan, the client, or their own luck.

This chapter installs the decision that comes before any click: the billing unit. Understanding it changes where you build each automation and how much you charge the client. It's not a billing detail — it's the difference between delivering a service that pays for itself and one that silently eats the profit.

Key Concepts

n8n charges per workflow execution. An execution is one complete pass from trigger to end, and the steps inside it are unlimited — the pricing page itself, read on 17/08/2026, says "workflow executions with unlimited steps." In other words: a flow with 10, 40, or 100 steps costs the same, as long as it runs once. What weighs is frequency, not size.

Make charges per module call. Each module that runs consumes credits, and the rule is 1 operation = 1 credit, regardless of data size (help.make.com, 17/08/2026). A 40-step flow costs 40 credits per run. If it runs 100 times a day, that's 4,000 credits — the entire month's quota in one day.

Deciding what a good result looks like before asking anything of the tool.
Deciding what a good result looks like before asking anything of the tool.

The arithmetic consequence is direct: long, infrequent flows favor n8n; short, very frequent flows require doing the math on both. There's no "best tool." There's the flow that fits your plan. The pocket rule: design the flow, count the steps, estimate the frequency, and only then choose the tool.

Two different metrics: in n8n, one execution covers all steps; in Make, each step is a credit.
Two different metrics: in n8n, one execution covers all steps; in Make, each step is a credit.

Execution Flow

  1. List the steps of your flow, from trigger to the last module. Don't think about the tool yet — just what needs to happen. Include hidden stages like "fetch lead," "enrich," "send email."
  1. Estimate the real frequency. How many times per day, per week, per month does this flow trigger? Use the client's number, not your wish. If it's a monthly report, that's 12 executions a year; if it's a new lead, it could be 50 a day.
  1. Calculate the cost in n8n: 1 execution per run, with all steps inside. Then in Make: number of steps × number of runs = credits per month. Compare with the limit of the plan you have or will subscribe to.
  1. Compare both results with the real price of each plan. n8n charges in euros on the official page; Make in credits. Convert to your monthly cost. If one plan costs R$ X and the other R$ Y, which one fits the client's contract?
  1. Redesign if the number blows up. A short, frequent flow can be split into two smaller flows; a long, rare flow can stay in n8n without worry. The tool is a consequence of the calculation, not the other way around.
The step-by-step of calculating cost before building: list, estimate, calculate, compare, redesign.
The step-by-step of calculating cost before building: list, estimate, calculate, compare, redesign.

Applied Scenarios

Scenario 1: the monthly report that wastes credits. Júlia built a flow in Make that generates a revenue report for a clinic. It has 35 modules: database query, formatting, email sending, spreadsheet update. It runs once a month. Cost in Make: 35 credits per month. Cost in n8n: 1 execution per month. On Make's free plan, this consumes credits that could be used for more frequent automations; in n8n, it's a single execution among the available ones. The flow works in both, but n8n leaves Make's quota free for what matters. Júlia moved the report to n8n and the client didn't even notice the difference — only the bill got lighter.

Scenario 2: the new lead that blew up on the 12th. Júlia had a flow in Make that handled each new lead: 12 modules (capture, enrich, notify, schedule). The clinic gets 30 leads a day. 12 × 30 × 30 = 10,800 credits per month. Make's free plan quota ran out on the 12th, before the end of the month. In n8n, that would be 900 executions per month (30 × 30), a number that fits the free plan's quota. Júlia rebuilt the flow in n8n, but Make's trigger kept consuming test credits. She learned: design first, calculate first, and only then build.

The same flow, two costs: a 35-step monthly report costs 35 credits in Make and 1 execution in n8n.
The same flow, two costs: a 35-step monthly report costs 35 credits in Make and 1 execution in n8n.

Common Mistakes

  • Confusing credit with execution. You think "1 credit = 1 run," but it's 1 credit per module. A 20-step flow runs 20 credits per run. Check the count on Make's screen before assuming.
  • Designing in Make because the interface is easy. Ease doesn't pay the quota. n8n has a steeper learning curve, but the cost per execution can be lower for long flows. Decide by the numbers, not familiarity.
  • Ignoring modules that consume more than 1 credit. Some of Make's AI modules cost "more than 1" credit, but the page doesn't say how much. If your flow has an AI step, the real cost is higher than the number of steps suggests. Test with a small flow first.
  • Not counting retries and tests. Each execution attempt counts as a new execution. If the flow fails and retries, that's two executions in n8n, two credits in Make. The real cost includes failures.
  • Blaming the plan when the problem is the design. Each free plan has different limits — and your flow might blow one and not the other. If it blew up, the question is "how many steps and how many runs," not "which plan to buy." Redesigning is cheaper than subscribing to the paid plan.
Before blaming the plan, check: how many steps, how many runs, how many credits per run.
Before blaming the plan, check: how many steps, how many runs, how many credits per run.

Pro Tip: Before building any flow, do the math in 2 minutes: number of steps × runs per month. If the result exceeds 80% of the free plan's quota, the design needs to change — or the tool. This calculation is the difference between a service that pays for itself and one that eats the profit.

The 2-minute math: steps × runs = monthly cost. Do it before clicking 'create flow.'
The 2-minute math: steps × runs = monthly cost. Do it before clicking 'create flow.'

Practical Exercise

Take a workflow you've already built in Make — it can be Júlia's or one of your own. List all the modules, count the steps, and estimate how many times it runs per month. Calculate the cost in Make (steps × runs) and in n8n (1 execution per run). Compare with the free plan limits of each. You're done when you have a number in hand and can say which tool is cheaper for that specific workflow — and why.

Implementation Checklist

  • I can explain the difference between a workflow execution and a module call.
  • I can calculate the monthly cost of a workflow in both tools in under 5 minutes.
  • I can identify when a long, rare workflow should go to n8n and when a short, frequent one requires an account.
  • I know that some AI modules cost more than 1 credit and that I need to test to find out the real value.
  • I can defend to a client why the choice of tool changes the price of the service.

Chapter Summary

  • n8n charges per workflow execution, with unlimited steps inside it.
  • Make charges per module call: 1 operation = 1 credit, regardless of data size.
  • A 40-step workflow costs 1 execution in n8n and 40 credits in Make.
  • The rule of thumb: a long, infrequent workflow favors n8n; a short, very frequent one requires doing the math.
  • Now that you know what each tool counts, the next step is understanding where a workflow breaks — in chapter 2, "Anatomy of a workflow: trigger, steps, and the data that flows through."

---

Previews of similar courses

View all courses →
FAYAI