CareCompileMediFlow v14
14.1.1 — A service of CareCompile
MediFlow v14

Find the integration bug before go-live

MediFlow sends the HL7 v2 and FHIR R4 traffic a real hospital sends — admissions, orders, results, notes, claims — from a network of simulated hospitals into your systems, then scores what your systems did against a sealed answer key. Built for interface, lab-informatics and EHR go-live teams. No real patient data anywhere in the run.

356,444
HL7 Messages Sent
99.99%
ACK Success Rate
2,385
Synthetic Patients
6,126
AI Tasks Completed
0
Real PHI Used
Live from the MediFlow v14 engine · read Sep 29, 05:40 EDT
The MediFlow dashboard: patient and message counters, HL7 message-type breakdown, and a live send log showing raw HL7 v2.5.1 segments with ACK=AA responses.
The MediFlow dashboard, captured on an earlier release of the same engine that reports the numbers above — message-type breakdown, and a send log showing raw HL7 v2.5.1 with per-message ACK and latency. Not a mockup.

What changed in v14

v14 is about proving a receiver understands the code, not just accepts the message: a sealed, scored semantic test bench, and a release process gated on its own tests.

A semantic test bench, not a spec check
A library of 62 cases in 5 test families — potassium, sodium, glucose, creatinine and hemoglobin — across the hospitals switched on in the network. Each hospital codes the same test its own way, and the bench adds deliberate traps on top of that: a urine or whole-blood result given a serum-sounding name, a result reported per 24 hours instead of per sample, one hospital reusing another hospital's code, one hospital using a single name for two different tests, and abbreviations that read two ways. A runner seals the answer key before the first case is sent, the same discipline the rest of the platform already uses for its manifests.
Four outcomes, and two of them fail the run
Given the receiving system’s outcomes for the run, a scorer grades every case as resolved correctly, held for a human, wrong, or a false alert. Wrong and false alert both fail the run — there is no partial credit for confidently mapping a urine potassium to a serum reference range.
What it actually proves
In plain words: that a receiving system maps a hospital's local code to the right standard concept, holds what it cannot map for a person to review, and never files a urine result as a blood result. That is the failure mode the bench is built to catch, not throughput or uptime.
A release process gated on its own tests
v14 ships through a one-command release process, and the release is gated on the test suite: a build that fails its own tests does not become a release.
Earlier releases and delivery history

What changed in v12

v12 is about trusting the test data itself: every code checked against the official release, and every hospital a real one you control.

Every code checked against the source
A test that sends a code no longer in the code book does not test your system, it tests your error path — and it does it without telling you. In v12 every ICD-10-CM, RxNorm and CVX code MediFlow emits is checked against the published release, and the build fails on a code that is not billable, not current, or not a code at all. Getting there corrected 31 diagnosis codes and 3 medication identifiers that had drifted: category headers such as M54.5 and J45.9 that stopped being billable when they were subdivided, and a piperacillin-tazobactam identifier that is no longer in RxNorm. A historical vaccine code stays as it was given: a dose keeps the code of its day. This joins the LOINC gate that has run since v10.
Hospitals you manage, not hospitals we hard-coded
MediFlow used to send as eleven hospitals written into the source in four places. v12 makes them a registry of Utah rural hospitals that you switch on, switch off, or add to while the engine runs — each with its own identifier and NPI. A patient is assigned a hospital once and keeps it for life, so adding a hospital never rewrites the history of the patients already sent.
How a v12 run tests your system
A run is a sequence, not a file drop. MediFlow builds a clinically coherent encounter and records the outcome it should produce; sends it in clinical order over MLLP or HTTPS, or as FHIR R4, C-CDA or X12, under the sending facility's own identifier; reads back every acknowledgement, so an AE or AR is a reported failure rather than a silence; then scores what your environment actually did against that expected outcome and lists the defects by class. Deliberate awkward cases are part of it: the duplicate message, the transfer that arrives before its admission, the connection dropped mid-run, the code your system does not hold. What comes out is a scored run you can take to a go-live decision — see how a cutover rehearsal works.
Why it matters for a rehearsal
A migration rehearsal is only as good as its inputs. If the synthetic feed carries codes your production system would reject anyway, a clean run proves nothing and a dirty run sends you hunting the wrong defect. v12 makes the feed defensible: the codes are real, the hospitals are real, and every message says which hospital it came from.

