Make.com vs n8n for Beginners: Build an AI Automation You Can Sell (2026)
Most "Make vs n8n" posts compare feature lists you'll forget. This one is built around one real, sellable workflow — routing an inbound lead and drafting an AI follow-up email — built on both platforms, so the tool you pick is the tool that ships your first product. We'll do the honest cost math (operations vs executions), show copy-paste prompts, and be clear that this is a technical, mid-funnel decision. Figures are illustrative; nothing here guarantees income.
- The decision in one line: choose Make.com if you want a hosted, no-setup, visually friendly start today; choose n8n if you want lower cost at scale, more AI-native nodes, and code you can self-host and own.
- The cost difference that decides most cases: Make bills per operation (roughly per step), so a 10-step run can cost ~10 operations. n8n bills per execution (the whole run counts once), and self-hosted n8n has no execution cap. Many-step and AI-agent workflows get pricey faster on Make and stay flat on n8n.
- Rough 2026 pricing (verify — it changes): Make free ~1,000 credits/mo, Core ~$9–11/mo (~10k ops), Pro ~$16–19/mo. n8n Cloud from ~$24/mo (~2,500 executions); self-hosted Community Edition is free software on a ~$5–7/mo VPS (you run it). All figures approximate and vary.
- The centerpiece is a single sellable client workflow — inbound-lead routing + an AI-drafted, human-reviewed follow-up — built step-by-step on both tools, with the exact prompts and realistic outputs. The workflow is your first product.
- Honesty up front: this is a technical tool-decision topic, not a get-rich scheme. You can legally build client automations on both (with license limits on reselling n8n itself), but selling a service is hard — most earn little at first, a few do well. Not financial or legal advice; some links may be affiliate links.
What "Make.com vs n8n" Really Is — a Decision, Not a Religion
Let's be honest about where you are. If you're reading a Make-versus-n8n comparison, you're not at the very start of the side-hustle journey — you've already decided that building and selling automations is a path you want to explore, and now you're stuck on a tool choice. That makes this a mid-funnel, technical decision, and the worst thing a guide can do is turn it into tribalism. Both tools are good. The right one depends on your workflow's shape, your volume, your budget, and how much technical friction you'll tolerate.
Here's the honest framing that runs through this whole guide: Make.com is the hosted, beginner-friendly, fast-to-launch option that bills you per step. n8n is the more flexible, more AI-native, cheaper-at-scale option that you can self-host and own, but it asks more of you technically. That's the entire decision in two sentences. Everything below just makes it concrete by building the same real thing on both.
And we're going to keep the centerpiece practical: instead of comparing 30 features, we'll build one workflow a real small business will pay for — capturing an inbound lead, scoring it, drafting a follow-up email with AI, and logging it for the owner to approve and send. The point isn't the workflow's novelty; it's that by the end you'll have a working asset on whichever platform you chose, and a clear sense of which one fits how you want to work.
One more reality check before we spend your time: a tool decision is downstream of a business decision. Selling automation services is a legitimate model, but it's a service business with all the usual difficulty — finding clients, scoping, support. If you're not yet sure this is the right hustle for your skills and schedule, take the free HustleIQ quiz first; it matches you to one of 8 income models, including the tech-leaning ones this guide serves. Better to confirm the destination before you argue about the vehicle.
If your end goal is a full automation business, this guide is the "which tool" chapter. The "how do I get clients and run it" chapter is how to start an AI automation agency. If you want to build AI agents rather than linear automations, see how to build an AI agent with no code. And the workflow we build here needs somewhere for leads to come from — usually a simple site with a form.
The One Workflow You'll Build (and Sell): Inbound-Lead Routing + AI Follow-Up
We picked this on purpose. It's narrow enough to build in an afternoon, valuable enough that a real small business will pay for it, and it touches every concept that matters in both tools: a trigger, branching logic, an AI step, a human-review gate, and logging.
Imagine a small service business — a roofing contractor, a dental clinic, a bookkeeping firm. Leads come in through a website form, but nobody answers fast, hot leads go cold, and the owner has no record of who got followed up with. That lost-lead problem is worth real money to them, which is exactly why it's sellable. Here's the automation in plain language, tool-independent (write it like this before you open either platform):
TRIGGER: A new lead is submitted on the client's website contact form.
INPUT: name, email, phone, message, source (and budget, if asked)
STEP 1 — Capture & clean: Receive the form data via a webhook. Trim whitespace,
validate the email looks real, default any missing fields to "unknown".
STEP 2 — Score the lead: Ask an AI model to classify the lead as HOT / WARM / COLD
and give a one-line reason, using only the info provided (no guessing).
STEP 3 — Branch on score: If HOT -> notify the owner instantly (SMS/Slack/email) AND draft a reply.
If WARM -> draft a reply for the owner to review later.
If COLD -> log it; no urgent action.
STEP 4 — Draft the follow-up: Ask AI to write a short, friendly follow-up email DRAFT
tailored to the message. It is a draft only — a human approves before sending.
STEP 5 — Log everything: Append a row to the client's CRM or a Google Sheet:
timestamp, name, contact, score, reason, and the drafted email.
OUTPUT: The owner gets a notification for hot leads and a ready-to-send draft they
approve and send themselves. Nothing is sent automatically without review.Notice what this doesn't do: it never auto-sends an email to the lead, it never invents details about the lead or the business, and it never promises the client more revenue. Those three restraints are what make it safe to sell. The owner stays in control; AI just removes the blank-page and triage work. We'll build exactly this on Make first, then n8n, and the differences in how each handles it will make your tool choice obvious.
A working version of this is genuinely useful and genuinely sellable — but "sellable" is not "sold." Building the automation is the easy 20%; finding a client who'll pay, scoping it to their real tools, and supporting it is the other 80%. Treat this build as the product you demonstrate, not a guarantee of income. Most people who try selling automations earn little at first; a few who niche and persist do well.
The Honest Comparison Table
No winner-take-all verdict — each row tells you who that dimension favors. Read it as "which matters most to me," not "which tool is best overall." Prices are approximate and change constantly; always verify on the vendor's current pricing page.
| Dimension | Make.com | n8n |
|---|---|---|
| Beginner-friendliness | Higher. Hosted, colorful drag-and-drop, guided modules; many build their first scenario in a few hours. | Lower at first. Node canvas, expressions/JSON, optional server setup — steeper, but powerful once learned. |
| Hosting | Fully hosted by Make. Nothing to run or maintain. | Cloud (managed, paid) or self-hosted (free software, you run the server). |
| Billing unit | Per operation (~per step); now counted as credits since 2025. | Per execution (whole run = 1); self-hosted = unlimited. |
| Cost at low volume | Usually cheapest to start; free tier + ~$9–11/mo Core. | Cloud starts higher (~$24/mo); self-host adds setup effort. |
| Cost at high volume / many steps | Climbs fast — every step in every run costs. | Far cheaper; flat per run, and free if self-hosted. |
| AI-native depth | Good. AI modules; bring-your-own model API key (~1 op/call on paid plans). | Stronger for technical AI: native LangChain-style agent nodes, RAG building blocks, Code node. |
| Code / custom logic | Limited; some functions and a code module, but mostly no-code by design. | Full JavaScript/Python via the Code node; built for low-code. |
| App connectors | Very large library of polished pre-built apps. | Large and growing; plus generic HTTP for anything with an API. |
| Ownership / lock-in | You build on their platform; more lock-in. | Self-host = you own the data and the box; portable. |
| Selling client work | Build & deliver scenarios as a service (in the client's account or yours). | Building for clients allowed; reselling n8n itself as a hosted product needs a commercial license. |
| Best first pick if… | You want it working today with zero ops burden. | You'll run high volume, build AI agents, or want to own the stack. |
Pricing and feature details change often and vary by plan, region, and billing cycle — verify on make.com and n8n.io before deciding or quoting a client. "Operations" on Make are now metered as credits; standard steps are still ~1 credit each, while AI and code steps can cost more.
If you read only one row, read billing unit. That single difference — per step vs per run — is what drives almost every "which is cheaper" argument online, and it's why the next section does the actual math instead of hand-waving.
The Cost Math: Operations vs Executions (Worked, Not Hand-Waved)
This is the part most beginner guides skip. Let's put real numbers on our lead-routing workflow so you can predict the bill before you commit — and before you quote a client a hosting price.
Our workflow has, very roughly, ~7 billable steps per lead on a per-operation platform: receive webhook, clean data, AI score, a branch/router, AI draft, log to sheet/CRM, and a notification. (Your exact count will differ; this is illustrative.) Now watch how the two billing models treat 1,000 leads in a month.
MAKE.COM (per operation / credit)
1,000 leads x ~7 operations each = ~7,000 operations / month
Core plan includes ~10,000 ops -> fits in ~$9-11/mo (varies)
But add steps (enrichment, 2nd AI call) -> ops climb fast.
20,000 leads x 7 = 140,000 ops -> you're buying a much bigger plan.
Note: AI / code steps can cost MORE than 1 credit each. Verify current rates.
N8N (per execution)
1,000 leads x 1 execution each = 1,000 executions / month
Cloud Starter includes ~2,500 executions -> fits in ~$24/mo (varies)
Step count does NOT change the execution count: 7 steps or 70, still 1 run.
SELF-HOSTED Community Edition:
1,000 (or 100,000) executions = $0 in software
You pay only the server (~$5-7/mo VPS, varies) + your time to run it.Read the pattern, not just the numbers. At low volume and few steps, Make is often the cheapest and simplest place to start. The moment your workflows get many steps (especially multi-step AI agents) or your volume climbs, n8n's per-execution model — and especially free self-hosting — pulls dramatically ahead on cost. That's the real trade: Make charges you for convenience and per-step simplicity; n8n lets you trade your own operational effort for near-zero marginal cost.
- "Free" n8n isn't free to run. Self-hosting means you own the server, updates, backups, security, SSL, and uptime. A box that crashes at 2 a.m. during a client's busy season is your emergency. Many beginners rightly start on Make or n8n Cloud and only self-host once they're comfortable.
- AI calls cost money on top of either platform. Whether you use Make's AI modules or n8n's AI nodes, the model itself (OpenAI, Anthropic, etc.) bills you separately per token. On Make's paid plans you can often bring your own model API key for ~1 operation per call and pay the provider directly — usually cheaper than metered AI credits. Verify current rates on both.
When you quote a client, this math is also your pricing logic: a low-volume client is cheap to host on Make, so a small monthly retainer covers it; a high-volume client is where self-hosted n8n protects your margin. We'll come back to packaging and pricing in Step 7 — honestly, and without promising anyone a payday.
The 7-Step Build-and-Sell Workflow
Sequence matters: decide the workflow and the billing reality before you build, build it on your chosen tool, add the AI step safely, and only then think about packaging it. Each step is tool-aware but tool-agnostic where it can be.
Pick the one workflow you can actually sell
Beginners fail by trying to learn "automation" in the abstract. You learn far faster building one concrete thing a real business will pay for — and you finish with a sellable asset instead of a tutorial you forgot.
- Choose a narrow, painful, repetitive task a small business does by hand — lead follow-up, invoice reminders, review requests, appointment confirmations. We use inbound-lead routing + AI follow-up because it's universal and clearly valuable.
- Write the workflow in plain language first (trigger → steps → decisions → output), exactly like the block in the section above. This plan is tool-independent and is what you'll rebuild on either platform.
- Define the boundaries that keep it safe to sell: nothing auto-sends to the customer, AI never invents facts, and you make no revenue promise. Write these down — they're part of the deliverable.
- Sanity-check demand before building: would a business you can actually reach pay something for this? If you can't name one, pick a workflow closer to a niche you know.
You are a pragmatic automation consultant. I want to build ONE simple, sellable automation for a small [niche, e.g. roofing / dental / bookkeeping] business using a no-code/low-code tool. Propose 3 candidate workflows that are (a) genuinely painful and repetitive for that business, (b) buildable by a beginner, and (c) safe (no auto-sending to customers, no fabricated info). For each: the trigger, 4-6 plain-language steps, the human-review point, and one sentence on why a business would pay for it. Then recommend the single best one to build first and why. Do not promise income or results.- You can describe the workflow's trigger, steps, decision points, and output in plain language without opening any tool.
- You've written down its safety boundaries (no auto-send, no fabrication, no income promise) and can name at least one business that might pay for it.
Understand the billing models before you choose a tool
Picking the tool before understanding operations vs executions is how beginners get a surprise bill — or quote a client a hosting price that destroys their own margin. Five minutes of math here saves real money later.
- Internalize the one rule: Make = per operation (per step); n8n = per execution (per whole run), and free if self-hosted.
- Count the billable steps in your plain-language workflow. Multiply by your expected monthly volume. That's roughly your Make operation load; on n8n it's just your run count.
- Look up each tool's current plan that fits that load (don't trust a number from a 2024 blog — Make moved from "operations" to "credits" in 2025; verify). Note free-tier limits, included volume, and overage behavior.
- Flag the cost multipliers: extra AI calls, data enrichment, retries, and polling triggers all add operations on Make. On n8n they're "free" in execution terms but still cost AI/API money.
Act as a cost analyst for automation tools. My workflow has about [N] billable steps per run and I expect about [M] runs per month. Explain, in plain numbers, the rough monthly cost difference between a per-OPERATION billing model (like Make.com, where each step counts) and a per-EXECUTION model (like n8n, where the whole run counts once), plus a self-hosted option (free software, ~$5-7/mo server). Show the operation count and execution count side by side. Tell me at what volume self-hosting starts to clearly win. Remind me that AI model calls are billed separately and that I must verify current vendor pricing rather than trust your numbers.- You can state your workflow's approximate monthly operation count (Make) and execution count (n8n) from real volume estimates.
- You've checked each tool's current pricing page yourself and know which plan your load fits today.
Choose your lane: Make for speed, n8n for scale and ownership
The right first tool isn't the "best" tool — it's the one that matches your volume, budget, technical comfort, and whether you value zero-setup convenience or long-term cost and control. Choosing on fit, not hype, keeps you moving.
- Lean Make if: you're new and want a working automation today, you don't want to manage a server, your volume/step-count is modest, and the polished hosted experience is worth a per-step price.
- Lean n8n Cloud if: you want n8n's flexibility and AI-native nodes but still don't want to run a server — you pay per execution, not per step, and skip the ops burden.
- Lean self-hosted n8n if: you'll run high volume or many-step AI workflows, you're comfortable (or willing to learn) running a small server, and you want the lowest marginal cost and full ownership.
- Don't agonize. Many builders deliberately learn on Make (concepts click faster) and migrate high-volume workflows to self-hosted n8n later. The skills transfer; rebuilding is a few hours, not a few weeks.
- Try your real workflow's first two steps in your chosen tool within 30 minutes. If it's a fight at step one, the other lane may suit you better.
Act as a pragmatic technical advisor for a non-expert building their first sellable automation. Recommend Make.com, n8n Cloud, or self-hosted n8n based on my answers, with a one-line reason and one caveat each. My answers: technical comfort = [none / a little / comfortable with data & servers]; want to manage a server? [no / willing to learn / yes]; expected volume = [low / medium / high]; steps per workflow = [few / many]; budget priority = [lowest setup friction / lowest cost at scale]; do I need heavy AI-agent logic? [yes/no]. End with the single best FIRST choice for me and what would make me switch later. Tell me to verify current pricing; do not promise income.- You've named one primary tool and one fallback, each tied to a specific answer about your volume, budget, and comfort.
- A 30-minute test in your chosen tool got the first step or two working without a wall.
Build the workflow on Make (the fast, hosted path)
Make's visual scenario builder is the gentlest on-ramp: you see data flow between modules, and there's nothing to install. Building here first — even if you'll later move to n8n — teaches the concepts quickly.
- Create a new scenario. Add a Webhook trigger ("Custom webhook"); copy its URL into your website form (or a test tool) so submissions arrive as structured data.
- Add a module to clean the data (a "Set variables" or "Tools" step): trim fields, default missing ones to "unknown". Map the webhook fields by clicking, not typing.
- Add an AI module (OpenAI/Anthropic, or your own key) to score the lead HOT/WARM/COLD with a one-line reason. Paste the scoring prompt from Example 2.
- Add a Router to branch on the score: a HOT path that sends an instant notification, plus a path that drafts the email.
- Add a second AI module for the follow-up draft, then a Google Sheets/CRM "Add a row" module to log everything. Run once with test data and watch each module's operation count tick up — that's your live cost meter.
I'm building a lead-routing automation in Make.com as a beginner. My workflow: webhook receives a website lead (name, email, phone, message) -> clean the data -> AI scores it HOT/WARM/COLD with a reason -> Router branches on score -> AI drafts a follow-up email (draft only, never sent automatically) -> log a row to Google Sheets. List the exact Make modules in order, what each one does, which fields to map between them, and where operations get consumed so I can estimate cost. Flag the 3 places a beginner most often makes a mistake in Make and how to avoid them. Tell me what to TEST after building before I trust it.- A test lead flows end-to-end: it's scored, branched, an email draft is produced, and a row appears in your sheet/CRM.
- You've watched the operation count for one run and can estimate the monthly cost at your expected volume.
Build the same workflow on n8n (the flexible, ownable path)
Building the identical logic in n8n shows you the real trade in your own hands: a steeper canvas and (if self-hosting) some setup, in exchange for per-run billing, AI-native nodes, and code you own. Now your choice is informed, not theoretical.
- Start on n8n Cloud (or a 14-day trial) to skip server setup for your first build; move to self-hosting later if cost or ownership justifies it. Self-hosting means a small VPS, Docker, and SSL — doable, but it's real ops work.
- Add a Webhook node as the trigger; point your form/test tool at its URL. Note n8n shows you the raw incoming JSON, which is great for learning but more exposed than Make.
- Use a Set (or Edit Fields) node to clean/normalize, then an AI/LLM node (n8n's AI nodes or the OpenAI/Anthropic node) for scoring. n8n's AI-agent and LangChain-style nodes shine if you later add memory or tools.
- Add an IF / Switch node to branch on the score, a second AI node for the follow-up draft, and a Google Sheets (or HTTP-to-CRM) node to log. The whole run counts as one execution no matter how many nodes — feel the difference from Make.
- If a step needs custom logic Make couldn't do, use the Code node (JavaScript/Python). Have AI write it, then read and test it — never ship code you don't understand.
I'm rebuilding a lead-routing automation in n8n as a beginner (starting on n8n Cloud). Same logic: Webhook receives a lead -> clean fields -> AI scores HOT/WARM/COLD with a reason -> IF/Switch branches on score -> AI drafts a follow-up email (draft only) -> log a row to Google Sheets. List the exact n8n nodes in order, what each does, and how data passes between them via expressions. Explain clearly that the entire run is ONE execution regardless of node count. Point out where n8n is harder than Make for a beginner (expressions, JSON, OAuth/credentials, self-hosting) and how to get past each. Tell me what to TEST before trusting it. Don't promise results.- The same test lead flows end-to-end in n8n and you've confirmed the whole run registers as a single execution.
- You can articulate, from experience, where n8n was harder and where it was more flexible than Make — enough to decide your real first tool.
Add the AI follow-up draft with a safe, reviewed prompt
The AI step is where value and risk concentrate. A sloppy prompt invents facts, over-promises, or auto-sends embarrassing email. A disciplined prompt produces a useful draft a human approves — which is exactly what makes the whole thing safe to sell.
- Structure the prompt with explicit rules: draft only, never send; use only the facts provided; insert
[VERIFY]where it lacks information rather than guessing; make no promises about price, timeline, or results. - Give the model the lead's real message and the business's true details (services, hours, booking link) so the draft is specific — but feed it only verified facts, never invented ones.
- Keep the draft short, friendly, and human — a starting point the owner edits in seconds, not a wall of AI text. Two or three sentences plus a clear next step.
- Route the output to a human-review gate: the draft lands in the owner's inbox/Slack/sheet for approval. The automation's job ends at "ready to send," not "sent."
- Consider connecting your own model API key (OpenAI/Anthropic) so you control cost and model choice — on Make this is often ~1 operation per call; verify current rates on both tools.
You are a lead-qualification assistant for a small [niche] business. Classify the lead below as HOT, WARM, or COLD and give ONE short reason, using ONLY the information provided. Do not guess or invent details. HOT = clear, urgent, in-scope request with contact info. WARM = interested but vague or not urgent. COLD = spam, out of scope, or no real intent. Respond as strict JSON only: {"score":"HOT|WARM|COLD","reason":"one short sentence"}. Lead: name={{name}}, email={{email}}, phone={{phone}}, message="{{message}}".You are drafting a follow-up email for the OWNER of a small [niche] business to review and send. This is a DRAFT ONLY — it will never be sent without human approval. Rules: use only the facts I provide; if a needed detail is missing, write [VERIFY] instead of inventing it; make NO promises about price, timeline, guarantees, or results; keep it warm, plain, and under 90 words with one clear next step (e.g. book a call). Business facts (verified): services=[list], hours=[hours], booking link=[link]. Lead's message: "{{message}}". Lead's name: {{name}}. Output just the email body, no subject line, no preamble.- The AI produces a usable draft that contains no invented facts and no promises, with
[VERIFY]wherever information was missing. - Nothing sends to the lead automatically — every draft passes through a human-approval step you can point to in a demo.
Package, price, and deliver it as a service (honestly)
A working automation isn't a business until someone pays for it and you can support it. This step turns your build into a clean, deliverable, license-compliant offer — without pretending it's a guaranteed income stream.
- Decide the delivery model: build it in the client's own account (they pay the tool, you charge for setup) or run it for them as a managed service (you host on Make or self-hosted n8n and charge a retainer). The second is where n8n's free self-hosting protects your margin at volume.
- Price as a one-time setup fee + optional monthly maintenance/hosting retainer. Actual figures vary enormously by market, scope, and your track record — treat any number you see online as illustrative, not a rate card. Charge for the outcome (handled leads), not the hours.
- Respect the licenses. Make: you're building on their hosted platform as a service — fine. n8n: building client workflows is generally allowed, but reselling n8n itself as a hosted product, or hosting it as a service for external users, needs a commercial license — get one if that's your model. This is general info, not legal advice; verify each tool's current terms.
- Document the handoff: a plain-language description of the workflow, the prompts, where credentials live, what to do if it breaks, and the human-review step. Documentation is part of what they're paying for.
- Frame results honestly with the client: the automation saves time and reduces dropped leads — it does not guarantee more revenue. Under-promise. Reliability and honesty are how you get the repeat clients that actually make this model work.
Act as an honest advisor for a solo automation builder. I built a lead-routing + AI-follow-up automation (Make or n8n). Help me package it as a service: (1) two delivery options (build in the client's account vs. managed/hosted by me) with the trade-offs of each; (2) a simple, honest pricing structure (one-time setup + optional monthly) framed around the client's outcome, making clear that real rates vary and I should not over-promise; (3) a short handoff/documentation checklist; (4) the licensing points I must respect, especially that reselling/hosting n8n itself as a product for external users may require a commercial license (general info, not legal advice). Do NOT invent specific dollar figures as if they're guaranteed; keep all earnings framing illustrative.- You can explain your delivery model, pricing logic, and handoff in one page — and you've confirmed your model complies with each tool's current license.
- Your client-facing framing promises time saved and fewer dropped leads, with zero income or revenue guarantees.
Worked Build: the Same Automation on Both Tools
One running build — the inbound-lead router — shown as real prompts, realistic outputs, and before/after pairs. Treat every AI-produced field as a placeholder to verify. The value is in your edits and your testing, not the generator.
Turn a vague idea into a tool-independent workflow spec
Plan the automation in plain language before opening Make or n8n, so you can build the same thing in either and quote it accurately.
You are an automation architect. Turn this idea into a precise, tool-independent spec: "When a roofing company gets a website lead, score it, draft a follow-up email, and log it for the owner." Output: (1) the trigger; (2) an ordered list of 5-7 steps in plain language; (3) every decision/branch; (4) the exact human-review point; (5) the inputs and outputs. Add a one-line note on which steps consume an AI call. Keep it neutral between Make and n8n.TRIGGER: New website-form lead (webhook).
INPUTS: name, email, phone, message, source.
1. Receive & clean the lead data (trim, default missing -> "unknown").
2. [AI] Score lead HOT/WARM/COLD with a one-line reason (JSON out).
3. BRANCH on score: HOT -> notify owner now + draft; WARM -> draft only; COLD -> log only.
4. [AI] Draft a short follow-up email (DRAFT ONLY, never auto-sent).
5. Log to CRM/Sheet: time, name, contact, score, reason, draft.
6. HUMAN REVIEW: owner approves/edits the draft, then sends it themselves.
OUTPUT: Owner notified on hot leads + a ready-to-send draft per qualified lead.
AI calls: steps 2 and 4.Takeaway: A neutral spec is the asset that survives your tool choice. Build it once in plain language and you can implement it in Make, n8n, or anything else — and you'll never confuse the client with tool jargon.
Build it in Make: modules, mapping, and the operation count
See the same spec realized as Make modules — and watch where operations (your cost) get consumed on a single run.
List the Make.com scenario for the spec above as an ordered module list. For each module: its name, its job, and the key field mappings from the previous module. Then estimate how many operations ONE run consumes and where. Keep it beginner-friendly.1. Webhooks > Custom webhook — receives lead JSON (1 op)
2. Tools > Set multiple variables — clean/default fields (1 op)
3. OpenAI/Anthropic > Create completion — score lead (JSON out) (1 op*)
4. Flow > Router — branch on {{3.score}} (0 op)
|- HOT path: Slack/Email > send notification to owner (1 op)
5. OpenAI/Anthropic > Create completion — draft follow-up email (1 op*)
6. Google Sheets > Add a row — log time/name/score/draft (1 op)
Approx total: ~6 ops per HOT lead (fewer for COLD).
*AI modules may cost more than 1 credit, or ~1 op if you use your own API key — verify.Takeaway: In Make, you can literally count your cost per run by counting modules that fire. That transparency is great for quoting — multiply ops-per-run by monthly volume and check it against your plan's included operations before you promise a client a hosting price.
Build it in n8n: nodes, expressions, one execution
The identical logic in n8n — note how the whole run is a single execution no matter how many nodes fire.
List the n8n workflow for the same spec as an ordered node list. For each node: its name, its job, and how data passes in via an expression (show one real expression example). Then state clearly how many EXECUTIONS one run consumes. Note where a beginner hits friction vs Make.1. Webhook node — receives lead JSON at a URL
2. Edit Fields (Set) — clean fields; e.g. {{ $json.message.trim() }}
3. AI/OpenAI node — score lead; prompt reads {{ $json.message }}
4. Switch node — route on {{ $json.score }} (HOT/WARM/COLD)
|- HOT: Slack node — notify owner
5. AI/OpenAI node — draft follow-up email (draft only)
6. Google Sheets node — append row with all fields
EXECUTIONS PER RUN: 1 (six nodes, still ONE execution).
Beginner friction vs Make: expressions use {{ }} + JS-ish syntax; you map by
referencing $json paths, not point-and-click; credentials/OAuth setup is more
manual; self-hosting adds server + SSL work. Upside: 1 execution, not ~6 ops.Takeaway: Same six steps, but n8n charges for one execution where Make charged for ~six operations. That gap is the whole pricing argument — small at low volume, decisive at scale. The cost of n8n's edge is the expression/JSON learning curve you just felt.
The AI scoring step: real input, real JSON output
Feed the scoring prompt a realistic lead and see the structured output your branch will read — identical on both tools.
name: Dana Okafor
email: [email protected]
phone: (varies — none given)
message: "Half my garage roof is leaking after last week's storm and I need
someone out this week if possible. Roughly what does a repair like that run?"{
"score": "HOT",
"reason": "Urgent storm-damage repair with a clear timeframe and a price question; high buying intent."
}Takeaway: Forcing JSON output makes the AI step reliable to branch on — your Router/Switch reads score directly. Always handle the case where the model returns malformed JSON (add a fallback to WARM and log it), because models occasionally break format.
The follow-up draft: generic AI output vs. a guarded prompt
The naive prompt over-promises and invents specifics. The guarded prompt produces a safe, human-reviewable draft.
Subject: We'll Fix Your Roof Fast — Guaranteed!
Hi Dana, thanks for reaching out! We can absolutely have your roof repaired
by tomorrow, and a job like yours typically runs $450. We guarantee the
lowest price in town and a lifetime warranty. Book now and save 20%!Hi Dana, thanks for reaching out about the storm damage to your garage roof.
We can usually get someone out for an assessment this week — does a morning
or afternoon work better for you? After we see it in person, we'll give you a
clear written quote. You can grab a time here: [VERIFY: booking link].The naive draft invented a price ($450), invented a timeline ("by tomorrow"),
and made guarantees (lowest price, lifetime warranty, 20% off) the owner never
authorized — each is a liability and a trust-killer. The guarded draft promises
nothing it can't keep, asks a question to move the lead forward, and flags the
missing booking link with [VERIFY] instead of guessing. A human approves it in
seconds.Takeaway: The difference between a dangerous automation and a sellable one is entirely in the prompt's guardrails. "Draft only, no invented facts, no promises, [VERIFY] for gaps" is the rule that keeps you and your client safe.
Side-by-side cost at three volumes
Make the abstract concrete: how the same ~6-step workflow bills on each tool as volume grows. Figures are illustrative and vary — verify current pricing.
Volume Make (per op, ~6 ops/lead) n8n (per execution / self-host)
----------- -------------------------------- --------------------------------
100 leads ~600 ops -> free/Core tier 100 exec -> Cloud Starter, or $0 self-host
1,000 leads ~6,000 ops -> fits ~$9-11 Core 1,000 exec -> ~$24 Cloud, or $0 self-host*
10,000 leads ~60,000 ops -> larger paid plan 10,000 exec -> higher Cloud tier, or $0 self-host*
50,000 leads ~300,000 ops -> much larger plan 50,000 exec -> self-host clearly wins on cost*
*Self-hosted n8n software is free; you still pay ~$5-7/mo for a server (varies)
plus your time to run/update/secure it. AI model calls bill separately on BOTH.Takeaway: Low volume: Make is simplest and cheapest to start. High volume or many steps: self-hosted n8n wins decisively on marginal cost — that's the lever that protects your margin when you're charging a client a flat retainer. Pick the tool that matches where this client actually sits.
Make it client-ready: error handling and a test plan
A demo that works once isn't sellable. Add the unglamorous reliability work that separates a hobby flow from a service.
Act as a reliability reviewer. For my lead-routing automation (webhook -> clean -> AI score -> branch -> AI draft -> log), list the realistic failure points and a simple safeguard for each, suitable for a beginner on [Make / n8n]: malformed/empty form data, the AI returning non-JSON or no score, the AI service timing out, a duplicate submission, and the logging step failing. Then give me a concrete pre-handoff TEST checklist (good lead, spam lead, missing fields, AI down) with the expected result for each. Keep it practical.Failure points & safeguards:
- Empty/malformed form data -> validate early; if invalid, log + stop (no AI call wasted).
- AI returns non-JSON/no score -> default to WARM, flag for manual review, log raw output.
- AI times out -> add a retry/timeout; on fail, route to "needs human" path.
- Duplicate submission -> de-dupe on email+timestamp before logging.
- Logging step fails -> capture the error; alert yourself so no lead is silently lost.
Pre-handoff test checklist (expected result):
[ ] Good HOT lead -> scored HOT, owner notified, draft created, row logged.
[ ] Spam/COLD lead -> scored COLD, logged, no notification, no draft sent.
[ ] Missing phone -> defaults to "unknown", still completes, no crash.
[ ] AI service down -> routes to "needs human", lead still logged, you're alerted.Takeaway: Clients pay for reliability, not cleverness. Handling the ugly cases — bad data, AI hiccups, duplicates — and shipping a test checklist is what justifies a maintenance retainer and earns the repeat work that makes this model viable.
The client handoff doc (what they're really paying for)
Turn your build into a one-page document the client (or future-you) can actually use and trust.
Write a concise, plain-English handoff document for a small-business client for the lead-routing automation I built on [Make / n8n]. Sections: (1) What it does, in one paragraph, no jargon; (2) the human-review step and why nothing is auto-sent to leads; (3) where their data is stored and which accounts/credentials are involved; (4) what to do if it stops working (who to contact, basic checks); (5) an honest note that it saves time and reduces dropped leads but does not guarantee more revenue; (6) any monthly costs (tool plan, AI usage) they should expect. Keep it under one page and reassuring, not technical.What it does: Every time someone fills out your website form, this system reads
the message, flags how urgent it looks, drafts a friendly reply for you to review,
and records the lead in your spreadsheet so none slip through.
You stay in control: No email is ever sent to a lead automatically. You get a
draft and a heads-up on urgent leads; you read, edit if needed, and send it.
If it stops working: Check that your form is live and the spreadsheet is shared.
If leads aren't appearing, contact [you] at [contact]. Most issues are a changed
password or a tool update and take minutes to fix.
Honest note: This saves you time and helps you catch leads faster. It does not
guarantee more sales — that depends on your follow-up and pricing.
Monthly costs to expect: ~[tool plan] for the automation tool and a small amount
for AI usage (varies with volume).Takeaway: The handoff doc is half the deliverable. It sets honest expectations (time saved, not guaranteed revenue), documents the human-review safety, and makes you look like a professional — which is what turns one project into a referral.
The Supporting Tool Stack (With Hedged Pricing)
You only need the automation platform plus a couple of connected services to ship the workflow. Free tiers exist throughout; prices change constantly, so treat every figure as approximate and verify on the vendor's current pricing page. Any affiliate links are disclosed.
The two automation platforms (pick your lane)
Hosted, visual, beginner-friendly; bills per operation (per step). Fastest path to a working automation today.
Flexible, AI-native, bills per execution (whole run = 1). No server to manage on the Cloud tier.
Free, fair-code software with unlimited executions; you run it. Lowest marginal cost at scale; you own the data.
The AI model (the brain of the scoring + drafting steps)
Powers the lead scoring and the email draft. Bring your own API key into Make or n8n to control cost and model choice.
Make's AI modules and n8n's AI/agent nodes if you'd rather not manage an external key.
Where leads come from and go (the connected services)
The trigger: a contact form, Typeform, or any form that can POST to a webhook. Build the form fast with AI if you don't have one.
The log: every lead, score, reason, and draft in one place the owner can see. A sheet is the zero-friction start.
The "hot lead now" alert so the owner acts fast. Slack and email are easiest; SMS adds per-message cost.
If you're building this as a business
A credible one-page site and a booking link to demo and sell your service. Build it with AI in an afternoon.
Take the setup fee and any monthly retainer. Per-sale fees, no fixed cost to start.
Common Mistakes Beginners Make With Make and n8n
These are the avoidable errors that turn a promising first automation into a stalled project — or an embarrassing client incident. Each one is cheap to prevent.
- Choosing the tool before counting the steps and volume. Picking n8n for a tiny low-volume flow adds needless complexity; picking Make for a high-volume many-step agent invites a surprise bill.
Fix: count your billable steps and monthly runs first (the cost math), then choose. The workflow's shape decides the tool, not the other way around. - Treating "free" self-hosted n8n as free to operate. The software is free; the server, updates, security, and 2 a.m. uptime are your job.
Fix: if you're new, start on Make or n8n Cloud and only self-host once volume justifies the ops work — and price that effort into any client retainer. - Letting AI auto-send to customers. The fastest way to embarrass a client is an unreviewed AI email going straight to a lead with a made-up price or promise.
Fix: always route AI output through a human-review gate. The automation ends at "draft ready," never "sent." Make this a selling point, not a hidden risk. - Shipping prompts with no guardrails. A bare "write a follow-up email" prompt invents prices, timelines, and guarantees you'll have to honor.
Fix: use the guarded prompt pattern — draft only, facts provided only,[VERIFY]for gaps, no promises. See the before/after. - Ignoring error handling because the demo worked once. Real form data is messy: empty fields, duplicates, AI returning broken JSON, the model timing out.
Fix: add validation, fallbacks, retries, and a "needs human" path before handing it over (the reliability pass). Reliability is what you're actually paid for. - Quoting a client a hosting price you didn't math out. You promise a flat monthly fee, then the tool bill balloons with volume and eats your margin.
Fix: calculate ops/executions at the client's real volume, build in headroom, and use self-hosted n8n for high-volume clients to protect margin. - Misreading the n8n license. Building client workflows is generally fine, but hosting n8n as a service for external users or reselling it as a product is different — and needs a commercial license.
Fix: read each tool's current terms, and get a commercial agreement if your model is "host n8n and charge users." General info, not legal advice. - Promising results instead of time saved. "This will double your leads" is a promise you can't keep and shouldn't make.
Fix: sell the honest benefit — faster response, fewer dropped leads, less manual triage. Outcomes vary; under-promising is how you keep clients. If you're unsure this hustle fits you at all, take the free quiz first.
Frequently Asked Questions
Make.com vs n8n: which is better for a complete beginner?
For a complete beginner who wants to launch fast, Make.com is usually the gentler start: it's fully hosted, the drag-and-drop scenario builder shows data flowing between modules visually, and many people build a working automation in a few hours with no server to manage. n8n is more powerful and cheaper at scale, but its node-based canvas, expressions, and (if you self-host) the server setup add a steeper learning curve. A common path is to learn the concepts on Make, then move to n8n once cost or AI complexity justifies it. Neither choice guarantees you'll earn money — that depends on the offer and the client.
What is the real difference between Make operations and n8n executions?
It's the single biggest cost difference. Make bills per operation: roughly every individual step a module performs consumes at least one operation (now counted as a credit), so a 10-step workflow that runs once can cost about 10 operations. n8n bills per execution: one complete run of a workflow from trigger to finish counts as a single execution no matter how many steps it contains, and self-hosted n8n has no execution cap at all. That means workflows with many steps — especially multi-step AI agents — tend to get expensive faster on Make and stay flat on n8n. Always verify current billing units on each tool's pricing page, since Make moved from "operations" to "credits" in 2025.
How much do Make.com and n8n cost in 2026?
Prices change often, so treat these as approximate and verify on each vendor's page. Make has a free tier (~1,000 credits/month, ~2 active scenarios, ~15-minute minimum interval), a Core plan around ~$9–11/month for ~10,000 operations, and a Pro plan around ~$16–19/month that adds priority execution and log search (varies; annual billing tends to save ~15%). n8n Cloud starts around ~$24/month for ~2,500 executions, with a Pro tier around ~$60/month for ~10,000 executions (varies). n8n's self-hosted Community Edition is free software with unlimited executions — you only pay for a server, often a ~$5–7/month VPS (varies). At low volume Make is cheapest; at high step-count or volume, self-hosted n8n is usually far cheaper.
Can I legally sell automations I build with Make.com or n8n?
Generally yes for building client automations as a service, but the details differ and this is not legal advice — read each tool's current terms. With Make, you build on their hosted platform and typically deliver the scenario in the client's own Make account or run it in yours as a service. With n8n, the Sustainable Use License generally allows you to build workflows for clients' internal business use and to offer consulting around it, but it restricts reselling n8n itself as a product, hosting n8n as a service for external users, or embedding it as the core engine of a customer-facing SaaS — those need a commercial agreement. If your business model is "host n8n and charge users to access it," get a commercial license. When in doubt, confirm with each vendor and a professional.
Do I need to know how to code to use Make.com or n8n?
No for basic automations on either. Make is true no-code: you connect modules visually and map fields with a point-and-click interface. n8n is low-code: you can build a lot by connecting nodes, but you'll hit expressions, JSON, and sometimes a Code node (JavaScript or Python) sooner, which is part of why it's more flexible. For the sellable lead-routing workflow in this guide, neither requires real programming — but n8n rewards a little comfort with data and JSON, while Make hides more of that complexity. AI assistants can help you write any expressions or code you do need, but always test the output.
Is n8n free? What's the catch with self-hosting?
The n8n Community Edition is free, open-and-fair-code software you can self-host with unlimited workflows and executions — but "free software" isn't "free to run." You supply and maintain the server (often a ~$5–7/month VPS, varies), handle updates, backups, security, SSL, and uptime yourself, and you don't get the official cloud's managed reliability or some enterprise-only features. For a beginner, that operational burden is the real catch: a self-hosted box that goes down at 2 a.m. is your problem. Many people start on n8n Cloud's paid tier to skip ops, or use Make's hosting, and only self-host once they're comfortable. The license also restricts reselling n8n itself as a hosted product.
Which is better for AI agents and AI workflows, Make or n8n?
Both can call AI models, but n8n is generally the more AI-native of the two for technical builders: it has native LangChain-style AI/agent nodes, RAG pipeline building blocks, and a Code node for custom logic, and its per-execution billing means a multi-step AI agent run doesn't multiply your cost the way per-operation billing can. Make is very capable for AI too — and on paid plans you can connect your own OpenAI or Anthropic API key for roughly one operation per call, paying the model provider directly — but heavy multi-step agent loops add up faster under operation-based billing. If your sellable product is simple AI drafting inside a short workflow, either is fine; if it's a complex multi-step agent, n8n's model usually scales better. Verify current AI pricing on both, since it changes.
How long does it take to build the lead-routing automation in this guide?
On Make, a beginner can often get a first working version of this inbound-lead-routing-plus-AI-follow-up workflow running in roughly an afternoon, because there's no server to set up and the modules are guided. On n8n Cloud the build is similar once you're oriented; self-hosting n8n first adds setup time (provisioning a server, Docker, SSL) that can turn an afternoon into a day or more for a first-timer. Add testing, edge cases, and making it client-ready, and a polished, sellable version is realistically a few focused sessions either way. Times vary widely with your experience and how clean the client's tools are.
How much can I charge for an automation I build, and will I actually make money?
It varies enormously and nothing here is a promise. Solo builders commonly price simple automations as a one-time setup fee plus an optional monthly maintenance or hosting retainer, with figures that range widely by market, scope, and your track record — treat any number as illustrative, not a guarantee. The honest reality of selling automation services is the same as any service business: most people who try it earn little, especially at first, and a smaller number who niche down, deliver reliably, and find repeat clients do well. The automation in this guide is a starting product to learn and demonstrate value, not an income guarantee. If you're weighing whether this path even fits you, the free HustleIQ quiz can match your skills, time, and budget to one of 8 income models.
Make.com vs Zapier vs n8n — where does each fit?
Roughly: Zapier is the most beginner-friendly and has the broadest app library but is typically the most expensive at volume and the least flexible for complex logic; Make sits in the middle — visual, hosted, far more flexible than Zapier, billed per operation; n8n is the most flexible and cheapest at scale (especially self-hosted) and the most AI-native, but it asks the most of you technically. For a brand-new builder validating an idea, Zapier or Make get you live fastest; for a repeatable, cost-controlled automation business, many builders graduate to n8n. This guide focuses on Make vs n8n because that's the decision most aspiring automation builders actually face. Pricing and features change, so verify current details.
Can I switch from Make to n8n later, or am I locked in?
You're not locked in conceptually — the same logical workflow (trigger, AI step, review, log) can be rebuilt on either tool — but there's no clean one-click export that converts a Make scenario into an n8n workflow, so "switching" means rebuilding. The good news is that the skills transfer: webhooks, field mapping, branching, and AI prompts are the same ideas in both. To keep your options open, document each automation's logic in plain language (trigger, steps, decisions, outputs) independent of the tool, store your prompts and credentials separately, and avoid hard-coding tool-specific quirks. Many builders deliberately learn on Make and migrate the highest-volume workflows to self-hosted n8n to cut cost.
Pick One, Ship One — the Tool Matters Less Than the Build
Here's the truth that outlasts any pricing table: the people who succeed at this don't win the Make-vs-n8n argument — they ship one working automation and find one client who values it. Make.com gets you there fastest with zero setup and per-step billing; n8n gets you lower cost at scale, more AI-native power, and code you own, at the price of a steeper curve. Both are genuinely good. Choose the one that fits this workflow's volume and your tolerance for technical setup, then build the lead router and stop deliberating.
And keep the honesty front and center: this is a real service business. The automation is the easy part; the client work, the reliability, and the support are where the money — when there is money — actually comes from. Most people who try selling automations earn little at first; a few who niche down and deliver consistently do well. Sell time saved and fewer dropped leads, never guaranteed revenue.
Natural next moves: if you want to turn this one workflow into an actual business, read how to start an AI automation agency. If you'd rather build smarter AI agents than linear flows, see how to build an AI agent with no code. And since this workflow needs leads coming in, build a simple site with a form to feed it. For the full business picture, start with how to build an online business with AI.