Skip to content

Capability comparison: BizTalk, Logic Apps, MeshFlows

This page fills the empty Alternative (n) column in a typical enterprise integration capability comparison (BizTalk Server vs Azure Logic Apps). It is an inventory of what MeshFlows can claim today, where the gaps are, and which gaps are worth working on.

Compare capabilities, not product features. Do not ask whether MeshFlows has a “MessageBox equivalent”; ask whether it supports durable messaging, pub/sub, routing, correlation, retries, and dead-letter handling.

Related: Why MeshFlows, Logic Apps import, Capability provider contract. Source ticket: issue #105.

Snapshot: MeshFlows main after issues #106–#111, #115, and native XML↔CSV (14 August 2026). Status is product truth, not marketing.

Where it runs: Logic Apps (and typical SaaS iPaaS) are cloud-hosted; on-premises systems reach them through a data gateway or hybrid connection. MeshFlows is the same engine in both places: on-premises Kubernetes next to the systems, and in the cloud (AKS). That is a Shipped networking fact, not a slogan or a second SKU. You still operate the cluster (Operations stays Partial).

Azure Service Bus as a bridge provider

Azure Service Bus is supported as a capability provider, not as the native MeshFlows backend bus. The provider bridges MeshFlows workflows and external Azure messaging or cloud services through the Capability Registry and service_call/trigger contracts. It supports topic and queue publish, peek-lock settlement, and topic/queue triggers without making Azure Service Bus the internal runtime dependency of the orchestrator.

For on-premises deployments, RabbitMQ and meshflows.events remain the more natural local platform bus: they keep high-volume internal traffic close to the workloads and avoid unnecessary cloud round trips. Azure Service Bus is a useful boundary for communication with cloud workloads, for example an Azure AI service or another Azure-hosted integration component. This keeps the local execution path fast while allowing selected workflows to cross the cloud boundary through an explicit provider.

Shipped since the inventory

The first draft of this page lived on branch docs/issue-105-capability-gaps. Read the MkDocs wiki (dev-wiki), not the Forgejo wiki mirror (that is only a pointer). These comparison tickets are on main:

Issue What shipped Row
#106 csv_to_json / json_to_csv plus native xml_to_csv / csv_to_xml Transformation
#107 / #108 validate_json_schema / validate_xsd Schema Registry (catalog still open)
#109 SOAP as HTTP + XSLT recipe + soap_http_xslt_demo Connectivity (no WSDL provider)
#110 Dashboard DLQ inspect + retry Messaging
#111 Business-event convention on type: log (Loki/LogQL) Observability (no BAM UI)
#115 CI govulncheck + NuGet --vulnerable beside pip-audit Operations tooling

Still not shipped (stay in the plan below): Logic Apps create-in-cluster convert, ADR 0007 checkpoint/resume, Entra, OPA, human-in-the-loop, SAP, Service Bus queue reconciliation and multi-subscription subscriber runtime. Topic-subscription and queue triggers, plus topic-subscription reconciliation, are now available behind an explicit deployment apply input.

Status Meaning
Shipped Present and usable in a real integration
Partial Exists, but thinner than BizTalk / Logic Apps for this row
Gap Missing, ADR-only, or not a product yet

Summary table

