Medical Device IntegrationFHIRHealthcare Interoperability

Medical Device Integration (2026): How It Works, Vendors, EHR Integration and FHIR

April 29, 202617 min readUpdated Nov 17, 2026
Written by
Jitendra Choudhary
Jitendra Choudhary

CTO & Co-Founder

CTO & Co-Founder at Nirmitee.io. Architects healthcare integrations across FHIR, SMART on FHIR, ABDM and NHCX, writing from production experience taking hospital software from sandbox to go-live.

Medical Device Integration (2026): How It Works, Vendors, EHR Integration and FHIR

Medical device integration (MDI) connects bedside and biomedical devices, such as patient monitors, ventilators, infusion pumps and vital signs machines, to the electronic health record, so readings flow into the patient's chart automatically instead of being typed in by a nurse. A device integration platform collects the data from each device, ties it to the right patient, translates it into HL7 v2 or FHIR, and sends it to the EHR, alarm systems and dashboards.

This guide is for hospital IT leaders, clinical engineering teams and health-tech product teams choosing how to integrate medical devices. The first half covers what MDI is, how it works, the main vendors and platforms, build versus buy, and the implementation steps. The second half is the technical part: IEEE 11073, IHE device profiles, FHIR Device and Observation resources, and the new FHIR DeviceAlert resource. Updated October 2026.

What is medical device integration?

Medical device integration is the automatic, validated transfer of data from medical devices into clinical systems, mainly the EHR. Without it, a nurse reads the monitor and types the numbers into a flowsheet, which is slow and error-prone.

The term covers a few related jobs:

  • Vitals documentation: monitors and spot-check vital signs machines send heart rate, blood pressure, SpO2, respiratory rate and temperature to the EHR flowsheet, where a nurse reviews and validates them.
  • Continuous ICU and OR data: ventilators, anesthesia machines and multi-parameter monitors send frequent numeric data, and sometimes waveforms, into the ICU or anesthesia record.
  • Infusion pump interoperability: the EHR sends the pump order (auto-programming) and the pump sends back what it actually delivered (auto-documentation).
  • Alarm and alert communication: device alarms are routed to the right nurse's phone or the nurse call system, and logged.
  • Biomedical device management: device inventory, status and maintenance data go to clinical engineering systems (CMMS).

"Biomedical device integration" and "medical device integration" usually mean the same thing. Clinical engineering (biomed) teams often own the devices, while IT owns the integration platform, so a project needs both. If you need a team to scope or build it, see our medical device integration services.

Why hospitals integrate medical devices

The main reasons are fewer transcription errors, faster documentation and better data for clinical decisions. The evidence is real but mostly from smaller studies, so treat specific percentages as examples, not promises.

  • Fewer documentation errors. In a study of 1,933 vital signs records on a 23-bed medical-surgical unit, data errors fell from about 20% with manual entry to near zero with automated entry (Plass and Richardson).
  • Nurses see the risk. In a Harris Poll survey of 526 nurses for the West Health Institute, half said they had witnessed a medical error caused by a lack of device coordination.
  • Data for early warning scores and analytics. Sepsis alerts, deterioration scores and ICU dashboards only work if the vitals arrive in the EHR quickly and attached to the right patient.
  • Alarm management. The Joint Commission's Sentinel Event Alert 50 on alarm safety cited studies finding that 85% to 99% of alarm signals do not need clinical intervention. Integrated alarm data lets a hospital measure and reduce that noise.

One caution: integration does not remove the nurse's review. Most hospitals require a clinician to validate device data before it becomes part of the legal record.

How medical device integration works

