The proposal looks tidy. One page, item four: “Bidirectional integration with the hospital EHR, HL7 FHIR compliant, eight weeks, fixed price.” The digital health company signs, because the word “standard” sounds like a promise that nothing has to be invented. In week three the team learns that the hospital’s lab results do not come through FHIR at all; they arrive as HL7 v2 ORU messages through an interface engine, with local test codes nobody has a dictionary for. In week five, the EHR vendor’s FHIR sandbox turns out to support reads but not the writes the product depends on. In week nine the first change request arrives.

Nobody lied. “FHIR compliant” was true, and it said nothing about what had to be built. This is the most common pattern we see in conversations about healthcare integrations: a standard appears in the scope instead of a scope.

This article is for CTOs and engineering leaders at providers and health-tech companies who are commissioning, or pricing, an EHR or EMR integration. The thesis is specific, and some vendors will disagree with it: a healthcare integration should be scoped, priced and accepted flow by flow, with named profiles, versions and code systems, never “to the standard”. FHIR is an agreement about syntax and exchange. Most of the cost sits elsewhere: in mapping meaning, terminology, patient identity, error handling and conformance testing. A proposal that does not itemise those is not cheaper; it simply defers the bill.

Why does “we have a FHIR API” not answer the cost question?

HL7 FHIR (Fast Healthcare Interoperability Resources) defines resources such as Patient, Encounter, Observation and DocumentReference, and a RESTful way to exchange them. Release 4, published in 2019, is the version most of the market implemented, including the US certification requirements. Release 5 followed in 2023, but production integrations still overwhelmingly run on R4. That already raises a decision “FHIR compliant” does not settle: which release are we on, and what happens when the other side moves?

The base FHIR resources are deliberately loose. A Patient can carry zero or many identifiers, an Observation can be coded in any code system, and most elements are optional. Every real deployment therefore constrains resources with profiles: rules about which elements are required, which value sets apply and which extensions are allowed. In the United States the baseline is US Core; EHR vendors publish their own profiles and documentation on top of it; European countries publish national implementation guides. Two systems that are both “FHIR R4 compliant” may not be able to exchange a single valid resource if they implement different profiles.

The second layer is meaning. FHIR tells you how to represent an observation, not whether “HGB” in lab system A is the same value as “Hemoglobin” in system B, in the same unit and measured the same way. That is semantic interoperability, and no transport standard solves it. A code map solves it, and somebody has to build it, have it reviewed by a clinician and maintain it.

The third layer is workflow. An integration never moves data in a vacuum; it moves data as part of an event: an admission, a lab order, a discharge, a referral. Each event has its own sequence, its own exceptions (corrections, cancellations, a change of attending physician) and its own legal requirements. The number and complexity of those workflows sets the cost, not the number of FHIR resources involved.

So for the buyer the conclusion is simple. “Do you have a FHIR API?” is a question about a precondition, not about scope. The scope is a list of flows.

What are you actually integrating with in the US and the EU?

The regulatory landscape decides which interfaces exist on the other side, so it is worth knowing before you write a statement of work.

United States. The 21st Century Cures Act of 2016 pushed certified EHRs towards open, standardised APIs and introduced the information blocking rules, which have applied since April 2021. Under the certification criterion for standardised API access, known as § 170.315(g)(10), certified EHRs must expose FHIR R4 APIs for single-patient and population access, using US Core, SMART App Launch for authorisation and Bulk Data Access for population exports. The HTI-1 final rule from the Office of the National Coordinator, now the Assistant Secretary for Technology Policy (ASTP/ONC), made USCDI version 3 the baseline data set, with US Core 6.1.0 and C-CDA Companion Guide R4.1, from 1 January 2026. ASTP/ONC published an enforcement discretion notice in November 2025 relaxing direct review for developers who missed that date solely because of the required updates, so in practice you will meet EHRs at different points of that transition.

On the payer side, the CMS Interoperability and Prior Authorization final rule (CMS-0057-F), finalised in January 2024, requires impacted payers to stand up FHIR-based Patient Access, Provider Access, Payer-to-Payer and Prior Authorization APIs, with compliance dates generally starting 1 January 2027. If your product touches prior authorisation or payer data, those APIs belong in the scope discussion.

For network-level exchange there is TEFCA, the Trusted Exchange Framework and Common Agreement, under which Qualified Health Information Networks (QHINs) began exchanging data around the turn of 2023 and 2024. TEFCA matters when the use case is retrieving records across many organisations; for a point-to-point connection to one health system you will typically use that system’s EHR vendor API instead.

