The whole interface workflow, in one product
MessageFoundry isn't just an engine. It's the console your team watches, the editor where you configure, the service that runs your interfaces, and the harness that proves them — four pieces designed to work together, so a small team can run reliable interfaces with confidence.
Know your interfaces are healthy — at a glance
A desktop console that shows what's flowing right now, so problems surface before a clinician or a downstream system ever notices.
- Live dashboard — every connection's status and throughput in one view.
- Search and inspect any message, with a readable view of its HL7 structure.
- Delivery & audit trail — see exactly what happened to a message, and who looked at it.
- One-click replay — re-send a stored message after you've fixed the cause.
- Read-only by design — it reaches the engine over a local API, never the database directly.
Set up interfaces with wizards; use full Python for the tricky parts
A custom VS Code extension lets your whole team build interfaces in a familiar editor. Wizards generate the wiring for you; the full power of Python is there when a case gets genuinely complex.
- Setup wizards — guided New Connection and New Route flows generate the wiring so you don't start from a blank file.
- Validate as you save — mistakes are caught in the editor, not in production.
- Dry-run Test Bench — run a real message through a route and see the before/after, without touching a live system.
- Stage → Promote — push a reviewed change to a running engine when you're ready.
- Pipeline-ready — interfaces are plain Python in git, so they review in pull requests and test in your CI like any other code.
- AI assistance, PHI-safe — an in-editor assistant that helps author and migrate, sending only code, never message bodies.
Runs quietly in the background, where your data lives
The engine is built to run headless as a service in your own environment — on-prem or cloud — and keep moving messages reliably without anyone watching.
- Runs as a background service — install it as a Windows service with the included scripts.
- Headless and self-hosted — no GUI required; deploy it where your PHI already lives.
- Reliable by construction — durable delivery with automatic retries, dead-letter replay, and active-passive failover for high availability — no separate broker to run.
- Independent per destination — a slow or down peer never holds up the others.
- One local API — the console and the editor both attach to it; the deployment shape is a config choice.
Measured, with headroom. Per interface, MessageFoundry sustains a measured ~50 messages/second — roughly 180,000 messages an hour at that rate — with every message persisted to a durable store before it's acknowledged and delivered strictly in order: at-least-once, per-interface FIFO, nothing silently dropped. A typical hospital's full ADT feed uses only ~3-4% of that (roughly, and depending on the feed), so one interface is more than enough for a typical hospital's feed, and aggregate capacity grows as you add interfaces. Figures are measured on anonymized production telemetry; real throughput depends on your transforms, storage, and hardware. How throughput really works →
Prove an interface works before it goes live
A full harness ships with the product, so you can exercise interfaces with synthetic, PHI-free data — by hand while you build, and automatically in CI before you ship.
- Send / receive bench — drive inbound and outbound endpoints interactively as you develop.
- Automated scenario runner — assert routing and transform behavior on every change, in CI.
- Synthetic data generator — realistic, PHI-free HL7 for load and edge-case testing.
- Commit gate — validate configuration before it can ship.
- No real PHI required — prove correctness without ever touching patient data.
One product, end to end
Configure in your editor, run it as a service, watch it in the console, and prove it in the harness — all open source, all self-hosted.