Data passes through four layers: the device, a device gateway or middleware, an integration engine, and the receiving systems. Each layer has a different owner and a different failure mode.

  1. The device produces data. Modern devices speak a vendor protocol, IEEE 11073 SDC, or HL7 v2 over the network. Older ones use RS-232 serial ports, which need a small hardware adapter at the bedside.
  2. The gateway or MDI middleware collects it. It runs a driver for each device model, buffers data during network drops, and normalizes values and units. Monitor vendors often supply their own gateway for their monitors.
  3. Patient association. The system works out which patient the device is attached to, usually from the ADT feed (admit, discharge, transfer events) plus a bed location or a barcode scan. This is the step that most often goes wrong. See below.
  4. Translation and routing. The data is sent as HL7 v2 ORU messages (the IHE "DEC" profile) or as FHIR Observations, through an HL7 integration engine such as Mirth Connect, Rhapsody or InterSystems.
  5. The EHR receives it. Epic, Oracle Health and other EHRs show the values in a flowsheet as "unvalidated" until a nurse accepts them.

Which devices can be integrated?

Almost any networked or serial device can be integrated, but the effort and value differ a lot by category.

Device categoryTypical dataUsual connectionMain valueWatch out for
Multi-parameter patient monitors (ICU, ED, step-down)HR, NIBP, SpO2, RR, temperature, ST; sometimes waveformsVendor gateway (for example GE Carescape Gateway+), HL7 v2Automatic vitals charting, ICU dashboardsData volume, monitor-to-bed mapping when patients move
Spot-check vital signs machines (med-surg)One set of vitals per checkWi-Fi to vendor server, barcode patient IDBiggest nursing time saving on general wardsScanning discipline; wrong-patient risk if scans are skipped
VentilatorsMode, settings, measured volumes and pressuresSerial or network via MDI middlewareRespiratory charting, ventilator weaning dataMany models need specific drivers
Smart infusion pumpsDrug, rate, volume infused, statusPump vendor server plus EHR integrationAuto-programming and auto-documentation, fewer medication errorsNeeds pharmacy, nursing and EHR build together; drug library alignment
Anesthesia machinesGases, ventilation, vitalsSerial or network via MDI middlewareAnesthesia record completenessHigh frequency data in the OR
Point-of-care testing (glucose, blood gas)Results with operator IDPOCT middleware to LIS, then EHRResults in the chart quickly with QC dataUsually routed through the lab system, not MDI
Home and remote monitoring devicesBP, weight, glucose, SpO2Bluetooth to phone or cellular hub, then cloud APIRemote patient monitoring programsDifferent architecture; see our RPM data pipeline guide

Medical device integration vendors and platforms

The market splits into vendor-neutral MDI platforms, monitor vendors' own gateways, EHR vendors' device modules, and general integration engines. The table below lists well-known options, checked against each company's public material in October 2026. Features change, so confirm current device driver lists and FDA clearances with each vendor before you shortlist.

PlatformTypeWhat it does, per the vendorFits best when
Philips Capsule Medical Device Information Platform (MDIP)Vendor-neutral MDI platformDevice drivers for more than 1,000 device models (Philips, 2021), feeding EHRs and other systems. Philips bought Capsule in 2021. Capsule had earlier acquired Bernoulli (2019), whose Bernoulli One surveillance product is now part of this family.Large health systems with many device makers who want one enterprise platform
GE HealthCare Carescape Gateway+Monitor vendor gatewayAggregates GE monitoring data and sends numerics, alarms and waveforms out using IHE device profiles (DEC, ACM, WCM)Hospitals standardized on GE monitors
Masimo Iris GatewayMonitor vendor gateway plus third-party devicesTranslates device data into HL7 for EMRs, uses ADT for patient association; other devices connect through Masimo RootHospitals using Masimo Root at the bedside
Ascom Digistat ConnectVendor-neutral MDI softwareAcquires data, alarms and events from monitors, ventilators and pumps into one stream for the EMR; ask the vendor which modules are FDA clearedHospitals that also want alarm routing to staff phones
Oracle Health CareAware (Bedside Medical Device Integration)EHR vendor device moduleDevice connectivity for Oracle Health (Cerner) sites, with a published supported-device catalogOracle Health EHR customers
General integration engines (Mirth Connect, Rhapsody, InterSystems)Integration engineRoute and translate HL7 v2 and FHIR; do not include bedside device drivers on their ownRouting device data that is already HL7 or FHIR, or connecting an MDI platform to many systems

