Why MeshFlows (positioning)¶
MeshFlows is a capability-based integration orchestration platform. Its strength is not “another visual workflow builder,” but how integrations are built, deployed, and operated as a platform.
In short: n8n and Elsa-style tools are primarily workflow engines / automation tools; MeshFlows is oriented toward registry-first connectors, separate integration artifacts, and a durable runtime for message and API traffic.
What MeshFlows optimizes for¶
1. Registry-first connectors¶
New systems become capability providers: they register with the Capability Registry, expose metadata, and are invoked from workflows via service_call — not as hardcoded engine nodes.
That model scales for teams that build and deploy their own connectors as Kubernetes microservices, without forking the Orchestrator for every new system.
See: Integration end-to-end, Capability provider contract.
2. Separation of concerns¶
Workflows, triggers, connections/secrets, policies/chains, and transforms are separate artifacts, not one monolithic flow graph.
That is closer to a light iPaaS / ESB shape than a single UI canvas (typical of many automation tools) or an in-app workflow library embedded in a product process.
See: Step types, Triggers, Step contract.
3. Runtime for integration traffic¶
The Engine is built for reliable message and API orchestration: async small/large tracks, checkpoints and resume, gateway policies, and edge routes — more than for quick SaaS glue automations.
See: Engine overview, Gateway flow policies, Edge routes.
4. Contracts over canvas¶
Authoring centers on YAML, a validated step contract, and capability metadata. Definitions stay reviewable, diffable, and CI-friendly. A Dashboard designer exists for authoring and inspection; the source of truth remains contract-oriented artifacts under Git.
5. Cloud and on-premises, same engine¶
Logic Apps and most SaaS iPaaS products are cloud-hosted; on-premises connectivity is a data gateway or hybrid add-on. MeshFlows deploys as Kubernetes you operate: on-prem next to line-of-business systems, and in Azure (AKS) with the same artifacts. That is the deployment differentiator versus a cloud-only iPaaS, not a second product SKU. See Capability comparison (gaps) (Networking — Shipped).
Short comparison¶
These comparisons are about fit, not ranking. Each tool is strong in its primary niche.
| Typical strength | Where MeshFlows tends to fit better | |
|---|---|---|
| n8n | Fast citizen / automation glue; UI-first SaaS connectors | Own capability providers, policies, and deployable integration services on your cluster |
| Elsa (and similar) | Embedded .NET workflow inside your application | Standalone integration runtime with discovery, egress providers, and gateway edge |
Choose something like n8n when the priority is rapid UI-driven automations across popular SaaS apps with minimal platform ownership.
Choose something like Elsa when workflow is a library concern inside an existing .NET application process.
Choose MeshFlows when you want a self-hosted integration platform: providers you own, separate triggers/connections/policies, a runtime aimed at durable orchestration of APIs and messages, and the same engine in the cloud and on-premises (your cluster) rather than a cloud-only iPaaS.
Roadmap: Logic Apps import¶
Vision / planned — Dashboard analysis MVP may be present; full convert is not shipped.
MeshFlows should import Azure Logic Apps definitions into native MeshFlows artifacts (workflows, triggers, connections, and related bindings).
Primary source: Logic Apps Standard workflow.json. ARM / Consumption
templates are a later second frontend on the same intermediate representation
(IR) — not a separate product path.
Why it fits: a Logic App is already a declarative graph — triggers, actions, connections, and policies. MeshFlows already separates those concerns into distinct artifacts. Import is a compiler/mapper problem (definition → IR → MeshFlows YAML and stubs), not a second runtime or a Logic Apps compatibility layer.
Dashboard-first approach¶
- Analyze — upload
workflow.jsonin the Dashboard → structured gap report (mapped / partial / unmapped, platform gaps, suggested conversions). - Convert (later) — emit MeshFlows artifacts + stubs + confidence report.
- ARM frontend (later) — parse ARM into the same IR used by Standard import.
See the detailed vision: Logic Apps Standard import.
Service Bus → RabbitMQ / meshflows.events¶
Azure Service Bus is a bridge provider, not the internal MeshFlows bus.
Azure Service Bus peek-lock triggers use the same subscriber pattern as
AMQP (azure-servicebus-trigger-subscriber, ADR 0015
option C). Native topic and queue publish plus mid-flow subscription/queue
peek-lock + complete/abandon/dead-letter exist as egress.azure.servicebus.*
(#127). On-premises deployments should generally use RabbitMQ for local
MeshFlows traffic and use Azure Service Bus selectively to cross into cloud
workloads such as Azure AI services.
Trigger-path ACK stays subscriber-owned (ADR 0013).
Managed Identity¶
Service Bus: auth: workload_identity + user-assigned MI via Azure Workload
Identity (ADR 0012, #128).
SAS connection strings remain the default.
Logic Apps import: MSI on Http / other connectors is still a P2 gap — the importer does not rewrite Azure identity resource IDs.
Phased approach¶
- Parse Standard
workflow.json→ IR — normalize triggers, actions, edges, bindings. - Map known actions → existing capabilities — e.g. HTTP to
egress.http.call, messaging to RabbitMQ /meshflows.eventswhere a clear equivalent exists. - Unknown actions → stub
service_call— placeholder “needs provider” so the graph stays complete and reviewable. - Connections →
flows/connections— map connection references with$secret:placeholders (no secret values in Git). - Later: richer constructs — ForEach, Switch, expression mapper, retry, concurrency; optional ARM frontend on the same IR.
MVP golden workflows / non-goals¶
Golden patterns: HTTP Request → Http/Liquid/Response; SB topic trigger → transform → (implicit RabbitMQ ACK); Recurrence → schedule.
Non-goals (MVP): full high-confidence convert of all actions; 1:1 peek-lock + complete steps; MSI implementation; ARM as the first frontend.
Positioning note: import targets contracts + providers (YAML, step contract, capability registration), not a locked-in UI graph. Teams can still author and extend providers for actions that have no built-in mapping — see Integration end-to-end and the Capability provider contract.
Related authoring surfaces: Triggers, Egress RabbitMQ, Step types, Logic Apps Standard import.