n8n course from A to Z: 8 automation workflows with straight advice

The ninth course in MONA's free AI course series: n8n from A to Z, built on a syllabus of over 8 hours that teaches how to build 8 real automation systems, from a personalized sales email writer to a machine that recycles content for social media posting. Before we start, we state our view plainly, as we promised you at the beginning of the series: n8n suits small scale or testing software ideas; for large scale, the live operations of a business, you should look into writing complete software. Drag-and-drop tools build fast and look intuitive, but a long chain of nodes is a chain of breaking points: one node failing in the middle of the night stops the entire pipeline, and in this course you'll see both the strength and the breakdowns with your own eyes (we've kept the stumbles in the middle instead of cutting them for polish, because that's where you learn the most). Learning n8n is still very worthwhile: it's the cheapest way to understand automation thinking, test which processes are worth automating, and serve your own light needs; its place relative to agentic workflows and custom software is mapped out in full at the end of the article.

Part 1: What n8n is, what it costs, and where it sits on the automation map

n8n is a drag-and-drop automation platform: you connect node (each node does one job: read a Google Sheet, call AI, send Gmail) into a pipeline, with a trigger at the head (a form is filled, an email arrives, an appointment time hits, a webhook is called) and the whole chain runs. Its strengths over similar tools (Make, Zapier): open source, self-hostable, and strong built-in AI nodes, with over 500 integrations.

Money first, to make things easy: the official cloud entry plan is 20 euros a month (billed annually, 2,500 executions), the Pro plan is 50 euros (10,000 executions), and business plans go higher; or self-host for free with the open-source version, in exchange for handling operations yourself and a much fiddlier Google account connection (you have to create OAuth yourself in Google Cloud Console instead of clicking one button). For beginners: stick with the cloud version for peace of mind and do the math later.

As for its place: after two courses vibe coding and agentic workflow, you already know the world of “AI plus code.” n8n is the third world: workflows drawn by eye. Its biggest gain isn't really technical, but communication: a node diagram shows at a glance how the process runs, and you can bring it into a room where everyone can weigh in: something a pile of code can't do for non-specialists. Its biggest loss, you'll see gradually across the eight pipelines: everything has to be clicked by hand, tested by hand, and fixed by hand when it breaks.

Part 2: The foundations you must know: expressions, and n8n's classic “array of objects” trap

The first two hours of the syllabus go entirely to foundations, and here is the bare bones of it:

• Every input field has two modes: Fixed and Expression. Fixed is a dead value; Expression lets you insert dynamic variables and even short bits of code. The syllabus's advice: always use Expression, because it can do everything Fixed can. Insert a variable by dragging a field from the previous node's result, which comes out as {{ $json.tenTruong }}; to pull data from a node more than one step back, use {{ $('Node Name').item.json.fieldName }}: this is the syntax that stumps you for a whole session if you don't know it.
• The number one classic trap: all data flowing between nodes is an “array of objects”: a list of data packets, not a single packet. Beginners die here most often: thinking you're processing one customer while the node is running on 50, or the reverse. The cure: always view node results in JSON form until it feels familiar, and name columns without accents or spaces (a name with spaces has to be accessed with square brackets, adding another layer of fiddliness).
• Credentials: each service (Google, OpenAI, Gmail) is connected once with an account, and nodes share it. A resource's ID (spreadsheet, document) is almost always right in its link: a small tip that saves hunting around.

Part 3: The working nodes: HTTP Request, webhook, and the AI nodes