What changed in v11

Released September 7, 2026. v11 adds the administrative half of interoperability to the clinical half v10 already had.

X12 005010
The claim lifecycle now goes out as real EDI: 837P professional claim, 835 remittance advice, 270/271 eligibility, 276/277 claim status and 278 prior authorization, each with the acknowledgements a trading partner expects — TA1 for the interchange envelope and 999 for the transaction set. Claims are built from the same encounter that produced the HL7 charge message, so the two reconcile by construction rather than by luck.
Three XML representations
Three different things get called healthcare XML and they are not interchangeable, so v11 speaks all three: HL7 v2.xml (the same v2 message in XML encoding, round-trip lossless back to pipe-delimited), FHIR XML alongside the existing FHIR JSON, and C-CDA — a Continuity of Care Document, which is a clinical document rather than a message, and is what moves at a transition of care.
SOAP for older middleware
A SOAP 1.1 document/literal endpoint with a generated WSDL, because a large amount of installed hospital middleware cannot call REST. Four operations: submit an HL7 message, submit an X12 interchange, fetch a patient summary, verify eligibility.
MSH-4 corrected
Through v10, every message stamped its own release into MSH-4 — the sending facility field. That made the release attributable, but it also partitioned every per-facility metric by software version instead of by site, which is not a trade a real deployment can make. Since September 2 the version travels in MSH-3, where it belongs, and MSH-4 carries a real facility. The same correction has now been applied to the inbound acknowledgement path, which had been missed.
Arithmetic that balances
Building real 835 remittances surfaced a defect that had been invisible while the same numbers were only ever rendered as JSON: a flat per-encounter copay was being charged against every service line, so patient responsibility could exceed the allowed amount and the line no longer reconciled. A remittance that does not balance cannot be posted. It is now asserted line by line in the test suite.
Validated, not just generated
Emitting EDI is the easy half. v11 also reads it: delimiters are discovered from the interchange header rather than assumed, envelope and segment counts are checked, and every structural defect is reported at once instead of one per round trip.

Every version, and what it actually sent

Each row is counted from the receiving system's own message log. Through v10 the release was read from MSH-4; since September 2 it is read from MSH-3, where the version now travels. Nothing here is authored by hand.

ReleaseIn serviceHL7 messages delivered
V4 Mar 25, 2026 – Apr 14, 2026 20,759
V5 Apr 14, 2026 – Jun 7, 2026 337,386
V6 Jun 7, 2026 – Jul 12, 2026 9,461
V7 Jul 13, 2026 – Jul 24, 2026 855
V8 Aug 17, 2026 – Aug 21, 2026 814
V10 Aug 21, 2026 – Sep 7, 2026 2,603
V11 Sep 7, 2026 – Sep 10, 2026 960
V12 Sep 20, 2026 – Sep 23, 2026 7,280
V14 Sep 24, 2026 – Sep 28, 2026 941
V14 Sep 29, 2026 – current in service now

Releases under 500 messages are omitted. Counts are delivered messages, not generated ones — a message only appears here once a receiving system acknowledged it.

How It Works

Test the whole clinical journey before a real patient enters it

Not another static dataset: a controlled patient story, executed against your environment, with an answer key. The same cohort can be replayed for an EHR migration, an interface-engine cutover, a FHIR API release or a go-live rehearsal.

01 / BUILD

Patient Cohort Builder

Generate condition-aware populations with configurable demographics, acuity, diagnoses, labs, medications, edge cases, expected outcomes, and replayable scenario identities.

02 / ORCHESTRATE

Scenario Studio

Turn each patient into a longitudinal story: registration, admission, orders, results, deterioration, intervention, recovery, discharge, and claim.

03 / DELIVER

Interoperability Delivery