European Union. There is no single EU EHR API. Each member state has its own national infrastructure and standards mix, often based on HL7 CDA for clinical documents, with FHIR appearing in newer national services and implementation guides. Poland is a good illustration: electronic medical records are exchanged through the national P1 platform using a national implementation of HL7 CDA over SOAP web services, while the national e-Health Centre publishes FHIR implementation guides for some newer services. We described how that ecosystem evolved in our article on digital transformation of Polish healthcare. Over all of this sits the European Health Data Space, covered later in this article.

The practical consequence on both sides of the Atlantic is the same: a typical integration handles at least two standards, and often three.

Which standards will you meet on the other side, and what follows?

The list of standards in a project is set by whom you connect to, not by what is modern. Expect four families.

HL7 v2. The oldest and still the most widespread format inside hospitals: admissions and discharges (ADT), orders (ORM/OML), results (ORU), usually as a message stream over MLLP and TCP, often routed through an interface engine. Its weakness is flexibility: every vendor interprets fields slightly differently, and custom Z-segments are the norm. An HL7 v2 integration needs the interface specification of the specific site and vendor, not the standard.

HL7 CDA and C-CDA. Signed, persistent clinical documents with a header and a body. In the US, C-CDA documents such as continuity of care documents remain part of certification and of record exchange; in many European countries CDA is the backbone of national document exchange.

HL7 FHIR. REST, JSON or XML, resources and profiles. The most developer-friendly and best-tooled of the four, provided the other side actually exposes it and documents its profiles and the operations it supports. Read access is usually far more mature than write access.

DICOM. Medical images and their metadata. PACS integration is its own world: data volumes, DICOMweb, viewers. If imaging is in scope, price it separately.

Architecturally, this means your integration layer has to be a translator, not a pipe. An ADT message from HL7 v2 has to be translated into your domain model, and from there into a FHIR resource for a partner app or a C-CDA document for an exchange. Each transformation has its own rules, tests and failure modes. We covered the patterns that keep such a layer manageable (brokers, queues, interface engines, event-driven designs) in our overview of software integration patterns, and the general methods are summarised in the glossary entry on systems integration.

How do you describe the scope so it can actually be priced?

The unit of scope is a flow: one business event that moves defined data from system A to system B, in a defined standard, with defined exception handling. Examples: “a lab result from the hospital’s LIS reaches the patient record in our app and is visible to the clinician within five minutes” or “a new appointment in our scheduling product creates an encounter in the hospital EHR”.

For each flow, document eight things:

  1. Trigger. Which event starts the exchange, in which system.
  2. Direction and mode. Read or write, synchronous or queued, real-time or batch.
  3. Standard and profile on both sides. For example HL7 v2.5.1 ORU per the site’s interface specification on one side and US Core 6.1.0 Observation on the other.
  4. Data set. Required and optional elements, with the origin of each.
  5. Code systems. LOINC, SNOMED CT, ICD-10-CM, RxNorm or local codes on each side, and who supplies the map.
  6. Identity. How patients and practitioners are matched on both sides.
  7. Exceptions. Corrections, cancellations, duplicates, the other side being down, rejection by a validator.
  8. Acceptance criteria. Which test cases must pass, in which environment.

That takes one to two pages per flow and a few days of work with an analyst, an architect and somebody from the clinical side who knows the workflow. Without it, the price is a guess, and every “but that’s obvious” turns into a change request.

The flow as a unit has another benefit: it lets you decide in stages. Instead of buying “an EHR integration”, you buy the first flow, measure what it really cost, and only then price the next ones. The second flow of the same type is usually markedly cheaper than the first, because the shared layer (authorisation, queues, monitoring, audit) already exists. If you are doing this for the first time, start with a short discovery phase; at ARDURA it takes one to two weeks and ends with a scope and architecture that can be priced.

Why do the profile and version matter more than the standard itself?

Because the profile, not the standard, decides whether your resource is accepted. A Patient resource that is valid base FHIR R4 will be rejected by a server that requires a profile in which a particular identifier system is mandatory. A C-CDA document that is valid CDA will fail certification testing if it does not meet the companion guide in force.

In practice, that leads to three requirements, for the vendor and for yourself.

Profiles and versions in the scope. For each flow, record the profile name, canonical URL and version. If the other side does not publish a profile, record the vendor’s interface specification and its document version. “HL7 FHIR” without those details is not a specification.

Automated validation. Every resource and document you send should be validated before it is sent, in CI and in production. For FHIR, that means the official HL7 validator run with the target profile packages; for CDA, schemas and Schematron rules where available. Validating in production looks expensive until you have spent a week finding out why some documents silently stopped arriving.