Epic customers usually connect a third-party MDI platform or a monitor vendor gateway to Epic's flowsheets through HL7 interfaces. Our Epic integration team can explain what Epic needs on its side. For choosing the integration engine that sits between the systems, see how to choose a healthcare integration platform.

How to evaluate a medical device integration vendor

  1. Driver coverage for your actual fleet. Export your device inventory by make, model and firmware, and ask for a written match. "Supports 1,000 models" means nothing if your ventilators are not on the list.
  2. Patient association method. ADT plus bed location, barcode scan, or both. Ask how it handles transfers and shared rooms.
  3. EHR connection. Which HL7 messages or FHIR resources it sends, and how many live sites use your EHR version.
  4. Regulatory status. Which parts are FDA cleared (for example, alarm forwarding is often regulated, plain data transfer often is not). Get the 510(k) numbers.
  5. Uptime and buffering. What happens to data during a network or server outage, and how it backfills.
  6. Security. Network segmentation, encryption, patching of the gateway, and a signed BAA.
  7. Total cost. Licenses per bed or per device, hardware adapters for serial devices, interface fees from the EHR vendor, and the internal staff to run it.

Build vs buy: should you build your own device integration?

For bedside devices inside a hospital, buy a platform. Writing and maintaining drivers for dozens of device models, and taking on the regulatory responsibility for alarm handling, is rarely worth it. Building makes sense in narrower cases.

If you want a team to connect device data and your EHR for you, see our EHR and EMR integration services.

SituationRecommendation
Hospital with many device makers, documentation into Epic or Oracle HealthBuy an MDI platform, connect it to the EHR through your integration engine
Hospital standardized on one monitor vendorStart with that vendor's gateway; add a neutral platform when other devices join
Medical device company that needs its device data in hospital EHRsBuild an HL7 v2 or FHIR interface on your device or cloud, following IHE device profiles, so hospital MDI platforms and engines can consume it
Remote patient monitoring or wearables programBuild or buy a cloud pipeline; bedside MDI platforms are not designed for home devices
Research, analytics or an ICU dashboard on top of existing feedsBuild the analytics layer; take the data from the MDI platform or the EHR, not from devices directly

The hard parts: patient association, stale readings and alarms

Patient-device association

Every reading must land on the right patient. Bed-based association uses the ADT feed: if bed 4 belongs to patient A, monitor 4's data goes to patient A. It fails when a patient moves and the monitor goes with them, when the ADT transfer is entered late, or when two patients share a room. Barcode association (scan the patient wristband, then the device) is more reliable but depends on staff doing it. Good systems show the nurse the patient name on the device or in the EHR before data files, and stop sending when the association is unclear.

Stale and duplicate readings

A gateway that reconnects after an outage may resend old data, and a device clock that has drifted may stamp the wrong time. Use the device's measurement time, check device clocks against the network time source, reject readings older than a set window for "current vitals" displays, and deduplicate on device, parameter and timestamp. Show the age of every value on dashboards so a clinician never mistakes a 40-minute-old reading for a live one.

Alarm data

Sending device alarms to phones or nurse call is a different and more regulated job than documenting vitals. Use the IHE Alert Communication Management (ACM) profile or the vendor's cleared alarm product, and test escalation when an alarm is not acknowledged. Our guide on nurse call system integration covers the hospital side.

Medical device EHR integration: implementation steps and who owns what

StepWhat happensOwner
1. InventoryList devices by unit, make, model, firmware and connection typeClinical engineering
2. Scope and workflowDecide which parameters chart, how often, and who validatesNursing informatics
3. Platform choiceMatch the inventory to vendor driver lists, confirm EHR supportIT with clinical engineering
4. Network and securityDevice VLANs, gateway servers, encryption, BAAIT infrastructure and security
5. InterfacesADT feed to the platform, results feed to the EHR through the engineIntegration team
6. EHR buildFlowsheet rows, mapping of device parameters, validation screensEHR analysts
7. TestingEvery device model and parameter checked end to end, including transfers and outagesIntegration, clinical engineering, nursing
8. Pilot and go-liveOne unit first, at-the-elbow support, then roll out unit by unitNursing and IT
9. MonitoringInterface alerts, data gaps by device, association errorsIntegration support