Transmit through HL7 v2, FHIR R4 REST and Bundles, C-CDA, CSV, JSON, MLLP, HTTP, SFTP, and customer-specific interface profiles.

04 / ASSERT

Automated Validation

Check acceptance, patient identity, encounter linkage, critical alerts, idempotency, downstream state, timing, retries, and duplicate handling.

05 / PROVE

Evidence Pack

Deliver expected-versus-actual results, request and response hashes, ACK history, throughput, assertion results, and a signed reproducible run manifest.

registration → admission → orders → results → deterioration → intervention → recovery → discharge → claim → evidence
Synthetic by construction. MediFlow does not copy a production patient record into the test environment. Names, identifiers, encounters, and clinical events are generated for testing and carry explicit synthetic provenance. Live delivery remains controlled and off by default.
Example cohort request

Urban hospital integration rehearsal

population: 500 adult synthetic patients
clinical mix: 30 diabetes · 15 sepsis · 10 cardiac
identity cases: 5 duplicate MRNs · 3 A40 merges
safety cases: 2 medication-allergy conflicts · 6 panic labs
journey: admit → order → result → escalate → discharge → claim
evidence: assertions · ACK history · hashes · signed manifest

How the synthetic data is built →

MediFlow Scenario Library

Choose the failure you want to find before go-live

Each pack combines synthetic patients, executable clinical events, interface traffic, and expected outcomes. Run one scenario, a complete pack, or a hospital-specific validation program.

Pack 01 / IdentityAvailable

ADT & Patient Identity

Prove that registrations, encounters, transfers, discharges, updates, and identity corrections reach the correct chart.

  • New admission, transfer, discharge, and cancel-admit
  • Duplicate MRN and overlapping demographic match
  • ADT A40 merge with surviving and prior identifiers
  • Out-of-order discharge before admission
  • Patient update after identity merge
Expected proofCorrect patient, correct encounter, correct final census, no orphaned clinical data.
Pack 02 / Acute CareAvailable

Clinical Deterioration & Escalation

Exercise alerts and clinical escalation across a controlled worsening and recovery trajectory.

  • Sepsis cascade and septic shock
  • STEMI / NSTEMI and critical troponin
  • Acute ischemic stroke
  • DKA, pulmonary embolism, and respiratory failure
  • Rapid response, code blue, intervention, and recovery
Expected proofRequired alerts fire at the intended threshold, escalation is timely, and recovery clears the correct state.
Pack 03 / DiagnosticAvailable

Laboratory & Critical Results

Validate orders, specimens, serial results, critical-value handling, amendments, and result-to-patient linkage.

  • Hyperkalemia, troponin, sodium, glucose, INR, and creatinine panic values
  • Serial deterioration and improvement panels
  • Corrected and amended laboratory reports
  • Microbiology culture and susceptibility
  • Blood-bank order and result workflows
Expected proofResult lands on the intended order and encounter, critical routing occurs once, and amendments preserve history.
Pack 04 / PharmacyAvailable

Medication Lifecycle

Follow one medication identity from order through dispense, administration, bedside give, change, and discontinuation.

  • RDE order, RDS dispense, RAS administration, and RGV give
  • Medication-allergy conflict
  • Wrong-dose and wrong-unit exception
  • Discontinuation after dispense
  • Duplicate administration and replay protection
Expected proofOne order identity survives the lifecycle, unsafe conflicts are surfaced, and retries do not duplicate administration.
Pack 05 / RevenueAvailable

Eligibility, Claims & Denials

Test the financial journey from coverage and eligibility through charge capture, claim, denial, correction, and remittance.

  • Coverage and eligibility success / failure
  • Missing or inactive payer identifiers
  • Professional and institutional claim submission
  • Denial with known correction path
  • Remittance and account-balance update
Expected proofCorrect coverage is selected, failures are explainable, corrected claims reconcile, and balances close accurately.
Pack 06 / ReliabilityAvailable

Interface Resilience & Recovery