A version change plan. Profiles change. US Core moves forward as USCDI versions advance, EHR vendors ship new API versions and retire old ones, national guides are revised. An integration without an upgrade plan is a project that ends on acceptance day and breaks a few months later. The contract should say who watches for specification changes, how quickly the vendor adapts the integration and at what rate.

Anyone who has versioned APIs will recognise the problem: a contract change on one side breaks the other, often without a single compile error. The technique that catches it early is contract testing, which we covered in our article on contract testing and API compatibility.

Where are the pitfalls that proposals usually leave unpriced?

In our view, five areas account for most surprises in healthcare integrations. None of them is exotic, and all of them are easy to miss when scope is described as a standard.

Patient identity. The United States has no national patient identifier, so matching relies on demographics, local medical record numbers and probabilistic algorithms, with all the duplicates and overlays that implies. European countries with national identifiers have it easier, but not easy: newborns, foreign patients, unidentified emergency admissions and data entry errors remain. An integration needs matching rules, a merge and unmerge process and a defined procedure for uncertain matches.

Terminology and code mapping. Lab catalogues are often local, diagnoses arrive in ICD-10-CM or a national ICD-10 variant, and the receiving side expects LOINC or SNOMED CT. The map has to be built, approved by someone with clinical knowledge and maintained. It is analytical work no framework speeds up, and one of the most consistently underestimated lines in an estimate. Check the licensing terms of the terminologies you plan to use before you write them into scope.

Ordering and idempotency. Messages arrive out of order, repeat after a queue restart, and corrections overtake originals. The integration must survive each of these, which means message identifiers, deduplication, safe reprocessing and clear conflict rules.

Write access and its limits. Many EHR FHIR APIs are mature for reads and much narrower for writes. Some operations require vendor-specific APIs, a marketplace listing, a separate agreement with the vendor or a fee. Confirm early which writes are supported, under what terms and in which environment, because this single question can change the architecture.

Historical data. Does the integration cover only new events, or also a backfill of history? A backfill is often a separate project with its own data quality analysis, and it should never enter scope by implication.

Each of these pitfalls can be priced if it is named before signature. The problem with a proposal that speaks of “standard compliance” is that it has no place where they could appear.

Should FHIR be the internal data model of your system?

This question divides architects, and it is worth having your own answer before talking to vendors. Some teams build a healthcare application directly on a FHIR server: FHIR resources are the data model and the FHIR API is also the application API. The argument is attractive: one model, no translation, ready-made tooling.

In most projects we think it is a mistake, for three reasons. First, it ties your domain model to a standard version and to profiles that other organisations control. A change to US Core, a national guide or a partner’s move to a newer FHIR release becomes a change at the heart of your application instead of in the integration layer. Second, FHIR resources are designed for exchange, not for business logic. Rules such as “an encounter can be closed only after the note is signed” must be expressed outside the model anyway, only less naturally. Third, you will almost certainly have to produce C-CDA, HL7 v2 or a national document format too, so “no translation” is an illusion: the translation exists, it just lives somewhere less obvious.

A safer pattern is your own domain model plus an anti-corruption layer: a component that translates the internal model to and from FHIR, CDA or HL7 v2. Changes to external specifications are contained in that layer, and it can be tested independently of the rest of the application.

There are exceptions. If you are building a clinical data repository whose main job is to collect data and serve it to other systems, a FHIR-native model can be a sound choice. The same goes for an application that is only a viewer over one EHR. But for a product with its own workflow logic, such as a virtual care platform, an ordering system or a care management tool, FHIR should be the boundary, not the foundation.

If you are integrating with a legacy system that cannot be replaced immediately, the same translation layer lets you move functions to the new solution step by step; our legacy system modernization checklist covers the decisions involved.

How do you secure an integration that carries health data?

Health data is protected health information under HIPAA in the US and a special category of personal data under Article 9 of the GDPR in the EU, so an integration has to meet a higher bar than an ordinary business API. Some of the requirements are imposed by the platform, the rest you have to design.

Authentication and authorisation. On the FHIR side the market standard is SMART App Launch, a profile of OAuth 2.0 and OpenID Connect for healthcare applications, with scopes that define which resources an app may access. For backend services without a user, SMART Backend Services uses signed client assertions. If you integrate with a major US EHR, it will almost certainly be SMART. National platforms in Europe often use certificates and signed SOAP messages instead.

Keys and certificates. Certificates and client keys expire. An integration that stops because nobody rotated a key is a classic, entirely predictable outage. Put expiry monitoring and a rotation procedure into scope.

