«Another quote to fill out manually?»
I vividly recall the scene. A couple of years ago, at a mid-sized service company in Milan with about fifty employees, the sales manager pointed to his monitor: yet another spreadsheet to manually populate for a potential client. «It's like this every Friday,» he told me. «Between extracting data from the CRM, verifying rates, and filling it all out, if we're lucky, it takes 15-20 minutes per quote. And if we do 20-30? That's a day of work wasted.»
The immediate and most obvious solution seemed to be 'no-code' or 'low-code' automation using tools like n8n, Make, or Zapier. And in many cases, it is the best approach: it allows for rapid prototyping, delegating small automations to non-technical teams, and unlocking value in just a few hours. These are excellent tools for connecting different apps, moving data, or triggering simple actions. We've seen their effectiveness in numerous projects, from automated accounting management to AI-assisted quote generation.
But every tool has its limits. And, as I've observed repeatedly over the past 18 months, there are scenarios where n8n's apparent simplicity can turn into a maintenance nightmare, with unforeseen costs and inadequate performance 12-24 months down the line. This isn't an inherent flaw of n8n, but rather a trade-off to be aware of between initial development speed and long-term robustness.
Here are three real-world cases where pushing beyond pure 'no-code' and opting for more custom or specialized solutions pays off significantly.
Case 1: High-Volume or Real-Time Critical Data Flows
Imagine an e-commerce company with thousands of orders per day that need to be synchronized with the warehouse, ERP system, and shipping carriers, all within seconds to ensure a smooth customer experience. Or a financial monitoring system that must react to market variations in real time.
In these contexts, an n8n-based automation, while effective for smaller loads, can quickly hit its limits:
- Latency and Scalability: Each 'node' in an n8n workflow adds a small delay. Many nodes processing large volumes can slow down the entire process. Managing n8n's horizontal scalability for intense traffic peaks can be complex or costly to handle independently.
- Reliability: For critical transactions, it's essential that every step succeeds or that an intelligent and 'idempotent' retry mechanism is in place. Idempotency means performing the same operation multiple times always produces the same result, without unwanted side effects. While n8n offers retry mechanisms, managing complex idempotency and error handling logic for thousands of events per second becomes challenging within its visual interface.
When to Opt for Cloudflare Workers:
For these scenarios, solutions like Cloudflare Workers (or AWS Lambda, Google Cloud Functions, Azure Functions) offer much more granular control and inherent scalability. A Cloudflare Worker is a small serverless program that runs on 'edge servers,' meaning close to your users. This reduces latency. It allows you to write custom code (JavaScript, TypeScript, WebAssembly) to handle precisely the desired logic, without the overhead of a visual workflow engine. For example, for managing high-traffic webhooks (a webhook is a digital 'bell' that one system rings to notify another), a Worker can filter, transform, and route data with superior speed and reliability, keeping costs low for extremely high volumes.
Case 2: Complex Logic and Long-Lived Persistent State
Consider a workflow that manages new customer onboarding. Such a process might include sending documents, awaiting digital signatures, internal approvals, service configuration, and scheduling meetings, spanning days or weeks. This type of process requires 'remembering' its state at each step and resuming exactly where it left off, even in cases of interruptions or delays.
While n8n can manage multi-step workflows, it's not natively designed for very long-lived processes that require robust management of persistent state and recovery from complex failures. Debugging an error in a process that spans days can be a daunting task within its visual interface.
When to Opt for Inngest (or Temporal):
Tools like Inngest (or Temporal.io) are built specifically for the 'orchestration of distributed and persistent workflows.' Think of them as a highly specialized orchestra conductor who not only coordinates each musician (node) but knows the score precisely, remembers where you left off, and can seamlessly resume if there's an interruption. They allow you to define complex workflows in code (TypeScript/Go/Python) with execution guarantees, automatic retries with exponential backoff, state management, and visibility into execution history, even if the process lasts weeks. Their architecture is intrinsically resilient to failures and disconnections, ensuring that critical processes are always completed or their state is recoverable.
Case 3: Maximum Customization and Code Ownership
Finally, there are situations where the business logic is so unique or specific that no pre-defined node, nor a complex combination of them, can meet the requirements. Alternatively, the company might want total control over the infrastructure, security, and long-term maintainability of the code, without depending on a 'low-code' service provider for key functionalities.
While n8n does allow for creating custom nodes, integrating and maintaining them can add complexity. Debugging becomes more difficult when mixing visual logic and custom code. Furthermore, for very high usage volumes, the operational costs of 'no-code' platforms can exceed those of a self-managed custom solution on proprietary cloud infrastructure (e.g., AWS ECS, Kubernetes).
When to Opt for Custom Code (Dedicated Microservices):
When maximum customization is required, client code ownership is a priority, and the architecture must be precisely tailored to business needs, developing a dedicated microservice (or a series of them) becomes the most sensible choice. Writing code 'from scratch' offers the flexibility to implement any logic, optimize performance, and surgically integrate with legacy systems (an API is a set of rules for two software applications to communicate). This is an approach we often adopt at Logika.studio for our clients, ensuring complete ownership and 100% human review of the code. Although the initial investment might be higher, 5-year maintainability, scalability, and adaptability to future changes are often unparalleled, especially for core business processes.
'No-code' and 'low-code' are powerful tools for accelerating and democratizing automation. However, to prevent a 'quick' automation from becoming technical debt, it's crucial to understand when the complexity or criticality of a case demands a more robust, engineering-driven approach. The key is to choose the right tool for the right problem, with a keen eye not just on immediate implementation, but crucially on maintainability over 12, 24, and 60 months.
If you want to explore a similar case in your company and understand which tool fits best, our free 30-minute audit is available at audit — a quick analysis, 2-3 concrete points, zero pitch.