• HTTP Request is the all-purpose node: call any API, scrape any web page. The most valuable tip in the syllabus: big services all have a “copy cURL” button in their API docs: paste the whole chunk into n8n and the node configures itself, with no filling in each field by hand. For scraping web pages, add an HTML Extract node (filter by tag) and HTML to Markdown (compress content to save tokens before handing it to the AI to read).
• Webhook is the doorbell: one link, and when an outside service calls it the pipeline runs. Remember two things: there are separate Test URL and Production URL (forgetting to switch is the classic “why isn't it running”), and a service that sends via POST needs a node that catches POST.
• Node AI comes in two forms. The “Message a Model” form (call the model once, get a JSON result) is used most in the course, with an unchanging template: the system prompt sets the role, the user prompt gives the order plus rules (“concise, economical tone,” “don't leave any field empty,” “write n for line breaks instead of real line breaks”: that last rule guards against the classic JSON error), switch on JSON output mode, and use a low temperature around 0.6 for stability. The second form is node AI Agent: attach a model + conversation memory + tools (Calendar, Gmail, spreadsheets), with a syntax for $fromAI() letting the AI fill in parameters itself. The syllabus's experience matches our view: agents in business should be simple, more than 6-7 tools on one agent is a signal to split, and those pretty “agent calling five layers of agents” demos online are unstable and hard to sell to real customers.

Part 4: The flow-control nodes, and the testing habits of the pros

Six flow-control nodes carry the whole n8n world: If (split into two branches), Filter (keep or drop), Merge (merge branches), Split Out (unpack an array into separate packets), Loop Over Items (run packets one at a time, paired with the Wait node for a few seconds per round to dodge rate limits: n8n has no built-in mechanism to absorb that), and Limit (cap the quantity while testing). Plus four working habits the syllabus repeats again and again, which we'd like to put in a frame:

1. Pin data as soon as a node runs correctly: pin the result so you can keep building without calling the API again (one scrape of 500 prospects took 5 minutes: without pinning, every retry waits 5 minutes).
2. Try 1 packet, then 2, then release the whole herd: if it works with 2 it usually works with n; going straight to 500 just burns API money for nothing (the syllabus has a moment where Limit was forgotten and the AI ran 500 rounds, generating openers all at once).
3. Name nodes by function as you build: a 30-node pipeline full of nodes called “OpenAI” is a maze; and don't rename nodes while the pipeline is running for real: renaming breaks references.
4. If you're stuck on an absurd error too long, let go, work on something else, then come back: many API errors “fix themselves” because the trouble was on the service's side, and banging your head against it just costs you an evening.

Part 5: Two starter pipelines: a personalized email machine, and a journalist reply machine

Once the foundations are taught, the syllabus gets to real building, and the first two pipelines are chosen very cleverly because they are short yet touch every technique:

• Personalized sales email machine: Google Sheets reads the prospect list → an AI node reads each person's job title, industry and company description and produces a 5-field JSON (email subject, an opening line to build rapport, a short intro paragraph, a call to action, a P.S.) → write back to the Sheet → Gmail creates a draft (not sent directly: a person reviews and clicks send, in line with the “sensitive spots need a human” rule learned in the agentic course). A detail worth learning in the write-back step: the Update Row node must refill every column, including the unchanged ones, or old data gets overwritten with blanks: the kind of small detail the documentation doesn't teach, which you only learn by tripping on it.
• Journalist reply machine: a press service sends a daily email digest of the questions reporters need experts to answer; the pipeline catches the email with a Gmail Trigger, cuts the block of text into individual questions, has AI score “is this relevant to me,” and for relevant ones drafts a reply in a natural voice and creates a draft with a category label. A free PR channel running quietly all year. The core technique of this pipeline is dissecting text strings: the digest email is one long lump of text, which has to be cut twice on delimiter characters (first to split off the body, then to split each item), then a Split Out node unpacks it into twenty separate questions for the AI to score one by one: a small exercise that teaches the whole mindset of “raw data into processable unit rows.”

Each of these two pipelines has under a dozen nodes, yet together they cover everything: triggers, reading and writing spreadsheets, AI returning JSON in a set template, filtering, and creating drafts for human review. After building both, you can confidently read and understand any n8n workflow online: the rest of the course is just stacking these bricks higher.

Part 6: Money pipeline 1: personalized gifts for each prospect

The business idea behind it is well worth learning: instead of a cold sales email, give a custom-made gift first to each prospect (a newsletter-style analysis written just for their company), and response rates jump well above a dry pitch letter. The pipeline: scrape a list of prospects from a business database (through the Apify intermediary scraping service to keep it cheap) → filter for those with both a website and an email (from 500 down to 247 qualified prospects) → scrape each prospect's website and compress it into Markdown → AI pass one reads it and extracts “company context + person context + 3 unique angles” → AI pass two writes the personalized newsletter from a ready template → pour it into Google Docs as a nicely formatted document (technical tip: the native Google Docs node can't insert formatting, so you have to add an HTTP Request that writes HTML into the document) → loop through each prospect with a 5-second pause per round. For Vietnamese businesses, this turns into swapping the “newsletter” for a preliminary quote, a website analysis, or a sample content plan: same frame.

A few numbers and small details from this pipeline are worth keeping intact. Scraping cost: going around through an intermediary scraping service is far cheaper than buying the raw data package directly (the syllabus spent about $120 on a dataset that would have cost many times more bought directly): the lesson is “the same data has several doors, compare prices before reaching for your wallet.” Input quality decides the usable rate: scraping returned 500 prospects, but filtering for “has both website and email” left only 247: don't promise yourself a number before filtering. And the AI step that writes the newsletter uses exactly the technique from the Claude course: give it a real sample written by a person as the tone standard, and the AI follows that template instead of flying free: much more stable quality.

Part 7: Money pipeline 2: a quote generator that works while you're still on the phone, and a booking chatbot for your website

• Quote generator: an internal form (a sales rep quickly fills in: customer name, problem, solution, scope, timeline) → AI generates JSON with every field of a proper quote → Google Drive duplicates a Slides template file that has curly-brace variables preset → a Replace Text node fills in each variable → Gmail sends it to the customer with a link. The customer has barely hung up and the quote is already in their inbox: that professional feel closes deals. A prompt tip worth copying: teach the AI with real input-output example pairs (provide a sample form dataset alongside the exact quote written by hand as the standard), plus small rules that look ugly if missing: a 10-14 word limit for description boxes so they don't overflow the slide frame, no capitalizing every word, and the current date included in the prompt so the model doesn't fill in last year's date.
• Website chatbot doubling as a booking receptionist: an AI Agent node + 10-turn memory + two Google Calendar tools (check free slots, create appointments), embedded into the website with a ready-made code snippet. The system message is the soul: the bot's identity, hours and time zone, price list and business information stuffed straight in (for a small bot, stuffing context directly into the prompt works just as well as a fancy retrieval architecture), conversation rules (ask for name, email, preferred time, confirm back, then book), and a line guarding against off-topic leading questions. Agencies out there quote $1,000-2,000 for exactly this.

The quote machine has an upgraded version in the syllabus for anyone who wants to go all the way: replace Google Slides with a dedicated quoting service that integrates e-signature and a payment button (50% deposit on signing, 50% on handover) by calling their API directly through HTTP Request: the customer views the quote, signs and pays the deposit in the same document, cutting out the back-and-forth emails entirely. For Vietnamese businesses, this thinking applies even with a different tool: a quote isn't a document to be read, it's a closing machine: the fewer the steps from “view” to “sign,” the faster the money arrives.

Part 8: Money pipeline 3: a content recycling machine, and a trending video detector

• Content recycling machine: paste the link to a long video (podcast, conference) → scrape the subtitles (through Apify, about a cent per video) → AI dissects it into the 10 most valuable points → each point runs through three AI branches that write posts in each platform's own voice (short Instagram with hashtags under a character cap, long Facebook with a landscape image, polished LinkedIn) plus one branch that generates an illustration → pour everything into Google Sheets as a content calendar. A second pipeline runs at 7 a.m. every day: pick up posts not yet published, publish straight to the three platforms via API, mark them as posted. One podcast session becomes a whole month of content: exactly the kind of work Vietnamese businesses are hiring 1-2 people to do by hand. The technique of auto-posting to each platform is also taught thoroughly and honestly about how fiddly it is: Instagram and Facebook go through Meta's Graph API (you must create a developer app, grant permissions, and switch to Live mode: the paperwork takes longer than building the pipeline); LinkedIn requires you to download the actual image file first before posting rather than accepting a link. Anyone who has ever cross-posted to three platforms by hand will see the value right away: the pain isn't writing the post, it's the step of posting correctly to each platform's standard.
• Trending video detector: watch a list of channels in your niche, each morning compute each channel's average views, and any video that exceeds double the average is “trending,” bundled into a digest email with images and numbers sent at 6 a.m. Anyone who makes content understands the value: knowing early which topics are on fire before they hit the news.

But the most valuable part of these two pipelines is the real breakdowns the syllabus hit along the way, which we've kept intact so you see the downside of drag-and-drop: the image generation node sometimes dies from trouble on the service's side, not your mistake; the AI-generated image links expire on their own after a while, so you have to download them right away; the Merge node accepts only two inputs, so a third means a workaround; the YouTube API doesn't distinguish short videos from long ones, so you infer it from the duration string with an ugly regex; the Code node says “no output data” even though the logic is right, and you end up switching to a Filter node; and the heaviest of all: a bug in n8n itself that makes variables from the previous loop bleed into the next, pouring one channel's data into another channel's table: you have to rig up an extra loop just to force it to forget the old variable. Read this chain and ask yourself: what if this were the invoicing pipeline at your company? That is exactly why there is a boundary in section 10.

Part 9: Money pipeline 4: a LinkedIn outreach machine, and an opener writer that “reads every page of the website”

• The LinkedIn outreach machine: describe your target audience in plain language in a form (“creative companies with 1-1000 people in the US”) → AI translates it into a proper search query for the Apollo database → scrape through Apify ($1.20 per thousand leads) → AI writes a connection request under 300 characters for each person → dump into Google Sheets → the PhantomBuster service reads the Sheet and sends the real invitations, trickling out 10 per batch. Two rules for writing the invitations are worth carving in stone: never reuse scraped information word for word, always rephrase it (copying it verbatim gives away that a machine wrote it), and use natural abbreviations like a real person would. Plus a platform safety rule: LinkedIn tolerates around 150 cold invitations a week per account, and getting greedy gets the account locked.
• The machine that reads every page before writing an opener: an upgrade of the machine above: it doesn't just read the homepage but follows internal links and scrapes every subpage, AI summarizes each page into two paragraphs, merges them, then writes a multi-line opener that mentions a small, non-obvious detail on the prospect's site: the feeling that “someone really read up on me” is what opens the inbox. The course cites real campaign numbers running this framework: a 4-10% reply rate, while mass cold email is thrilled with 1%.

The technical chain of the “read every page” machine is worth describing in detail because it is the most complex pipeline in the course: scrape the homepage → HTML Extract node pulls out all links → filter to keep only internal linking (those starting with a slash) → deduplicate → join the domain onto each link to scrape every subpage → compress to Markdown → AI summarizes each page into two paragraphs (with a rule to truncate input over 5,000 characters so one long page doesn't clog the whole pipeline) → Aggregate node collects all summaries for the same prospect into one array → AI reads the whole array and writes a multi-line opener. The prompt for the final step uses a 5-layer structure: role, rules, a sample input, a model output, and only then the real data. This is the “industrial-grade” prompt level you should copy for every important AI step, whatever the platform.

We close the hands-on part with the five mistakes beginners make most, gathered from the stumbles in the course itself: one, forgetting to switch the Test URL to the Production URL when turning on a live pipeline (the pipeline “dies” mysteriously); two, forgetting the Limit node while testing, so AI runs a hundred rounds and burns money for nothing; three, writing to a spreadsheet with a missing column, which wipes old data blank; four, trusting AI-generated code for expressions without knowing n8n doesn't support another library's loop syntax (you have to concatenate strings by hand); five, building one overly long workflow instead of splitting it into small pipelines that call each other: hard to debug, hard to test, hard to hand over. Pin these five lines next to your screen and you'll dodge quite a few sleepless nights.

Part 10: n8n's real place: when to use it, when to stop, and the map of three worlds

After the eight pipelines, you have enough to draw your own map. We'll draw it for you, using over 10 years of building software and everything this very course exposes:

• n8n wins when: the scale is small (a few hundred to a few thousand runs a month), the work is internal and nobody gets hurt if it runs a session late, you need to test an idea before investing in a real build, or you need to see the process with your own eyes so the whole team understands it. All eight pipelines in the course fall in this zone, and all are worth building.
• n8n breaks when: the chain is long and runs at high volume (every node is a point of failure, not to mention bugs in the platform itself like the loop-variable bleed you've seen), the business process demands absolute certainty (invoices, money, inventory), you need permissions for many people, or you need sophisticated error handling (n8n handles errors the “if there's an error branch, route to it” way, while self-recovery, tiered retries and compensating transactions belong to real code). And a hidden cost few people mention: drag-and-drop pipelines have no automated tests: change one node and you have to run the whole pipeline by hand again, and the more you change, the more nervous you get.
• The map of three worlds, ordered by increasing investment: n8n for experiments and small jobs you can see with your own eyes; agentic workflows (the previous course) for personal workshops and teams, far more flexible thanks to AI orchestrating in plain language; custom-built software for the lifeblood of a business: load capacity, permissions, logs, tests, someone accountable. The three worlds don't replace each other, they connect: what you verify with n8n today is the cheapest spec for the real system tomorrow.

On money: the original course positions the systems in it at the international market rate of $1,500 to $15,000 per client deployment, and that number says something more worth thinking about than “go sell n8n door to door”: businesses are ready to pay real money for a properly automated process, whatever tool it's built with. If you're a business owner, the right view is the buyer's: which of the eight pipelines above is worth paying for at your company, and which version to buy: the drag-and-drop version that lives on one employee who knows n8n, or a version built as a system with a warranty and someone accountable.

And that's our invitation, familiar but with one more clause this time: if you want to test first, build it with n8n following this course, and when you see which process delivers real value, bring it to MONA and we will industrialize exactly that process: keep the logic you've already verified and rebuild it in production code with permissions, logs, load capacity and an operating commitment. If you'd rather go straight in: call 1900 636 648 or send it to info@themona.global, tell us the process eating the most people, and MONA will review it for free and tell you straight: this part n8n can do on its own at no cost, this part is worth building properly, at this price, paying back in this long. Over 10 years, 14,000+ projects, and the quote you sign is the price we deliver at.

Quick answers

What is n8n, and is it free? An open-source drag-and-drop automation platform: you connect nodes into a self-running pipeline. The cloud version starts at 20 euros a month; the self-hosted version is free, but you handle operations yourself and the account-linking is fiddlier.

Do you need to know code to use n8n? Not for the basics: drag, drop and fill in the boxes. But used to its full extent you'll run into expressions, JSON and regex as in the course: a bit of coding background makes you twice as fast.

How does n8n compare to Make and Zapier? Same drag-and-drop genre; n8n scores with open source, self-hosting, strong AI nodes and friendly per-run pricing at high volume. The thinking you learn in this course carries over to all three.

Should a large business run its core operations on n8n? Our straight view: no. n8n suits small scale and experiments; live business operations need complete software with tests, permissions, load capacity and someone accountable. In the course itself you've seen the breakages: a platform bug that bleeds loop variables, image links that expire on their own, nodes that die when an outside service hiccups.

n8n or agentic workflows, which should you learn first? Either works, but the smoothest path is to learn the agentic workflow course first to grasp the “AI judges, code executes” mindset, then learn n8n to add a tool for seeing the process visually. Both are free in MONA's series.

How long does it take to build an n8n pipeline? The pipelines in the course range from a few dozen minutes (the draft email machine) to a session (the content repurposing machine). Add the time to connect your service accounts for the first time: that often takes longer than the drag-and-drop part.

The next course in the series: intro to AI agents: the core theory fits into 2 hours, so you can talk about agents without getting bluffed. See you there.