Audit trail. Who accessed which patient’s data, when and for what purpose? The integration should log every access in a way that answers that question, without writing clinical content into application logs. That last point is a frequent mistake: logs containing full HL7 messages end up in a system half the IT department can read.

Data minimisation. A flow should carry only the data the receiver needs. The eight-point flow specification above is the right place to document that decision, and under HIPAA it also supports the minimum necessary standard.

API security itself. Common API weaknesses, such as broken object-level authorisation or excessive data exposure, have more serious consequences in healthcare than almost anywhere else. We collected the most frequent attacks and defences in our article on API security. In the EU, many healthcare organisations also fall under NIS2, which affects monitoring and incident reporting requirements and is worth clarifying with legal counsel before the design is fixed.

How do you test a healthcare integration before it touches real patients?

Testing healthcare integrations has a constraint most projects do not: you cannot freely use production data. You need synthetic data that is realistic enough to expose mapping problems and artificial enough not to be personal data. Tools such as Synthea, an open-source synthetic patient generator, help, but they do not replace site-specific test cases.

A sensible test plan has four levels.

Structural validation. Every generated FHIR resource passes the HL7 validator with the target profiles; every CDA document passes schema and Schematron checks. This is the cheapest level and should run automatically on every code change.

Contract tests. For each flow, a set of sample input messages and expected outputs, covering edge cases: corrections, cancellations, a missing optional element, an unknown code. With vendors who change interfaces often, these are the first tests to tell you something moved.

Vendor sandboxes and conformance tools. EHR vendors offer sandboxes, and national platforms offer integration environments. In the US, the Inferno framework is the test tool ASTP/ONC uses for the standardised FHIR API certification criterion, and it is equally useful for checking a client implementation against US Core and SMART before you go near a live system.

Clinical acceptance testing. Someone who knows the clinical workflow has to confirm that data means the same thing on the other side. A lab result with the right value in the wrong unit will pass every automated test and fail the first clinician who looks at it.

The trap is leaving testing until the end. Vendor sandboxes and integration environments have their own schedules, maintenance windows and ticket queues, and production access often requires a security review on the health system’s side. If your first contact with the sandbox happens in the last week of the project, the acceptance date is fiction.

What will the EHDS and US rules change for integrations by 2031?

European Health Data Space. Regulation (EU) 2025/327 was published on 5 March 2025 and entered into force on 26 March 2025. It applies generally from 26 March 2027, but the obligations that matter most for integration have later dates, set in Article 105.

From 26 March 2029 they cover the first group of priority data categories: patient summaries, ePrescriptions and eDispensations. From that date, manufacturers may place on the market only EHR systems processing those categories that comply with the common specifications for harmonised components, including the ability to exchange data in the European electronic health record exchange format (EEHRxF). From 26 March 2031 the same applies to medical imaging and reports, test results and discharge reports, and Chapter III of the regulation also covers EHR systems developed by care providers for their own use or offered as a service.

What does that mean for an integration you commission today? First, if you are building something that may count as an EHR system under the EHDS, the architecture should anticipate import and export in the European format from the start. The technical details will be set by implementing acts, so implementing the format speculatively is premature, but the translation layer described above is exactly where that next format will live. Second, the 2031 date for in-house systems means “it is only our internal tool” stops being an exemption. Third, member states can bring some requirements forward, so watch national implementing legislation.

United States. The direction is the same, through different instruments: certified EHRs moving to USCDI v3 and US Core 6.1.0, payers building FHIR APIs for the CMS-0057-F deadlines from January 2027, and TEFCA expanding network exchange. If your product serves both markets, design one internal model with two families of adapters rather than two products.

If your product may qualify as a medical device, the EU MDR, FDA requirements and IEC 62304 also apply. That changes the development process across the whole project, not just the integration, and should be settled before pricing.

How much does an EHR integration project cost, and where does the number come from?

Reliable public data on healthcare integration costs is scarce, and figures quoted in vendor blogs rarely say what scope they cover. The ranges below are therefore our estimate, presented as an estimate, together with the factors that move it. Treat them as a starting point for a conversation, not a price list.

