I used to have a strong opinion about visual workflow builders: they're for people who can't code. If I needed to move data from A to B, I'd write a small Node service, deploy it, and feel good about myself.
Then I counted how many of those "small services" I was babysitting. Webhook receivers. Cron jobs. A script that broke every time an API changed its auth. Each one had its own deployment, its own credentials handling, its own half-finished retry logic. None of it was interesting engineering. All of it was glue.
n8n is where I put my glue now. This post is what I'd tell a developer who's skeptical the way I was.
What n8n actually is
n8n is a workflow automation tool: you connect nodes on a canvas, where each node is a trigger (webhook, cron, "new email arrived") or an action (call an API, transform data, write to a database). It ships with hundreds of pre-built integrations: Gmail, Notion, Slack, Google Sheets, Postgres, and increasingly, LLM and agent nodes.
Two things separate it from the Zapier category:
- You can self-host it. It's source-available and runs happily in a single Docker container. Your data and credentials stay on your infrastructure, and there's no per-task pricing anxiety.
- There's an escape hatch to real code. The Code node lets you drop into JavaScript (or Python) whenever the visual nodes get awkward. This is the feature that makes it usable for engineers: you're never trapped fighting a dropdown to express something that's one line of code.
The workflow that converted me
The pipeline that changed my mind was embarrassingly simple. I record my meetings with Fathom, which produces transcripts and summaries. I wanted every meeting to end up as a structured page in Notion: action items extracted, decisions highlighted, tagged by client.
The custom-service version of this is a webhook receiver, OAuth token management for Notion, an LLM call with retry handling, error alerting, and a deployment. A weekend, at least, plus maintenance forever.
The n8n version is five nodes: Webhook → LLM node (extract action items and decisions into JSON) → a small Code node to shape the Notion blocks → Notion node → error branch to notify me if anything fails. It took about an hour, most of which was me fiddling with the extraction prompt.
It has run since without me thinking about it. That's the point. The value of the pipeline was never the code (it was the outcome), and n8n let me skip straight to the outcome.
Where n8n genuinely shines
After building a bunch of these, for myself and for clients, the pattern is clear. n8n wins when the problem is integration-shaped:
- Webhooks in, API calls out. The boring 80% of automation work (receiving events, transforming payloads, pushing them somewhere) is exactly what the node catalog covers.
- Credentials management for free. OAuth flows, token refresh, secrets storage: handled once, in one place, instead of re-implemented per script.
- Retries, error branches, and execution logs built in. Every run is recorded with the full data at each step. When something breaks at 2 AM, you open the execution, see exactly which node failed and what the payload looked like, and fix it. My hand-rolled scripts never had observability that good.
- AI workflows without the boilerplate. The AI agent nodes let you wire an LLM to tools and memory visually. For "summarize this and route it" or "classify incoming leads" workloads, it's dramatically faster than setting up a framework.
Where it doesn't
Being honest about the limits matters more than the pitch:
- Complex business logic gets ugly on a canvas. If your workflow has deeply nested conditionals or needs real data structures, a wall of IF nodes becomes unreadable. Push that into a Code node, or accept that this problem wants a real service.
- Version control is workable, not native. Workflows are JSON exports. You can commit them and review diffs, but it's not the same as reviewing code. For team settings, this needs discipline.
- Heavy compute doesn't belong here. n8n orchestrates; it shouldn't crunch. If a step needs serious processing, have n8n call a service that does the work.
My rule of thumb now: if the hard part is the integrations, use n8n. If the hard part is the logic, write code, and maybe let n8n trigger it.
Reading the source
Working with a tool daily eventually made me read its source. n8n is a big TypeScript monorepo, and it's one of the more approachable large codebases I've contributed to. The node interface is clean: most integrations boil down to "describe your parameters, implement execute()." That's a big reason the community has produced so many nodes.
I've had a couple of PRs merged upstream, and the process was a good experience: clear contribution docs, responsive maintainers, tests that tell you what they want. If you use n8n and hit a rough edge, fixing it upstream is very doable.
If you want to try it
Start self-hosted. It's one command:
docker run -it --rm -p 5678:5678 -v n8n_data:/home/node/.n8n docker.n8n.io/n8nio/n8n
Then build the classic starter: a webhook that takes any text, sends it to an LLM for a summary, and posts the result to Slack or email. Three nodes, fifteen minutes, and you'll understand the tool better than any tutorial can teach you.
The lesson I took from all this isn't "low-code good" or "low-code bad." It's that glue code was never the part of my job worth doing by hand, and admitting that freed up real time for the engineering that is.