Deliberately break transport and message sequencing to prove how the environment fails, recovers, and reconciles.

  • Dropped ACK and safe retry
  • Duplicate message and idempotent replay
  • Malformed identifier or required segment
  • Unusual but legal vendor Z-segment
  • Listener downtime, dead-letter capture, and controlled recovery
Expected proofBad traffic fails closed, legal traffic is not over-rejected, replay is idempotent, and final state reconciles.

Need a scenario that matches your hospital?

We can configure units, patient mix, facility codes, assigning authorities, MRN format, code systems, custom segments, message timing, target endpoints, expected alerts, and evidence requirements around one real implementation objective.

Multi-Facility & Interoperability

A network of hospitals, one run, agreed in advance

A single-hospital test tells you an interface works. A network tells you whether it still works when many sites send at once and every message has to land against the right facility. MediFlow runs the whole network as one exercise — and both sides sign off on what will be sent before it is sent.

The network
A registry of simulated hospitals — Utah critical-access and rural hospitals plus the CareCompile Reference Hospital — each with its own organisation code, NPI, and its own MRN, visit and accession formats, so identifiers from different hospitals never collide. Send as one hospital or as the whole network in one run, over HL7 v2, FHIR R4, or both at once.
A sealed plan, before anything is sent
The run is planned first, not narrated afterwards. The engine produces a manifest that names every case, the facility it belongs to and the outcome it expects — which facility field the message must carry, and that the receiver must acknowledge it. That manifest is hashed and sealed. Change one case and the seal no longer verifies.
The receiver has to agree first
Nothing runs on the sender's say-so. The manifest is delivered to the receiving system and execution stays blocked until that side confirms it has loaded it, authorised by a named person. Until then the run reports itself as blocked and says why. A test where only the sender knew what was coming is not evidence; it is a demonstration.
Checked on the way out, reconciled on the way back
Every message is validated against its own manifest entry as it leaves — right facility, right identifiers, right provenance markers — and the acknowledgements are reconciled against the plan afterwards. What was promised, what was sent and what arrived are three lists that either match or do not.
Why this matters for a network
Per-facility reporting is the thing that breaks quietly. If every site's traffic carries the same identity, a receiver cannot tell one hospital's volume from another's — and nobody notices until someone asks for a per-site number. Running distinct facilities through a real receiver catches it before go-live.
Every format MediFlow speaks, in both directions: HL7 v2, v2.xml, FHIR R4, C-CDA, X12 005010, MLLP, SOAP

Each row is emitted and parsed by the engine, and the round trip is asserted in the test suite.

StandardWhat it carriesDirection
HL7 v2.xADT, ORM, ORU, MDM, DFT, SIU, OML, RDE, RDS, VXU, BAR, MFN — 36 message builders, v2.5.1send and receive
HL7 v2.xmlThe same messages in XML encoding, lossless back to pipe-delimitedsend and receive
FHIR R4Patient, Observation, Encounter and related resourcesJSON and XML
C-CDAContinuity of Care Document — problems, medications, results, vitals, allergiesproduce
X12 837PProfessional claim, built from the encounter that produced the charge messagesend
X12 835Remittance advice, including denials with real adjustment reason codesreceive
X12 270/271Eligibility inquiry and benefit responseboth
X12 276/277Claim status inquiry and responseboth
X12 278Services review — prior authorization request and determinationboth
TA1 / 999Interchange and implementation acknowledgementsboth
MLLPThe transport a lab analyser actually useslisten and send
SOAP 1.1document/literal, generated WSDL, four operationsserve

What this is not. None of it is a clearinghouse connection — nothing here transmits a claim to a payer. Interchanges are marked as test data in the envelope (ISA15 = T) because MediFlow's patients are synthetic, and a production marker would assert real claims about real people. The institutional claim format (837I) is not implemented: the engine generates professional-fee data, and producing an 837I from it would require revenue codes it does not have. EDI validation is structural — envelopes, counts, control numbers — not full implementation-guide conformance. The C-CDA is well-formed and carries correct template identifiers, but it has not been through a certified C-CDA R2.1 validator and is not claimed to be conformant to the complete guide.

Integration Testing