Scope elementEstimated effort (person-days)What pushes it upWhat pulls it down
Flow specification (discovery)5–15many source systems, no documentation on the other sideone partner with published profiles
Shared layer: queues, monitoring, audit, keys, error handling30–60high availability, many environments, 24/7 operationan interface engine already in place
Read flow from an existing FHIR API15–30 per flowcustom profiles, large volumes, historical syncwell-documented profile and vendor sandbox
Write flow into an EHR via FHIR or vendor API30–70 per flowlimited write support, vendor approval process, workflow side effectssupported operation with sandbox access
Bidirectional flow over HL7 v2 or interface engine40–100 per flowcustom Z-segments, local codes without a dictionary, no test environmentcurrent interface spec and a test instance
Terminology mapping10–40 per code systemlocal codes, no clinician available for reviewstandard code systems on both sides
Clinical acceptance and go-live15–30several sites, partner maintenance windowssingle site, pilot rollout

How do you turn that into a budget? Take a virtual care product integrating with one health system: lab results in over HL7 v2, patient demographics and medications read through the EHR’s FHIR API, and encounter summaries written back. Discovery, the shared layer, three flows, two code systems and testing come to roughly 150 to 280 person-days. With a senior nearshore team at EUR 335–485 per day, that is roughly EUR 50,000 to EUR 135,000. Onshore US rates are typically higher, which multiplies the same effort into a larger number. The spread is wide, and at this stage it should be: only the flow specifications narrow it.

On top of that come costs on your own side: clinical staff time for mapping and acceptance testing, EHR vendor or marketplace fees for API access or test environments (often forgotten and sometimes material), interface engine licences if you buy one, and maintenance. We estimate maintenance, meaning monitoring, incident handling and keeping up with specification changes, at somewhere in the mid-teens to mid-twenties as a percentage of build cost per year, depending on how often partners change their interfaces.

Two closing observations. A proposal well below the bottom of such a range nearly always omits one of the table rows, most often exception handling or terminology mapping. And a lump-sum proposal with no breakdown by flow cannot be compared with another proposal, because you cannot tell what each vendor assumed.

How should the contract with the integration vendor be written?

A healthcare integration contract differs from an ordinary software contract because part of the scope depends on third parties: the EHR vendor, the health system’s IT team, a lab, a national platform. A good contract names those dependencies and assigns their risk.

Scope as a list of flows. Each flow with its eight elements, profile and version. A profile or version change on the partner’s side is a change of scope with a defined pricing procedure, not an argument about whether “FHIR compliance” covered it.

Third-party dependencies. Who arranges sandbox access, who applies for production credentials or a marketplace listing, who supplies the interface specification, and by when. If a dependency is not met, the schedule moves, and the contract should say what happens to cost.

Acceptance criteria per flow. A list of test cases, validation in the integration environment and a defined period of stable production operation. Accepting “the whole integration after go-live” without per-flow criteria ends in an argument about whether a bug in a rare correction path is a defect or a new feature.

Pricing model. A fixed price works for well-specified flows with documentation available on the other side. For flows with high uncertainty, such as an interface without documentation, time and materials with a cap, or a separate investigation stage priced on its own, is more sensible. Mixing both models in one project is fine as long as the boundary is written down.

Maintenance and version changes. Who monitors vendor and regulatory announcements of specification changes, how quickly the vendor adapts the integration, at what rates and for how long. An integration without a maintenance agreement is an integration that will stop working within a year.

Knowledge and documentation. Code maps, flow specifications and interface engine configuration should belong to you and be handed over continuously, not at the end. Otherwise changing vendors means rebuilding knowledge from scratch.

Team composition is a separate decision. A healthcare integration needs several roles that rarely come in one person: an analyst who understands clinical workflows, an engineer with HL7 and FHIR experience, an architect who owns the shared layer and a tester who can build synthetic data. We wrote about how to staff those roles across project phases in our article on building the IT team for an e-health project.

What are the key takeaways before you commission an EHR integration?

An EHR integration is not expensive because the standards are hard. It becomes expensive when scope is described as a standard rather than as flows, because then the cost of mapping, terminology, patient identity and exceptions surfaces only during the project, as change requests.

Remember six things. First, on both sides of the Atlantic a typical integration handles several standards, HL7 v2, CDA or C-CDA and FHIR, not FHIR alone. Second, describe scope as a list of flows, each with eight elements, a profile and a version. Third, require automated validation against named profiles, not a declaration of compliance. Fourth, do not build application logic on FHIR resources; use your own model with a translation layer. Fifth, budget for terminology mapping, partner-side costs and maintenance. Sixth, design for USCDI v3, the CMS-0057-F deadlines and the EHDS dates of 2029 and 2031, without implementing the European format speculatively.

If you are preparing an integration with a hospital EHR, a national platform or a payer API and need to turn a vague scope into a list of flows that can be priced, see how we work in custom software development. You can also extend your own team with healthcare IT specialists or book a call about the scope of your first flow.