Skip to content

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

  1. Analyze — upload workflow.json in the Dashboard → structured gap report (mapped / partial / unmapped, platform gaps, suggested conversions).
  2. Convert (later) — emit MeshFlows artifacts + stubs + confidence report.
  3. 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

  1. Parse Standard workflow.json → IR — normalize triggers, actions, edges, bindings.
  2. Map known actions → existing capabilities — e.g. HTTP to egress.http.call, messaging to RabbitMQ / meshflows.events where a clear equivalent exists.
  3. Unknown actions → stub service_call — placeholder “needs provider” so the graph stays complete and reviewable.
  4. Connections → flows/connections — map connection references with $secret: placeholders (no secret values in Git).
  5. 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.