Every scenario ships its own answer key

MediFlow scenarios are not just demo data. Each scripted patient declares what your downstream system should conclude — the alerts, the flags, the critical values. Run the scenario, diff your system's actual output against the declared expectations, and a demo becomes a regression test.

The scenario declares
census_hf — Robert Thompson, 65M
Decompensated heart failure · ICD-10 I50.9 · ICU

expected_cc_alerts:
  • BNP critical high
  • Sodium low
  • Creatinine elevated
Your system must answer
Assertion result

BNP critical high — fired
Sodium low — fired
Creatinine elevated — fired

A missing alert is a clinical regression. An extra critical alert is an over-alarm bug. Either way, you know before a real patient does.

And what your interface does when the traffic is wrong

A cancellation retried after a dropped acknowledgement. A merge that lands after the update it invalidates. A discharge before the admit. One transposed digit in an MRN.

Receiver refused it
Receiver accepted it
Corrupted
message
corrupt → refused
Defended
The damage never reached a chart, and the sender was told why.
corrupt → accepted
Silent corruption
Bad data written to a patient record — and the sender was told everything was fine.
Unusual but
legal message
legal → refused
Over-rejection
Real clinical traffic blocked. The interface looks careful; the ward experiences an outage.
legal → accepted
Correct
Surplus fields and unknown vendor segments tolerated, exactly as the standard requires.

Both diagonals are failures, in opposite directions. An interface that refuses everything scores perfectly on the top row and catastrophically on the bottom — so the engine reports defence and compatibility as two separate numbers and never averages them into one.

A truth oracle, not a checklist

What a correct receiver ought to do is modelled once, as a state machine. Every expected outcome is derived, never hand-asserted, so scenarios do not go stale when a workflow changes.

Stateful sequences

Ordered sequences that each hunt one bug: cancel and replay, phantom admit, stale merge, out-of-order events, unmerge.

Acknowledgements read in full

AA/AE/AR and CA/CE/CR scored separately. A commit ACK is not success, a reply with the wrong control ID is quarantined, and no reply is recorded as silent loss.

Seeded mutation with a control group

Twenty-two replayable mutations across structure, identity, encoding and plausibility, plus unusual-but-legal traffic, so rejecting everything never scores well.

Crisis events and load

STEMI, sepsis cascade, code blue, DKA, stroke and more, on demand, with batch and unattended modes to find queue depth and throughput ceilings.

Failure injection and recovery

Stop a listener mid-batch and prove dead-letter capture, replay without duplicates and downstream reconciliation. Idempotency is judged from final state, not from the ACK.

HL7 v2.5.1 Compliant FHIR R4 Ready Zero Real PHI <30s Per Run Production-Grade Format 10 Hospital Units
Inside the Engine

A working hospital, generated

MediFlow delivers to any HL7 v2 or FHIR R4 receiver. It has been run against CareCompile, a VistA FHIR bridge, a WorldVistA EHR and OpenEMR.

Local fine-tuned models

Three domain models write the clinical notes, lab interpretations and pathology reports. They run on CareCompile's own hardware; nothing is sent to an outside AI service.

A standard 27-message run

Admission, 15 LOINC-coded lab panels, 11 clinical reports, telemetry and charges for every patient, with an ACK tracked per message per target.

Bed board, telemetry and events

Ten hospital units with live bed state, streaming vital signs, and one-click clinical events such as code blue, sepsis cascade and panic labs.

Nursing documentation

Eight shift-aware nursing note types sent as MDM^T02, from admission assessment to patient education.

Natural-language control

An agent with 24 tools admits patients, fires events and queries the census in plain language.

Unattended mode

Continuous admit, lab, event and discharge cycles for pipelines that need a live HL7 source around the clock, with an audit trail.

Access

A service of CareCompile, by contract

MediFlow is not sold as a stand-alone product and there is no public sign-in. It is delivered by CareCompile as part of an engagement, scoped to the workflow you need to trust.

Build

Scenario pack

