FHIR standardizes the envelope healthcare data travels in — the resource shapes, the REST verbs, the JSON/XML syntax — but not the clinical meaning inside it. Two "FHIR-compliant" EHRs can both pass conformance tests and still disagree on what a Condition resource means in practice. For a product manager, that gap between compliance and compatibility is where entire quarters disappear.

Quick Answer: FHIR gives you a shared data structure and API pattern, not a shared meaning. Budget separate, serious effort for terminology mapping, profile alignment (like US Core), and per-EHR validation — "FHIR-compliant" is a floor, not a finish line.

What FHIR Actually Standardizes (And What It Doesn't)

FHIR (Fast Healthcare Interoperability Resources) standardizes the structure of healthcare data — resources like Patient, Observation, and Condition — and the transport mechanics for exchanging them over REST APIs. It does not standardize which codes, value sets, or workflows a given system uses to populate those resources, which is exactly where most integration effort actually lives.

Think of FHIR as a shipping container standard, not a contents standard. A container has agreed-upon dimensions and locking mechanisms so any port can handle it. It says nothing about whether the crate inside holds furniture or hazardous chemicals — that's a separate labeling problem. FHIR resources are the container; clinical semantics are the contents.

This distinction matters because the marketing language around FHIR ("universal interoperability," "plug-and-play health data") vastly outruns what the specification itself promises. HL7, the standards body behind FHIR, is explicit that the base specification defines a framework meant to be constrained further by implementation guides before it's usable for a specific purpose.

Resources vs. Profiles: The Layer PMs Often Skip

A resource is FHIR's generic data model (say, Observation for any measured or observed fact); a profile is a constraint on that resource for a specific context (like a blood-pressure reading or a lab result), and profiles are where real interoperability gets decided. Skipping profile-level scoping is the single most common reason integration timelines blow up.

The most important profile family for US-based healthtech PMs is US Core, mandated under ONC's information-blocking and certification rules for certified health IT. US Core narrows FHIR's broad resources down to specific, required elements and terminology bindings for the US context — but even within US Core, implementers retain discretion over extensions, optional fields, and workflow-specific behavior.

LayerWhat it definesWhat it leaves open
FHIR base specResource types, REST API shape, search parametersWhich fields a system populates, which codes it uses
US Core profileRequired/must-support elements, minimum terminology bindingsOptional extensions, non-mandated workflows, UI behavior
Vendor implementationActual EHR behavior against the profileField-population quality, update timeliness, edge-case handling

Reading this table top to bottom is effectively the scoping conversation you need to have with engineering before any FHIR integration is estimated. Each layer down adds real, non-standardized variability — which is why "we support FHIR" from a vendor sales deck answers almost none of your actual integration questions.

Why Every EHR Implements FHIR Slightly Differently

Every certified EHR implements FHIR conformant to the letter of the spec while still diverging in practice, because the standard permits optionality that vendors resolve according to their own legacy data models, workflows, and commercial incentives. This isn't a compliance failure on any single vendor's part — it's a structural feature of how a flexible, extensible standard interacts with decades of pre-existing systems.

Common sources of real-world divergence include:

  1. Legacy data mapping. Most EHRs didn't build FHIR-native; they built a FHIR API layer on top of a database designed in the 1990s or 2000s, and that translation layer introduces gaps, defaults, and lossy mappings.
  2. Optional field population. US Core marks some elements "must support" rather than "required," meaning a field can be present in the schema but reliably empty in practice.
  3. Terminology binding looseness. Code systems like SNOMED CT, LOINC, and RxNorm are recommended or required for specific fields, but free-text and locally-defined codes still leak through, especially in older records.
  4. Update cadence and completeness. A resource can technically exist in the API while representing stale or partial data, because the underlying system of record updates asynchronously or infrequently.
  5. Extension usage. Vendors add proprietary FHIR extensions to carry information the base spec doesn't model, and those extensions aren't portable to a different vendor's implementation.

This is the practical reality behind claims like "interoperability solved" — it's a case study in why our complete guide to healthtech product management treats integration risk as a first-class product concern, not an engineering afterthought.

The Conformance Trap

A system can pass a FHIR conformance test suite (validating resource shape and required elements) while still being functionally incompatible with your product's needs, because conformance testing checks structure, not clinical content quality or coverage. Don't let "we passed the Touchstone/Inferno test suite" substitute for testing against your actual use case with real (or realistic synthetic) data from that specific EHR.

This is also where interoperability intersects with regulatory scope. If your product touches protected health information as part of this integration, the compliance obligations run in parallel to — not instead of — the technical integration work; see our guide on HIPAA considerations for product managers for how those workstreams should be sequenced together rather than treated as separate phases.

A Pragmatic Scoping Example: Care-Gap Detection

For a typical care-gap feature (flagging patients overdue for a screening or follow-up), you need a narrow, specific set of FHIR resources rather than "all patient data," and defining that narrow set up front is the single highest-leverage scoping decision on the project. Over-scoping data requirements is the most common way these projects stall in security and legal review.

A care-gap feature — say, flagging patients overdue for a diabetic A1c check — realistically needs:

ResourcePurpose in this featureKey scoping question to ask
PatientIdentity, demographics for risk stratificationDo you need full demographics or just an identifier + age/sex?
ConditionConfirms the patient has diabetes (denominator)Which code systems (SNOMED, ICD-10) will the source system actually send?
ObservationLast A1c result and date (numerator/gap logic)Is LOINC coding reliably populated, or do you need fallback text parsing?
EncounterConfirms an active care relationship, not a one-off visitDoes the EHR expose encounter history via FHIR or only through a separate feed?
CarePlan (optional)If you want to close the loop with a recommended actionIs this even populated by the source system, or would you be writing to it?

Notice what's absent: full medication history, full allergy lists, clinical notes, imaging. A disciplined care-gap MVP doesn't need them, and pulling them anyway multiplies your BAA scope, your validation burden, and your attack surface for no feature benefit. Scope the resource list to the decision the feature actually makes, not to "everything that might be useful someday."

Planning for Mapping and Validation Effort

Once resources are scoped, the real work is mapping each source system's actual field population and code usage against what your logic assumes, then validating that mapping against live or realistic data — and this effort scales with the number of source EHRs, not the number of features. Two health systems on the "same" EHR vendor can still require separate mapping passes if they've customized their configurations differently.

A workable planning checklist:

  • Request a sample data pull (de-identified or synthetic) from each source system before writing integration logic, not after.
  • Verify terminology binding empirically — don't trust the implementation guide's claim that a field "must support" LOINC; confirm the actual codes present in real records.
  • Build explicit fallback logic for missing or null fields rather than assuming presence, since "must support" is not "always populated."
  • Budget a validation pass per source system, not per integration project — this is usually the estimate PMs get wrong by an order of magnitude.
  • Version-pin the FHIR release (R4 is currently the dominant production version; R4B/R5 adoption is uneven) since resource definitions shift between versions.

This is also a case where dual-user thinking pays off: a care-gap flag that's technically correct but confusing to the clinician reviewing it, or invisible to the patient it concerns, has failed regardless of how clean the FHIR mapping is — a concern we cover more broadly in designing for clinician and patient dual users.

Governance, Standards Bodies, and Where Authority Actually Sits

Three organizations set the rules PMs need to track — HL7 owns the FHIR specification itself, ONC enforces certification and information-blocking rules for US health IT, and CMS drives payer-side interoperability mandates — and confusing their scopes is a common source of misdirected compliance effort. Knowing which body governs which requirement changes who you escalate to when a vendor pushes back.

  • HL7 maintains the FHIR standard itself and its various implementation guides (including US Core); they set what's technically possible and specified.
  • ONC (Office of the National Coordinator for Health IT) enforces certification requirements and information-blocking rules under the 21st Century Cures Act, which is why certified EHRs are required to expose FHIR APIs at all.
  • CMS has separately driven payer-side interoperability rules requiring FHIR-based patient access and provider directory APIs for many health plans.

A common failure mode: a PM assumes that because ONC certification requires FHIR API exposure, the data behind that API is complete or clinically curated. Certification confirms the door exists and opens correctly — it says nothing about what's stocked in the room behind it.

If your care-gap or similar feature eventually recommends a clinical action based on this data, the safety obligations compound quickly — our piece on AI clinical decision support and safety is worth reading before that logic reaches a clinician's workflow.

Making Integration Scoping Concrete Before Engineering Estimates It

The gap between "FHIR-compliant" marketing claims and real integration effort is best closed by making your resource, profile, and mapping assumptions explicit and reviewable before engineering commits to a timeline — vague scoping is what turns a two-sprint integration into a two-quarter one. This is squarely a documentation and communication problem as much as a technical one.

Prodinja's API Designing tool is built for exactly this handoff moment: it lets you sketch FHIR-style endpoints and generate corresponding curl commands and spec output directly from the resource and field decisions you're making, so the resource list in the table above stops living in a slide and becomes something engineering can actually critique line by line before a single line of mapping code gets written. That shift — from "we'll need Patient, Condition, and Observation" as a bullet point to an inspectable endpoint sketch — is often what surfaces a missing field or a wrong assumption a sprint early instead of a sprint late.

None of that replaces the mapping and validation work described above; it front-loads the conversation so the estimate you get back reflects the real scope rather than an optimistic reading of a vendor's FHIR badge.

Key Takeaways

  • "FHIR-compliant" describes the envelope, not the contents — structure and transport are standardized; clinical semantics, code usage, and field completeness are not.
  • Profiles like US Core narrow the standard for a specific context but still leave optional fields, extensions, and workflow behavior to vendor discretion.
  • Every EHR diverges in practice due to legacy data mapping, optional field population, inconsistent terminology binding, and proprietary extensions — this is structural, not a vendor failing.
  • Scope resources to the decision a feature actually makes — a care-gap feature needs a handful of resources (Patient, Condition, Observation, Encounter), not a full clinical record.
  • Budget mapping and validation per source system, not per project — this is the most common place integration estimates go wrong.
  • Track governance separately: HL7 owns the spec, ONC enforces certification and access, CMS drives payer-side mandates — know which body to escalate to.
  • Make scoping decisions inspectable early, using tools that turn resource lists into concrete endpoint sketches engineering can critique before estimating.

Frequently Asked Questions

Does FHIR compliance mean two systems can exchange data without custom mapping?

No — FHIR compliance guarantees a shared resource structure and API pattern, but not shared terminology usage or field completeness, so custom mapping between any two real-world systems is still typically required. Treat "FHIR-compliant" as a starting point for integration planning, not a substitute for it.

What's the difference between a FHIR resource and a FHIR profile?

A resource is the generic data model (like Observation); a profile constrains that resource for a specific use case (like a specific lab result type) by requiring certain fields and terminology bindings. US Core is the most common profile set US healthtech PMs will encounter, driven by ONC certification requirements.

Which FHIR resources should a PM prioritize for an MVP integration?

Prioritize the minimum resource set that supports your feature's actual decision logic — for a care-gap feature that's typically Patient, Condition, Observation, and Encounter. Pulling broader data (full medication history, notes, imaging) without a specific feature need increases compliance and validation burden with no offsetting benefit.

How long should a PM budget for a new EHR integration if it's already "FHIR-compliant"?

Budget for a distinct data-sampling and validation pass per source system, since compliance doesn't guarantee your assumed fields are populated as expected — this is frequently underestimated by teams that treat FHIR compliance as equivalent to plug-and-play readiness. The scoping and mapping conversation described above should happen before, not during, that estimate.

Is FHIR the same thing as HL7?

No — HL7 (Health Level Seven International) is the standards organization; FHIR is one of the data-exchange standards it publishes, alongside older standards like HL7 v2 that remain in wide production use. Many "HL7 FHIR integration" conversations in practice also involve translating from legacy HL7 v2 feeds still running underneath a newer FHIR-facing API.