We got tired
of wiring
things together.
So we built Nexflow — a workflow automation engine for developers who want real control over what runs, when it runs, and exactly what comes out of it.
Two things no other tool does.
Not better versions of what exists. Genuinely absent features that change how you think about workflow automation.
Live parallel execution,
visible on the canvas.
n8n, Zapier, and Make show you execution results after they finish. Nexflow shows you execution as it happens — each branch turns live the instant it starts.
When it's done, BranchTimeline tells you exactly how much time parallel execution saved vs running sequentially. Not estimated — measured.
// n8n
$node["HTTP Request"]
.json["data"][0]
["user"]["email"]
// Make
{{1.data[].user.email}}
// Zapier
{{153892.Body.data
.0.user.email}}Your data has a name.
One you chose.
Every other tool forces you to navigate its internal data structure — position-based indexes, UUID node references, nested dot-paths that break the moment you reorder a step.
In Nexflow, you name a node's output once — say, fetchUser — and every downstream node accesses it as nex.fetchUser.field.
Scripts read it natively: var email = nex.fetchUser.email. No binding helpers. No adapter layers.
| FEATURE | NEXFLOW | N8N | ZAPIER | MAKE |
|---|---|---|---|---|
| Live parallel execution on canvas | ✓ | — | — | — |
| Per-branch real-time status dots | ✓ | — | — | — |
| Named data access (nex.name.field) | ✓ | — | — | — |
| Real JavaScript / Python in flows | ✓ | ✓ | — | — |
| Merge strategies (ALL / FIRST / N) | ✓ | — | — | — |
| Branch timing + savings visible | ✓ | — | — | — |
| Flows calling other flows | ✓ | ✓ | — | ✓ |
| Full execution JSON per node | ✓ | ✓ | — | — |
| Multi-instance WebSocket delivery | ✓ | — | — | — |
| Script reads nex directly | ✓ | — | — | — |
✓ = supported natively — as of March 2026
How we got here.
The Frustration
Every developer has lived this: you need to automate something — fetch data from an API, transform it, store it, notify someone. You write the same boilerplate again and again. HTTP clients, error handling, retry logic, scheduling. The code exists. The problem is the time it costs to wire it all together every single time.
The Observation
Tools like n8n and Zapier solved this for non-developers. But they made a trade — they hid the power to make it accessible. You couldn't write real logic. You couldn't compose flows from other flows. You couldn't understand what was actually happening inside an execution. They were black boxes with pretty UIs.
The Decision
We wanted a tool built for developers first. Where you can write real JavaScript or Python mid-flow. Where every execution is fully transparent — every node, every output, every path taken. Where flows can call other flows. Where your data has a name you chose, not a UUID you have to remember. Where automation is understandable, not magical.
The Engine
A full flow execution engine with 12 node types: HTTP, Script (JavaScript + Python), AI (multi-provider: Anthropic, OpenAI, Gemini, Groq, Mistral), Sub-Flows (sync + async), Variables, Mappers, Decisions, Loops, and terminal Success/Failure nodes. A universal nex container so every node output is named, not nested — nex.yourName.field, not nodes[uuid].result.body.
Real-Time Canvas
ReactFlow-based Studio canvas with live WebSocket node updates over STOMP. Two-phase trigger pattern: execution prepares first, browser subscribes to its queue, then starts — so no event is ever dropped. RabbitMQ StompBrokerRelay for multi-instance production deployments. Dedicated thread pool (core 20, max 50) with explicit transaction boundary commits so background threads always see committed state.
Parallel Execution
FORK and JOIN nodes that run multiple branches simultaneously on separate threads using CompletableFuture.allOf(). Three merge strategies: WAIT_ALL (every branch must finish), WAIT_FIRST (race mode — fastest wins), WAIT_N (quorum — continue when N branches complete). Branch results land in nex under their branch name. Live per-branch status dots on the canvas. BranchTimeline in transaction detail shows each branch duration and time saved vs sequential.
Production Hardening
Three production bugs diagnosed and fixed under load: WebSocket race condition where messages were dropped before subscription existed (fixed with /queue/ destinations and two-phase trigger). Multi-instance broker isolation where events published on Instance A never reached browsers on Instance B (fixed with RabbitMQ relay). Thread pool exhaustion under 25+ concurrent requests (fixed with dedicated executor and split @Transactional boundary). Each bug produced an engineering principle that is now part of how we build.
The Nex Standard
Replaced the scattered nodes[uuid].successOutput.body pattern with a single flat object: nex. Every trigger field, variable, and node output is auto-spread into nex under the name you chose. nex.fetchUser.body.email instead of nodes['ca250f8e'].successOutput.body.email. Scripts receive both nex and a legacy input object for backward compatibility. All config panels updated with {{nex.x}} syntax.
Auth + RBAC
Full authentication system: email/password with OTP verification, Google OAuth2 login, and JWT-based sessions. Three-tier role model: Admin, Sub-Admin, and Member. Admins manage user roles, create groups, and grant flow-level access. Groups can be all-access or selective. The first registered account is automatically promoted to Admin.
Production Deploy
Solved a hard Docker problem: Maven downloading 400+ JARs on an 8GB gp2 EBS volume saturated the 24 baseline IOPS ceiling. Solution: pre-built JAR pattern — Maven runs locally, only the JRE runtime image and a single JAR ship to EC2. Build time dropped from 20+ minutes to under 2 minutes. nginx reverse proxy routes traffic across backend (8090) and AI agent (3001). Cloudflare quick tunnel provides HTTPS without SSL cert setup.
The Near Horizon
CRON scheduling so flows run on time without external callers. Retry logic with configurable backoff on any node. MCP server so AI tools like Claude and Cursor can build and run flows through conversation. Nested fork-join support — a branch can contain its own parallel split. Secrets manager so credentials never touch the canvas. Flow templates marketplace.
The Vision
Nexflow becomes the automation layer that developers actually want to use — not because they have no choice, but because it respects their craft. Multi-tenant organisations with SSO. A marketplace of connectors. An AI node that reasons about data and routes decisions. Flows described in plain language, built in minutes, fully inspectable. Eventually: the platform where any integration is 20 minutes, not 2 days.
What guides every decision.
Transparency over magic
Every execution is fully visible. Every node shows its input, output, and status. No hidden transformations. You should always know exactly what happened and why.
Developer-first, always
Real code runs inside flows. JavaScript, Python — not expression builders with 12 nested dropdowns. If you can write it in code, you can run it in a node.
Composability
Flows call other flows. Nodes are reusable. Connectors are saved once and used everywhere. Nothing should be rebuilt twice.
Named, not nested
Your data has a name you chose. nex.userData, not nodes['ca250f8e'].successOutput.result.body. The machine should adapt to you, not the other way around.
Access by design
Every flow belongs to someone. Roles, groups, and per-flow permissions ensure the right people see the right automations — without locking everyone out by default.