Timelines depend on the number of units, device models and EHR build queues, so plan after the inventory, not before.

The standards: IEEE 11073, IHE device profiles, HL7 v2 and FHIR

You do not need these details to buy a platform, but you need them to build an interface or to check a vendor's claims.

IEEE 11073

IEEE 11073 is the family of standards for medical device communication. Three parts matter most:

  • IEEE 11073-10101 (nomenclature): numeric codes for each measurement, such as 150456 for SpO2 (MDC_PULS_OXIM_SAT_O2).
  • IEEE 11073-10201 (domain information model): the object model of a device: Medical Device System, Virtual Medical Device, Channel and Metric.
  • IEEE 11073 SDC (Service-oriented Device Connectivity, 11073-20701 and related parts): the newer network protocol for device-to-device and device-to-gateway exchange in the OR and ICU. Personal health devices such as home blood pressure cuffs use the separate 11073-20601 family.

Which device integration platforms support IEEE 11073 SDC for bedside data exchange into the EHR? SDC support is still growing, mainly in newer OR and ICU devices. Draeger publishes an open-source Python SDC library (sdc11073). In practice, most bedside data still reaches the EHR as HL7 v2, with the gateway or MDI platform converting from SDC or vendor protocols. Ask each vendor for a list of SDC devices it supports in production, not just on its roadmap.

IHE device profiles

ProfilePurposeMessage
DEC (Device Enterprise Communication)Send device observations to the EHR or a data repositoryHL7 v2.6 ORU^R01 (transaction PCD-01), coded with IEEE 11073 terms
ACM (Alert Communication Management)Send device alarms to people, with escalationPCD-04 to PCD-07 alarm and status transactions
WCM (Waveform Content Module)Carry waveform data in DEC messagesHL7 v2 observation segments

Protocol comparison

ProtocolTransportPrimary useMapping effort to FHIR
IEEE 11073 SDCTCP/IP web servicesOR and ICU device networksMedium (well-defined model)
IEEE 11073-20601 over BluetoothBluetoothPersonal health devicesLow
HL7 v2 (IHE DEC)MLLP over TCPGateways to EHRsMedium (v2 to FHIR mapping)
Serial RS-232Serial cable plus adapterOlder devicesHigh (proprietary formats)
FHIR RESTHTTPSCloud gateways, newer systemsNone

FHIR resources for medical devices

FHIR represents a device with the Device resource, each measurement channel with DeviceMetric, and each reading with an Observation that points back to the Device. The Observation's device element is what separates device-sourced data from manually entered values.

Device

{
  "resourceType": "Device",
  "id": "bedside-monitor-icu-204",
  "identifier": [{ "system": "urn:example:biomed-asset-tag", "value": "MON-0204" }],
  "status": "active",
  "manufacturer": "Example Monitor Co",
  "modelNumber": "M-100",
  "type": {
    "coding": [{ "system": "urn:iso:std:iso:11073:10101", "code": "69965", "display": "Patient monitor" }]
  },
  "location": { "reference": "Location/icu-bed-204" }
}

DeviceMetric

{
  "resourceType": "DeviceMetric",
  "id": "spo2-metric-icu204",
  "type": {
    "coding": [{ "system": "urn:iso:std:iso:11073:10101", "code": "150456", "display": "MDC_PULS_OXIM_SAT_O2" }]
  },
  "device": { "reference": "Device/bedside-monitor-icu-204" },
  "operationalStatus": "on",
  "category": "measurement"
}

Device-sourced Observation

