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).
waitis 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)¶
- Keep this page honest — update status when a gap actually ships.
- Logic Apps import convert — analysis/scaffolding exists; create-in-cluster and higher-confidence YAML are the migration story (import reference).
- Checkpoint / resume (ADR 0007) — without this, “long-running orchestration” is a stretch.
Do next (typical BizTalk migrant asks)¶
- JSON Schema / XSD validation — shipped (
transformers.validate_json_schema,transformers.validate_xsd). Catalog still open. - SOAP HTTP+XSLT recipe — shipped (howto
soap_http_xslt_demo). A WSDL/soap.callprovider is still later.- Dashboard DLQ / retry operator UX — first slice shipped (RabbitMQ view:
named
orchestrator.dlq/ retry queues, inspect payload/headers/correlation, retry one message toorchestrator.commands). - CSV transform — shipped (
transformers.csv_to_json/json_to_csv/xml_to_csv/csv_to_xml). - Business-event convention — shipped (
type: log+ Loki/LogQL). No BAM UI.
Do when a named customer needs it¶
- Entra OIDC for Dashboard login.
- OPA rules provider.
- Human-in-the-loop (approval task + resume).
- SAP (or other LOB) as a dedicated provider — never as an orchestrator step type.
- Workload identity (ADR 0012) for AKS → Azure APIs.
- 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¶
- Walk the table top-to-bottom; mark each customer requirement as MeshFlows can / pattern exists / gap.
- For every gap, decide: provider (weeks), platform ADR (months), or out of scope.
- Do not accept “we need a MessageBox”. Rewrite to durable queue + retry + DLQ
- correlation — MeshFlows already has those building blocks on RabbitMQ.
- 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”.