A synthetic population and reusable scenarios for one workflow, interface or release.

  • Custom synthetic cohort
  • Happy paths and edge cases
  • Expected outcomes and answer key
  • HL7, FHIR, JSON and CSV exports
Protect

Continuous validation

Scheduled scenario suites and regression runs as your systems change, through CareCompile Cloud.

  • Scheduled suites
  • Saved interface profiles
  • Controlled replay
  • Historical evidence ledger

Access to MediFlow and CareCompile Cloud is by contract only. Tell us what you are validating and we will scope it with you.

Healthcare software vendors
Hospital interface teams
Clinical AI and CDS vendors
Implementation firms
Payers and RCM platforms
Questions

Synthetic healthcare data, clearly explained

What hospital, integration, and clinical AI teams usually ask before a first validation engagement.

What is synthetic patient data?

Synthetic patient data represents fictional people and clinical events created for development, testing, training, and validation. MediFlow builds complete, coherent patient journeys with known expected outcomes rather than copying a real patient chart.

Does MediFlow use real patient PHI?

MediFlow-generated cohorts are constructed without copying production patient records. Synthetic identifiers and provenance markers distinguish test traffic. A customer engagement can be designed to keep generation local and delivery disabled until an approved test destination is configured.

Can MediFlow generate HL7 and FHIR test data?

Yes. MediFlow creates HL7 v2 workflows and FHIR R4 resources and Bundles, with additional JSON and CSV exports. Customer profiles control identifiers, facility codes, assigning authorities, code systems, message conventions, and transport.

How do hospitals use synthetic patients?

Common uses include EHR migrations, interface-engine cutovers, lab and pharmacy validation, FHIR API testing, clinical decision-support evaluation, downtime and recovery drills, staff training, regression testing, and go-live rehearsals.

What makes MediFlow different from a static dataset?

Each scenario is executable and carries an answer key. MediFlow sends the patient journey into the target environment, observes acknowledgements and downstream state, then compares actual behavior with expected clinical and technical outcomes.

Are the codes in the test data still valid?

MediFlow checks every ICD-10-CM, LOINC, RxNorm and CVX code it emits against the published release before it ships, and the build fails on a code that is not billable, not current, or not a code at all. This matters because code books move: a diagnosis code that was billable last year becomes a category header once it is subdivided, and a test feed carrying it exercises your error path instead of your workflow. A historical immunisation keeps the CVX it was given under, which is correct.

Can I test more than one facility?

Yes. MediFlow keeps a registry of facilities, each with its own identifier and NPI in the message header, and a patient keeps the same facility for its whole history. Facilities can be switched on, switched off or added while the engine runs, so per-facility routing, coverage and onboarding can be rehearsed one site at a time rather than as one anonymous feed.

What does the evidence pack contain?

A run can include the scenario identity, synthetic cohort manifest, expected-versus-actual assertions, raw request and response hashes, ACK history, timing, throughput, failure details, and a signed reproducible manifest.

How do we get access to MediFlow?

MediFlow is a service of CareCompile. There is no public sign-in: access is by contract, delivered through CareCompile and CareCompile Cloud. Tell us the workflow you need to validate and we scope the engagement with you.

Live Demo

Generate a patient right now

Pick a scenario and watch MediFlow build a complete encounter: vitals, AI-authored notes and the 27 HL7 messages of a standard run. Demo mode: nothing is sent from this page.

mediflow-v14 — simulation engine
--:--:--Select a scenario above and click Generate Patient to run a simulation.
--:--:--MediFlow v14 will build a complete patient encounter with AI-authored notes. Nothing is sent from this page.
Request Access

Bring us the clinical journey you need to trust

Tell us what you are testing. Access is by contract through CareCompile; we will scope the synthetic patients, interface profile, expected outcomes, delivery path and evidence with you.

CompanyMediFlow is a service of CareCompile
ResponseWithin one business day
Direct contacthello@carecompile.com
AccessBy contract only — no public sign-in

Submitted securely to CareCompile. We respond within one business day. See the CareCompile privacy policy.

✓

Request received.

We will reply within one business day. For anything urgent, email hello@carecompile.com.