{
  "resourceType": "Observation",
  "status": "preliminary",
  "category": [{ "coding": [{ "system": "http://terminology.hl7.org/CodeSystem/observation-category", "code": "vital-signs" }] }],
  "code": {
    "coding": [
      { "system": "http://loinc.org", "code": "59408-5", "display": "Oxygen saturation in Arterial blood by Pulse oximetry" },
      { "system": "urn:iso:std:iso:11073:10101", "code": "150456" }
    ]
  },
  "subject": { "reference": "Patient/example" },
  "effectiveDateTime": "2026-10-14T14:30:22Z",
  "valueQuantity": { "value": 96, "unit": "%", "system": "http://unitsofmeasure.org", "code": "%" },
  "device": { "reference": "Device/bedside-monitor-icu-204" }
}

The status is "preliminary" because a nurse has not yet validated the value. Many systems change it to "final" on validation.

IEEE 11073 to FHIR mapping

IEEE 11073 conceptFHIR resourceKey fields
Medical Device System (MDS)Deviceidentifier, manufacturer, modelNumber
Virtual Medical Device (VMD)Device (child)parent reference
Channel and MetricDeviceMetrictype, unit, device
Numeric observationObservationvalueQuantity, device, effectiveDateTime
Compound numeric (for example NIBP)Observation with componentscomponent[] for systolic, diastolic, mean
Real-time sample array (waveform)ObservationvalueSampledData
Alert condition and signalDeviceAlert (FHIR R6 build)condition, priority, signal

Example: translate a gateway reading into a FHIR Observation

"""Minimal device reading to FHIR Observation translation."""
from dataclasses import dataclass

# IEEE 11073-10101 code to LOINC (vital signs)
IEEE_TO_LOINC = {
    "150456": ("59408-5", "Oxygen saturation by pulse oximetry"),
    "147842": ("8867-4", "Heart rate"),
    "151562": ("9279-1", "Respiratory rate"),
    "150021": ("8480-6", "Systolic blood pressure"),
    "150022": ("8462-4", "Diastolic blood pressure"),
    "150023": ("8478-0", "Mean blood pressure"),
    "150364": ("8310-5", "Body temperature"),
}

@dataclass
class DeviceReading:
    device_id: str
    patient_id: str      # from ADT or barcode association, never guessed
    ieee_code: str
    value: float
    ucum_unit: str
    measured_at: str     # device measurement time, not receive time

def to_observation(r: DeviceReading) -> dict:
    loinc, display = IEEE_TO_LOINC[r.ieee_code]  # fail loudly on unmapped codes
    return {
        "resourceType": "Observation",
        "status": "preliminary",
        "category": [{"coding": [{"system": "http://terminology.hl7.org/CodeSystem/observation-category", "code": "vital-signs"}]}],
        "code": {"coding": [
            {"system": "http://loinc.org", "code": loinc, "display": display},
            {"system": "urn:iso:std:iso:11073:10101", "code": r.ieee_code},
        ]},
        "subject": {"reference": f"Patient/{r.patient_id}"},
        "effectiveDateTime": r.measured_at,
        "valueQuantity": {"value": r.value, "unit": r.ucum_unit, "system": "http://unitsofmeasure.org", "code": r.ucum_unit},
        "device": {"reference": f"Device/{r.device_id}"},
    }

Handling high-frequency data

A monitor can produce a value every second or two per parameter. Do not send every one to the EHR. Common choices:

  • Chart at the interval nursing policy requires (for example every 15 minutes in the ICU) and keep the full stream in a separate store.
  • Batch observations into FHIR transaction or batch Bundles.
  • Put a queue (Kafka or RabbitMQ) between the gateway and the FHIR server so a slow server does not drop data.
  • Use FHIR Subscriptions for real-time consumers instead of polling.

The FHIR DeviceAlert resource

DeviceAlert is a new resource in the FHIR R6 work that represents a single alert condition detected and signaled by a device. Before it, device alarms were squeezed into Observation or DetectedIssue, which could not hold alarm priority, signal state or acknowledgment cleanly.