Capability BizTalk Server Azure Logic Apps MeshFlows Status Notes / mapping
Connectivity / Adapters BizTalk adapters Logic Apps connectors Capability providers + service_call Partial HTTP, FTP/SFTP, IMAP/SMTP, RabbitMQ, S3 (put/get/list/delete + object eventstream trigger), Postgres, Google Workspace, and Azure Service Bus as a bridge provider for topics and queues (publish, peek-lock/settlement, topic and queue triggers). SOAP is a documented HTTP+XSLT recipe (no WSDL). No SAP. New systems = new provider, not a new orchestrator node.
Workflow / Orchestration Orchestrations Logic Apps workflows YAML orchestrator (if / loop / parallel / try / compensate) Partial Strong control flow. Long-running dehydrate + human-in-the-loop are gaps. Checkpoint/resume is ADR 0007 (not shipped).
Messaging MessageBox-centric Azure messaging services RabbitMQ + meshflows.events internally; Azure Service Bus as an external bridge Partial Durable queues, topics, DSAV routing, retry, DLQ, correlation ids. RabbitMQ is the preferred local platform bus for on-prem traffic. Azure Service Bus provides provider-backed topic/queue publish, peek-lock/settlement, and triggers for selected cloud boundaries. Sequential convoys designed in ADR 0014 (not shipped). Queue reconciliation remains open.
Transformation Maps / XSLT XML, Liquid, XSLT Transformers provider + context steps Shipped XSLT 1.0, XML↔JSON, XML↔CSV, CSV↔JSON, Liquid, JSON Schema / XSD validate, XPath / JSON pointer, SES scripts. Flatfile POC: BizTalk wizard XSD (b:recordInfo) or JSON layout (flatfile_to_xml). No visual mapper; not a full FFDASM.
Extensibility Assemblies / pipelines Functions, inline .NET, custom APIs Capability registry (Python / Go / C#) Shipped This is the MeshFlows bet: own connectors as K8s microservices. SES for JS/Python/Bash; C# as a provider, not inline.
Schema Registry XSD schemas Integration Account / Standard schemas Artifacts + transformers validate Partial transformers.validate_json_schema / validate_xsd exist. No centralized Integration Account-style catalog.
Observability Admin Console / BAM Azure Monitor / App Insights / Invictus OTel + Tempo + Loki + Prometheus + Dashboard traces Partial Strong technical traces. Thin business-event convention (type: log) in Loki/LogQL. No BAM UI.
Security Windows Auth / SSO Entra ID, MSI, Key Vault JWT / OAuth2, IAM RBAC, connection secrets Partial Solid self-hosted model. No Entra / Managed Identity (ADR 0012 draft).
Operations Complex infra IaC + PaaS runtime Git + Kustomize + Forgejo Actions + Dashboard Partial You operate the cluster (BizTalk-like ownership, container-native). Not a Microsoft-managed PaaS.
Networking Native on-prem VNet + On-premises Data Gateway Same engine on-prem and in the cloud Shipped On-prem K8s and AKS are both first-class. Logic Apps stays a cloud iPaaS plus a data gateway for on-prem systems. MeshFlows needs no separate gateway product — you deploy the platform where the systems are (DC, factory, AKS).
Governance Roles / policies RBAC + Azure Policy IAM + gateway policy chains + Git review Partial Permissions, API products, throttle/OAuth/header policies. No Azure Policy equivalent.
Performance Battle-tested Platform-managed scale Two-track messaging + K8s limits Partial Architecture is there (small/large track, 16 MiB broker cap). Not proven at BizTalk/LA enterprise scale.
Developer Experience Visual Studio VS Code + designer YAML + Git + Dashboard designer Partial Diffable contracts are a strength. Designer and Logic Apps import are scaffolding, not a full convert.
Cost / Licensing Server / SQL licenses Usage or capacity GPL-3.0 + your cluster Shipped No per-workflow Microsoft tax. You pay compute, ops, and (optionally) commercial support.
Community Microsoft Integration Community Same Small / project community Gap Wiki + Forgejo. No public connector marketplace or large integrator ecosystem yet.
Business Rules BRE Workflow logic or OPA if / when / SES / variables Gap No BRE, no OPA. Rules live in workflow YAML or script. OPA-as-provider would fit the architecture.
Vendor Support / Maturity Mature, EOL soon Strategic Azure iPaaS Early-stage self-hosted platform Gap Honest: younger than both. Fit is “leave BizTalk without full Azure lock-in”.

Row-by-row

1. Connectivity / Adapters — Partial

Shipped providers: HTTP/REST (egress.http.call), FTP/FTPS, SSH/SFTP, IMAP, SMTP, RabbitMQ, S3/MinIO, PostgreSQL, Google Workspace (Gmail / Calendar / Drive), plus demo/SaaS examples (Weatherstack, Positionstack, Joke API).

How it maps: BizTalk “adapter” and Logic Apps “connector” become a capability provider that registers with the Capability Registry. Workflows call it with type: service_call + capability_name + path. Do not add new first-class orchestrator step types for each system.

Gaps: SAP, first-class SOAP/WSDL, Azure Service Bus queue entity reconciliation, JMS, SQL Server / Oracle, filesystem file-drop watcher (S3/MinIO object triggers cover object-store drops), 400+ SaaS connectors.

Workable: SOAP is a pattern (HTTP + XML + XSLT), not a product. Golden recipe + demo: SOAP over HTTP + XSLT (soap_http_xslt_demo). A thin SOAP/WSDL provider remains a later connector. SAP is large and customer-specific — only start with a named landscape. Service Bus topic publish + subscription peek-lock/complete is native (egress.azure.servicebus.*); topic subscription triggers use ADR 0015 option C (azure-servicebus-trigger-subscriber). Queue send/receive/settlement and queue triggers are shipped; queue entity reconciliation remains later. Logic Apps import can map peek-lock receive to the native trigger once that converter slice is built (Logic Apps import).

2. Workflow / Orchestration — Partial

Shipped: YAML workflows with if, for_each, repeat_until, parallel, try/catch, scope, workflow_call, wait (delay 0–3600s), compensate, run_after, workflow on_error / finally, HTTP / schedule / AMQP / Azure Service Bus / S3 object triggers.

Gaps vs the table notes (long-running, stateful, human-in-the-loop):

  • Runs execute in-process. Crash recovery / step resume is ADR 0007 (Proposed, not implemented).
  • wait is a delay, not dehydration of a dehydrated orchestration instance.
  • No approval / human-task step.

Workable: checkpoint + resume (ADR 0007) is the highest-leverage platform gap if someone asks “can it do BizTalk-style long-running orchestrations?”. Human-in-the-loop is a later product surface (Dashboard task + wait on external signal).

3. Messaging — Partial

Shipped: RabbitMQ as the local platform broker; durable topic meshflows.events; DSAV (Domain/Service/Action/Version) send/receive; AMQP trigger filters; small/large command tracks; retry queues; DLQ; correlation_id / X-Request-ID propagation; Dashboard operator UX to find orchestrator.dlq, inspect a message, and retry one message onto the command track.

Not 1:1 with Logic Apps peek-lock on RabbitMQ: the AMQP subscriber ACKs after synchronous Orchestrator invoke (ADR 0013). Native Azure Service Bus mid-flow peek-lock/complete exists on egress.azure.servicebus.subscription.*. Subscription triggers are ADR 0015 option C (azure-servicebus-trigger-subscriber, subscriber-owned complete).

Gaps: Service Bus queue reconciliation, JMS, BizTalk correlation sets / parallel convoys. Sequential convoys / in-order processing per business key is designed in ADR 0014 (not shipped). DLQ operator UX has a first Dashboard slice (find orchestrator.dlq / retry queues, inspect, retry one message to the command track).

Workable: keep RabbitMQ as the platform bus (that is the product choice). Improve DLQ/retry operator UX and extend the idempotent Azure Service Bus entity reconciler to queues. Native SB topic and queue send/receive/settlement plus topic and queue triggers (ADR 0015 option C) are shipped. Azure Service Bus remains an external bridge provider rather than a replacement for the local RabbitMQ bus.

4. Transformation — Shipped

Shipped: transformers.apply_xslt, xml2json, json2xml, apply_liquid, csv_to_json / json_to_csv, xml_to_csv / csv_to_xml, flatfile_to_xml / xml_to_flatfile (POC: BizTalk wizard XSD or JSON layout → nested XML), validate_json_schema, validate_xsd; context_extract_xml / _json; xml_set_text / json_set; SES JS/Python/Bash for glue.

Gaps: visual mapper (BizTalk maps); full BizTalk FFDASM (wrap chars, nested repeating groups, compile parse tables — this POC consumes wizard XSD tag identifiers + positional pos_length); XSLT 2.0/3.0 if a customer requires it and Saxon is not available.

Workable: visual mapper is low priority while YAML + artifacts stay the source of truth.

5. Extensibility — Shipped

This is MeshFlows’ strongest row against both columns.

New systems are HTTP microservices in Python, Go, or C# that register capabilities. C# “custom pipeline components” become providers, not GAC assemblies. Logic Apps “Azure Functions” map to SES (light) or a provider (real logic). See Add a capability provider and C# custom process.

6. Schema Registry — Partial

XSLT/Liquid/schema artifacts live with the flow. transformers.validate_json_schema and transformers.validate_xsd validate against those artifacts (HTTP 400 with path/message on invalid input). There is still no Integration Account / BizTalk-style central schema catalog.

Workable: a storage catalog of versioned schemas on top of the existing validators. High value for BizTalk migrants; medium effort.

7. Observability — Partial

Shipped: OpenTelemetry → Tempo, Loki, Prometheus; Dashboard run traces and step I/O; trigger audit events; cluster health; correlation headers. Thin business-event convention: existing type: log with tag business-event and marker meshflows.business_event (DSAV fields + business_id + outcome). Find it in Loki; count with LogQL. Demo: business_event_demo. Howto: Business events.

Gaps: BAM / business activity monitoring / Invictus-style business KPIs; polished Grafana packs as a product.

Workable: keep technical observability; the thin convention is the BAM precursor. Do not build a KPI dashboard until a named customer needs one.

8. Security — Partial

Shipped: Gateway as edge; JWT / OAuth2; IAM roles and permissions (ADR 0010); API keys and products; connection secret isolation (ADR 0011); HTTP/SSH egress allowlists; Azure Service Bus workload identity (ADR 0012).

Gaps: Entra ID SSO, HTTP egress MSI / other Azure connectors, native Key Vault. Secrets for non-Azure (and SAS fallback) live in MeshFlows storage / K8s secrets.

Workable: Entra OIDC login for the Dashboard is the first identity gap that hurts Azure-centric buyers. Service Bus can already drop SAS keys when the cluster federates a user-assigned MI.

9. Operations — Partial

Shipped: Git as source of truth; Kustomize overlays (lab, AKS, …); Forgejo Actions build/deploy; Dashboard for day-2; wiki.

Trade-off: MeshFlows is self-hosted. You get BizTalk-like control without SQL Server farms, but you do not get Logic Apps PaaS “Microsoft runs the runtime”. That is intentional positioning, not an accident.

10. Networking — Shipped

MeshFlows is not a cloud-only iPaaS. The same release runs on on-premises Kubernetes (next to line-of-business systems) and in the cloud (documented AKS overlay). Teams that cannot put every flow in Azure Logic Apps — data residency, shop floor, air-gapped DC, or “the systems stay on-prem” — still run the same YAML and providers; they can also run that same platform on AKS when Azure is the right place.

There is no On-premises Data Gateway because the platform sits on the same network as the adapters. Only the Gateway should be public; orchestrator and providers stay cluster-internal.

11. Governance — Partial

Shipped: IAM; gateway policy chains (throttle, OAuth outbound, XML/JSON, headers) in global → product → user → API layers; Git review of workflows, connections, and policies.

Gaps: Azure Policy / central org policy-as-code beyond Git conventions; multi-tenant org isolation as a product.

12. Performance — Partial

Two-track messaging (512 KB split, large payloads via MinIO), broker 16 MiB cap, resource-limit howtos, load-testing notes. Not yet a public scale study or SLA. Treat “battle-tested” as a claim MeshFlows should not make yet.

13. Developer Experience — Partial

YAML + step contract + capability metadata + CI is the authoring model. Dashboard designer and Logic Apps analyze + scaffolding preview exist; create-in-cluster and high-confidence convert are not shipped.

14. Cost / Licensing — Shipped

GPL-3.0. Cost is cluster + people, not BizTalk CALs or Logic Apps action meters. Commercial support can still be a separate conversation; the code is copyleft.

15. Community — Gap

No Microsoft Integration Community equivalent. Connector growth is in-repo / customer providers, not a marketplace.

16. Business Rules — Gap

No BRE. No OPA. Conditions live in if / when and in SES scripts.

Workable: an opa.evaluate capability provider is architecturally clean and matches how Logic Apps shops already talk about “external rules engines”.

17. Vendor Support / Product Maturity — Gap

BizTalk is mature and approaching end of life. Logic Apps is Microsoft’s strategic iPaaS. MeshFlows is younger: the runtime and provider model are real; import, dehydrate, BAM, and connector breadth are not at parity.

The honest pitch: self-hosted, registry-first integration platform for teams leaving BizTalk who will not (or cannot) standardise on a cloud-only iPaaS such as Azure Logic Apps — including estates that must keep the runtime on-premises and run the same stack in the cloud.


Plan of approach

Order is “what unblocks the comparison conversation”, not a full product roadmap.

Do now (platform credibility)

  1. Keep this page honest — update status when a gap actually ships.
  2. Logic Apps import convert — analysis/scaffolding exists; create-in-cluster and higher-confidence YAML are the migration story (import reference).
  3. Checkpoint / resume (ADR 0007) — without this, “long-running orchestration” is a stretch.

Do next (typical BizTalk migrant asks)

  1. JSON Schema / XSD validation — shipped (transformers.validate_json_schema, transformers.validate_xsd). Catalog still open.
  2. SOAP HTTP+XSLT recipe — shipped (howto
  3. soap_http_xslt_demo). A WSDL/soap.call provider is still later.
  4. Dashboard DLQ / retry operator UX — first slice shipped (RabbitMQ view: named orchestrator.dlq / retry queues, inspect payload/headers/correlation, retry one message to orchestrator.commands).
  5. CSV transform — shipped (transformers.csv_to_json / json_to_csv / xml_to_csv / csv_to_xml).
  6. Business-event convention — shipped (type: log + Loki/LogQL). No BAM UI.

Do when a named customer needs it

  1. Entra OIDC for Dashboard login.
  2. OPA rules provider.
  3. Human-in-the-loop (approval task + resume).
  4. SAP (or other LOB) as a dedicated provider — never as an orchestrator step type.
  5. Workload identity (ADR 0012) for AKS → Azure APIs.
  6. Native Service Bus — only if AMQP conversion is a deal-breaker.

Explicitly not competing 1:1

  • BizTalk MessageBox as a product feature
  • Visual Studio mapper / GAC pipelines
  • Logic Apps 400+ OOTB connectors (strategy is build the provider you need)
  • Microsoft-managed PaaS operations
  • Mid-flow Service Bus complete as a fake service_call (see ADR 0013)

How to use this in a requirements workshop

  1. Walk the table top-to-bottom; mark each customer requirement as MeshFlows can / pattern exists / gap.
  2. For every gap, decide: provider (weeks), platform ADR (months), or out of scope.
  3. Do not accept “we need a MessageBox”. Rewrite to durable queue + retry + DLQ
  4. correlation — MeshFlows already has those building blocks on RabbitMQ.
  5. For Logic Apps estates, start with Dashboard Platform → Logic Apps Import (analyze + scaffolding). Treat unmapped connectors as a provider backlog, not as a reason the orchestrator is “missing step types”.