Everyone can wire up n8n. Almost nobody can tell you where n8n stops. That gap is the entire job. Real automation is three layers, not one tool, and the layer most people build is the easy third. We run all three in production, in our own systems and for clients, and the value was never the part everyone already has.
n8n had a strange year. In October 2025 the company raised 180 million dollars and crossed a 2.5 billion dollar valuation, up from 300 million four months earlier. Around 230,000 people now run it, three quarters of them using the AI nodes. Every second automation post on LinkedIn is an n8n canvas with a few boxes and an arrow. The tool earned the hype. It is genuinely good, it is self-hostable, and it connects to almost everything.
And that is exactly where most automation projects quietly stop. Someone sets up n8n, wires a webhook to a Slack message, calls it an automation strategy, and moves on. It works until the workflow has to make a judgment call, or until it has to survive four days and a server restart without losing its place. Then the visual canvas runs out of road, and the people who only know the canvas run out with it.
What Automation Actually Needs#
Strip away the tools and there are three jobs underneath every serious automation. They are different problems, and a tool that does one well usually does the other two badly.
The first job is connecting things. A signup comes in, a record goes into the CRM, a welcome mail goes out, a notification lands on someone's phone. No thinking required, just reliable plumbing between systems that were never designed to talk to each other. This is the bulk of automation by volume, and it is the job n8n was built for.
The second job is making a judgment call. The workflow has to read something ambiguous, decide what it means, and pick the next step based on that decision. An email arrives and the system has to judge whether it is a real lead or noise, then route accordingly. A draft gets reviewed and the system has to decide whether it is good enough to ship or needs another pass. This is not plumbing. This is reasoning, and it needs a different kind of tool.
The third job is surviving over time. Some workflows run for hours or days. They wait for a human to approve something. They call six external services, any of which can fail, and a failure halfway through must not corrupt the other five. If the machine reboots at step four of seven, the work has to resume from step four, not start over. This is durability, and it is the hardest of the three to fake.
These three jobs are orthogonal. A tool that tries to be all three at once ends up mediocre at each. A stack that picks the right specialist for each layer beats the all-in-one every time. Our three specialists are n8n, LangGraph, and Temporal.
n8n: The Layer Everyone Already Has#
n8n is the connecting layer, and for that job it is excellent. Four hundred plus pre-built integrations, a visual canvas a non-engineer can actually read, self-hosting in under half an hour. We run it as the automation hub for the unglamorous work that keeps a business moving. A signup webhook that creates a CRM lead and fires a welcome mail. A new blog post that fans out into draft social posts. A scheduled health check that pings a row of services and alerts a channel when one goes quiet. An inbound email that gets parsed for intent before it touches a human.
This is real value and I want to be clear about it. n8n is not a toy and it is not Zapier for power users. It is a proper, fair-licensed, self-hostable orchestration platform, and for connecting systems it is often the fastest correct answer. If a client needs their ops team to edit a workflow without a deployment cycle, the visual canvas wins on its own merits.
The limits appear in state, concurrency and recovery. For merged branches, check which data is available when and how errors are handled; no general merge failure rate is established here. n8n is not a durable execution engine with deterministic replay like Temporal. Whether an interrupted run can resume still depends on the workflow and stored execution data, not a blanket claim about every crash. n8n also offers plan-dependent evaluations for AI workflows. Custom Code nodes still need suitable tests and maintenance. The canvas is a useful part of the architecture; it does not replace checking these properties.
LangGraph: When the Workflow Has to Think#
LangGraph models execution as a graph with state and transitions. It supports fixed workflows as well as agentic flows in which a model selects the next step. We use it when that control and observable state transitions fit the task.
The two features that earn its place are state and pausing. With a configured checkpointer, LangGraph saves state at step boundaries. Recovery after process failures requires persistent storage; an in-memory checkpointer is not sufficient. Pausing lets the workflow stop midway, wait for human approval or correction and continue with that answer. The prerequisites are documented in the persistence guide.
A concrete shape we run on it: a multi-step agent pipeline where one step drafts a plan, the next builds against it, a third reviews the result, and a fourth tests it, with an approval gate that pauses the whole thing for a human whenever the review comes back uncertain. That is reasoning plus checkpoints plus human-in-the-loop, a combination we prefer to express in LangGraph. n8n can also pause with its Wait node, persist execution data in the database and resume through a webhook or form, for example. An approval does not require a polling hack.
The trade-off is real and worth saying out loud. LangGraph is overkill for a workflow that just calls a model and posts the result somewhere. Reach for it too early and you have written two hundred lines of framework code where fifty lines of plain logic would have read more clearly. The open-source framework uses the MIT license. We review the terms of any additional hosting services separately. The discipline is to use it only where reasoning and resume genuinely pay for the added weight.
Temporal: When the Workflow Cannot Be Allowed to Die#
The third layer is the one almost nobody in the n8n crowd has even heard of, and it is the one that separates a hobby setup from infrastructure. Temporal is a durable execution engine. It records every step of a workflow as an event history. After a worker failure, an available worker can take over tasks, reconstruct workflow state by replaying the event history and continue execution. Temporal does not itself start a new worker process; deployment and available workers must be configured. Workflows can run for days or years. It is open source under the MIT license, and it has quietly become the standard for durable agent execution. OpenAI runs Codex on it in production, for agents that wait days for human approval and survive restarts without losing their place.
What this unlocks is the class of workflow that touches the real world and cannot afford to be half-done. A billing lifecycle where a subscription renews, a payment is taken, and a refund has to roll back a chain of side effects cleanly if one step fails. A customer onboarding that runs over several days with timers and waits built in. A recurring job that aggregates work across many sources and must complete reliably every single time. These are sagas, long-running transactions with compensation when something breaks, and they are exactly what a visual canvas was never meant to hold.
The need for durable execution depends on recovery, side effects, waiting periods and the cost of failure. A short read-only task may work without a dedicated engine. Multiple external calls, long waits and payments or deletions deserve deliberate assessment; a mandatory threshold of thirty seconds or three calls is not established here. Our templates are at github.com/studiomeyer-io/temporal-memory-workflows. Temporal adds operational work and rules for deterministic workflow code.
How the Three Layers Fit Together#
Their jobs differ: n8n connects systems, LangGraph controls model decisions and human approvals, and Temporal supports long-running execution and recovery. Together they can form a suitable stack. Temporal does not guarantee successful completion: activities and workflows can fail permanently. Retry policies, timeouts, error handling and idempotent external actions or compensation must fit the task. A crash becomes more manageable; recovery still needs checking. Observability shows what each layer actually did.
Separating business logic from the framework makes a switch easier. Domain rules can live in plain, tested code that different tools call. State, events, permissions and execution semantics still require work; a one-day migration is not a general promise.
Setup Is a Commodity. Architecture Is Not.#
Here is the part the market gets backwards. Setting up n8n is a commodity now. There are thousands of people who will draw you a canvas, and the price of that work is falling because the tool made it easy, which was the whole point. If all you buy is the n8n setup, you bought the layer that was already the cheapest to build.
The value is in the two decisions nobody sells you. First, knowing which of the three layers a given problem actually needs, and having the judgment to resist both failure modes: cramming a reasoning problem into an n8n Code node until it rots, and over-engineering a fifty-line job into a durable workflow it never needed. Second, building the boundary so cleanly that the choice stays cheap to revisit. That is architecture, and it does not show up on a canvas screenshot.
There is one more thing worth being honest about. What runs our own internal systems is deliberately pragmatic, tuned for an operation that knows its own edges. A client engagement gets the other gear entirely, the same three layers but with the hardening, the governance gates before risky actions, the observability, and the testing that a system someone else depends on actually requires. Knowing the difference between good-enough-for-us and right-for-a-client is itself part of mastering the stack. Anyone can run the tools. Knowing how far to take them is the work.
So the next time you see an automation pitch that begins and ends with n8n, the question to ask is not whether the canvas is nice. It is what happens at the two edges the canvas does not show, when the workflow has to think and when it has to survive. If you want that whole stack designed properly rather than just the easy third, that is the conversation we have.
