The N8N workflow that powers the IAM Newsletter from an iOS Shortcut on my phone
Build Smarter: Meet n8n and the Next Phase of Your Automations
Automations exist for one reason: so your days don’t vanish under a pile of repetitive nonsense that shouldn’t need your brain in the first place. They tag subscribers, route form entries, fire off welcome emails, and keep your day from grinding to a halt. That’s solid. But once you get comfortable with those foundations, you’re going to see bigger possibilities—ways to stop telling your systems exactly what to do and start letting them figure it out on their own.
Author Automations is a reader-supported publication. To receive new posts and support my work, consider becoming a free or paid subscriber.
That’s what agentic automations make possible. Let me introduce you to N8N .
The Different Levels of Automation Tools
Most authors and solo creators start with tools like Zapier or Make.com. They’re designed for quick, structured automations that link the everyday platforms you’re already using. As your business grows or your workflows start needing conditional decisions and local control, tools like n8n step in. Each level comes with tradeoffs.
Zapier: The Starter Layer
Zapier is where most people begin. It’s popular for a reason.
Huge library of pre-built connectors
Easy “when this happens, do that” flows
No need to touch raw data or learn code
It’s perfect for adding a new subscriber from your form to MailerLite, sending yourself a Slack or Gmail notification on new orders, or logging transactions to a Google Sheet.
The limits show up quickly:
Very little visibility into each stage
Minimal branching (mostly skip or stop)
Breaks on first failure, with no robust error handling
Make.com: The Flexible Middle Ground
Make.com (formerly Integromat) gives you more control.
Multi-branch routers and real visual maps
Functions to transform dates, text, numbers
Better error handling than Zapier
It’s perfect for sending different onboarding emails by signup type, auto-creating blog posts from form data, or handling multi-step checks like pulling images, testing keywords, and queuing posts.
But it’s still mostly point-and-click modules, and without careful planning, complex logic can turn into a tangled mess.
n8n: The Local, Open-Source (or SaaS) Brain
n8n goes even further. It’s open-source, so you can run it on your own server, keep your data private, avoid surprise price changes, and customize everything. Or you can pay for their managed SaaS version and skip the server upkeep.
Multiple triggers, multi-branch routers, loops, waits, and full error-catching all live on the same canvas
Mixes simple functions with direct HTTP/API calls, so you’re never stuck waiting on someone to build a connector
Integrates cleanly with self-hosted tools like Ollama for AI, Baserow for structured data, or your own CRMs
This is where automation shifts from running a single pipeline to acting like a smart coordinator.
The tradeoffs are real. It’s not as beginner-friendly. You’ll handle JSON, troubleshoot, and keep an eye on system health. Hosting it yourself means you own it—but also maintain it. Using the SaaS version simplifies the tech but gives up some control and privacy.
What Makes an Automation Agentic
A typical automation follows direct instructions:
“When this happens, do that.”
An agentic automation evaluates. It considers multiple data points, checks what’s already happened, and decides what to do next based on context.
For example, instead of just adding a reader to your list and sending a thank-you, it might:
Check if this reader’s signed up before.
Look at which web pages they’ve engaged with.
Decide whether to send a first-time welcome series, a returning-reader bonus, or hold off if they’re already queued for a launch.
It still follows clear rules—but they’re layered and conditional. The system isn’t just reacting. It’s choosing actions based on the bigger picture.
How This Works in My Business Right Now
These aren’t abstract concepts. This is literally how I run Indie Author Magazine’s newsletters—inside a custom n8n system that does more than just fire off a broadcast. It coordinates.
Right now, this workflow starts with a simple webhook. I trigger it from an iOS shortcut on my phone—meaning I can be at a café in Scotland and queue up an entire content sequence by voice. From there, it moves through a whole set of checks and agents that handle the messy decisions.
It first checks for duplicate content in Airtable so I’m not accidentally repeating newsletter topics we’ve already covered.
Then it queries a vector database built from past IAM articles to maintain consistency and avoid rewriting the same ideas in a new hat.
It pulls in multiple LLMs—OpenAI, Google’s Gemini, and even DeepSeek—so different models can evaluate or generate content, depending on the step.
It also stores short-term context in memory nodes so if a branch needs to remember something it decided earlier, it can.
Finally, it sends a summary or draft to Gmail so the team knows exactly what’s in the pipeline (and can override it if needed).
That means my system isn’t just following a static recipe. It’s making decisions based on what’s already been published, what’s in the works, and how each piece fits into the bigger editorial calendar. And because it’s designed to stop or alert us when data’s missing or something fails, we’re not building silent messes that we have to clean up later.
Why Checks and Stops Matter Even More Here This isn’t just about preventing duplicate content. It’s about protecting everything downstream.
Because this workflow pulls from multiple models, taps memory nodes, and writes to several systems, it needs guardrails at every handoff. If the duplicate check fails, the flow pauses. If the vector search comes up empty or returns garbage, the system logs it and waits for me or the team to decide next steps. If an API times out, the automation doesn’t keep rolling forward with half-baked data—it flags the error and stops.
That means we catch issues in real time instead of sending half-formed newsletters or cluttering inboxes with repetitive content. It also means we’re never crossing wires on campaigns, launching something new before the last sequence finishes, or blowing up our deliverability by hammering the same segment twice.
Agentic workflows give you huge leverage, but only if they’re designed to think carefully, not just execute blindly. Those stop-points are what keep the whole system from quietly turning into a problem machine.
How to Start Without Overbuilding None of this started with multiple LLMs, vector lookups, or a dozen checks. The IAM newsletter workflow began embarrassingly simple: a webhook that took text from my phone and dropped it into Airtable. That was it.
Then we added a duplicate check—because I got tired of writing the same three newsletter ideas in different flavors. Next came a lightweight vector store to cross-check against past issues. Only once those were running clean did I start layering in more decision points, like separate AI models for different types of content generation. The memory nodes and structured error logging were the last piece, because until the core decisions were stable, adding more logic just meant more places to break.
If there’s one takeaway, it’s this: build in small, solid increments. Start with a single-purpose flow that does one job—like dropping newsletter topics into a database or sending a draft to your team. Run it for a few weeks, watch the outputs, and see where the real gaps are. Only then start layering conditions, memory, or AI that shapes content on the fly.
Keep every major process modular. My onboarding automations live on separate canvases. My launch sequences are in another. That way, if something in the newsletter chain stalls, it doesn’t freeze everything else we’re running. Each system checks its own work, logs its steps, and hands off data clean—so if a fix is needed, we’re only ever pulling one thread.
Because that’s the real point of all this: to build systems that handle 95% of the work, flag the other 5% for a human, and never go off making decisions you didn’t explicitly teach them to make.
Wrapping Up
Agentic systems give your business more than just saved clicks. They build resilience by evaluating what’s happening in real time and acting on it—without constant manual oversight.
You still stay in charge. Your role just shifts from clicking every step to overseeing a smart system that flags exceptions, so you can jump in only when your judgment’s actually needed.
Next time, I’ll show you one of my live n8n canvases in action—so you can see exactly how data flows, where checks run, and how local AI handles creative work like blurbs and social copy.
Paid subscribers will also get a private video walkthrough and starter templates you can use to start layering this into your own business.
Keep building smart. The systems you put in place now will pay you back every single day.
—Chelle
Author Automations is a reader-supported publication. To receive new posts and support my work, consider becoming a free or paid subscriber.