The current FHIR build marks DeviceAlert as Normative, the most stable status. R6 is not yet a published FHIR release, though, and few EHRs or device gateways support DeviceAlert today, so use IHE ACM or HL7 v2 for alarm exchange in production and plan DeviceAlert as the next step.

Why it matters: a standard alert record lets hospitals measure alarm counts, response times and silencing per unit and device, which is how alarm fatigue programs show progress. See our piece on alert fatigue for the clinical side.

Waveforms, nurse call and CMMS

  • Waveforms (ECG, arterial pressure) are large. FHIR can carry them in SampledData, and IHE WCM carries them in HL7 v2, but most EHRs store snapshots or links, with full waveforms in a dedicated store.
  • Nurse call systems receive routed alarms and send acknowledgments back; test the escalation path end to end.
  • CMMS (computerized maintenance management) systems use device identity, status and error data for maintenance and recalls, so keep the Device resource's identifiers aligned with the biomed asset tag.

Plan your medical device integration

Start with an inventory of your devices and a clear decision on what should chart automatically. From there the platform choice, the EHR build and the test plan follow. If you want help, our medical device integration team scopes device inventories, connects MDI platforms to Epic and other EHRs through HL7 and FHIR, and builds FHIR interfaces for device makers. We sign a BAA and work under ISO 27001:2022 controls.

Ready to scale?

Talk to our healthcare engineering team about building, integrating, and shipping faster.

Frequently Asked Questions

What is medical device integration?

Medical device integration (MDI) is the automatic transfer of data from medical devices such as patient monitors, ventilators, infusion pumps and vital signs machines into the EHR and other clinical systems. A gateway or MDI platform collects the data, links it to the right patient, translates it to HL7 v2 or FHIR, and sends it to the chart, where a nurse validates it.

How does medical device integration with the EHR work?

Devices send data to a gateway or MDI middleware, which uses device drivers, associates each reading with a patient using the ADT feed, bed location or a barcode scan, and checks timestamps. An integration engine then sends HL7 v2 ORU messages (IHE DEC profile) or FHIR Observations to the EHR flowsheet, where values wait for nurse validation.

Who are the main medical device integration vendors?

Well-known options include Philips Capsule Medical Device Information Platform (which also absorbed Bernoulli), GE HealthCare Carescape Gateway+, Masimo Iris Gateway, Ascom Digistat Connect and Oracle Health CareAware for Oracle Health EHR sites. Check each vendor's current driver list against your own device inventory before you shortlist.

What is the difference between medical device integration and biomedical device integration?

The terms usually mean the same thing. Biomedical or clinical engineering teams own the devices, and IT owns the integration platform and interfaces, so a medical device integration project needs both teams.

Should a hospital build or buy a medical device integration platform?

Most hospitals should buy an MDI platform for bedside devices, because maintaining drivers for many device models and taking on regulated alarm handling is expensive. Building makes sense for device makers who need their own device to reach EHRs, for remote patient monitoring, and for analytics or dashboards on top of existing feeds.

Which device integration platforms support IEEE 11073 SDC for bedside data exchange into the EHR?

IEEE 11073 SDC support is growing in newer OR and ICU devices, and Draeger publishes an open-source sdc11073 library. Most bedside data still reaches the EHR as HL7 v2, with the gateway converting from SDC or vendor protocols. Ask each vendor which SDC devices it supports in production today.

How is FHIR used in medical device integration?

FHIR represents the device with the Device resource, each measurement channel with DeviceMetric, and each reading with an Observation that references the Device. The newer DeviceAlert resource in the FHIR R6 work represents device alarms, and the current FHIR build marks it Normative; because R6 is not yet published and support is thin, most production alarm exchange still uses IHE ACM or HL7 v2.

What are the biggest risks in medical device integration?

Wrong-patient data from poor patient-device association, stale or duplicate readings after outages or clock drift, gaps in device driver coverage, and alarm routing that is not tested for escalation. Good projects test every device model end to end, including transfers and outages, before go-live.
Share