FHIR for non-engineers: a 10-minute primer for product managers

If you're the PM on a healthcare project, you don't need to write FHIR code, but you do need to know what your engineers mean by resources, profiles, scopes and US Core, and what FHIR will not do for you.

In short

  • FHIR is an HL7 standard that represents health data as small named records called resources, such as Patient or Observation, and moves them through a web API.
  • For a product manager, three things decide scope: which resources the EHR exposes for read and write, which US Core profile version it follows, and which SMART on FHIR permissions (scopes) your app can get.
  • US rules require certified EHRs to offer a FHIR R4 API and many health plans to offer FHIR APIs by January 1, 2027, but FHIR does not remove per-customer setup, workflow design or data cleanup.

FHIR (pronounced "fire") is a standard for representing health data as small, named records called resources, such as a Patient or an Observation, and for moving them through a web API. As a product manager, you need it to answer three questions: what data you can get from an EHR, how your app gets permission, and how much extra work each new customer adds.

You don't need to write FHIR code. You do need to follow your engineers well enough to scope features, spot risk early and push back when an estimate hides an assumption.

What is FHIR, in plain English?

FHIR stands for Fast Healthcare Interoperability Resources. It is published by HL7, the same standards body behind HL7 v2 and CDA documents. The FHIR overview describes it as a standard for exchanging healthcare information electronically, designed to simplify implementation without sacrificing information integrity.

Think of it as two things at once. First, a shared vocabulary: everyone agrees what a Patient record or a lab result looks like. Second, a way to ask for that data over the web, the same way most modern apps talk to each other. A request like "give me this patient's blood pressure readings" has a standard shape, whichever EHR answers it.

What is a FHIR resource?

The FHIR overview calls the resource the basic building block: all exchangeable content is defined as a resource. Each one is a small record with a defined structure, usually sent as JSON. Resources point to each other, so an Observation refers to the Patient it belongs to. The R4 resource list is long, well over a hundred types, but a typical product touches a dozen.

  • Patient: who the person is (name, birth date, identifiers).
  • Practitioner: a clinician or other provider.
  • Encounter: a visit or admission.
  • Observation: a measurement or result, such as a vital sign or lab value.
  • Condition: a diagnosis or problem on the problem list.
  • MedicationRequest: a prescription or medication order.
  • AllergyIntolerance: a recorded allergy.
  • Appointment: a scheduled visit.
  • DocumentReference: a pointer to a document, such as a clinical note or PDF.
  • Coverage and Claim: insurance and billing data, mostly in payer work.

Resources mature at different speeds. In R4, Patient and Observation are normative, which means stable. Many others carry a lower maturity level and can change between versions. When a feature depends on a less mature resource, expect more variation between EHRs.

What are profiles, and what is US Core?

Base FHIR is deliberately flexible. The overview says the base resources aim to cover the majority of common use cases, with a built-in extension mechanism for the rest. Profiles then add rules for a specific setting, tightening which fields are required and which code systems to use.

In the US, the profile set that matters is US Core. It defines the minimum constraints on FHIR resources for US use, and it is updated each year to track the US Core Data for Interoperability (USCDI), the federal list of data elements. HL7 lists US Core 9.0.0 as the current published version, while EHRs certify to the versions ONC requires, so the version your customer runs may be older.

For planning, "the EHR supports FHIR" tells you little. "The EHR supports US Core version X, with read access to these resources and write access to these two" is something you can build a roadmap around.

What is SMART on FHIR?

FHIR describes the data. SMART App Launch describes how an app gets permission to use it. It is an HL7 guide built on OAuth 2.0, the same sign-in standard many consumer apps use. The current published version is 2.2.0, based on FHIR R4.

  • SMART App Launch: for apps a person uses. The app can launch from inside the EHR and receive context, such as the patient the clinician has open, or launch on its own and ask the user to sign in.
  • SMART Backend Services: for systems with no user present, such as a nightly data sync.
  • Scopes: the permissions an app asks for. The guide gives examples like user/Encounter.rs for an app acting for a user and system/Encounter.rs for a backend service.

Scopes are a product decision as much as a technical one. Ask for only what each feature needs. Broad scopes are harder to justify to a health system's security reviewers, and harder to explain to a patient who is deciding whether to connect.

Which FHIR version matters?

For US products, R4 (version 4.0.1). It is the version ONC's certification criterion and CMS's payer rule reference. HL7's site lists R5 (5.0.0) as the current published version, and you will hear about it, but US regulation and certified EHR APIs are built on R4. If an engineer proposes building on R5, ask which of your customers' systems support it.

What do US rules require?

Two rules explain why FHIR APIs exist at all at most US EHRs and payers.

  • ONC §170.315(g)(10): certified EHRs must offer a standardized API for single patients and for groups of patients, using FHIR R4, US Core, SMART App Launch and Bulk Data. Patients can revoke an app's access, and the EHR must act on that within one hour. API documentation must be public.
  • CMS-0057-F: Medicare Advantage organizations, Medicaid and CHIP programs and plans, and QHP issuers on the federal exchanges must run FHIR-based Patient Access, Provider Access, Payer-to-Payer and Prior Authorization APIs, with the API requirements due by January 1, 2027.

These rules guarantee a baseline of read access. They do not guarantee that every EHR lets your app write data, or that every feature you want has a standard resource behind it.

What FHIR does not do for you

  • Writes are limited. Read access is the regulated baseline. Write access (filing a result, creating an order) varies by EHR and by customer, and is often where integrations get hard.
  • Each customer is still a project. The same EHR vendor's API behaves differently across health systems because of local configuration, enabled features and approvals.
  • Workflow is yours. FHIR moves data; it does not decide where a clinician sees it or what happens next.
  • Data quality is yours. Records from different sources disagree, codes are missing, and duplicates appear.
  • Not everything is in FHIR. Many hospital event feeds still run on HL7 v2. Our FHIR vs HL7v2 guide covers when each applies.

Words you will hear in standups

  • Endpoint or base URL: the address of a customer's FHIR server. Each customer has its own.
  • Sandbox: the vendor's test environment with fake patients. Useful, but not identical to any customer's production system.
  • CapabilityStatement: the document a FHIR server publishes to say which resources and operations it supports.
  • Extension: an extra field a profile or site adds on top of a base resource.
  • Bulk export: pulling data for many patients at once, as files, instead of one request per patient.
  • Client ID: your app's registration with an EHR. You usually need one per environment.

Questions a PM should ask the engineering team

  • Which resources does each feature read, and which does it write?
  • Does each target EHR support those writes, and do we have that in their documentation?
  • Which scopes do we request, and can we justify each one to a security reviewer?
  • What changes when we onboard customer number two on the same EHR?
  • What happens in the app when the EHR is slow, returns an error, or the token expires?
  • Where does data from the EHR live in our system, and who can see it?

That last question carries compliance weight. We sign a BAA before touching PHI, run penetration tests before launch, and scope access so each clinician sees only their own patients. Those are the answers a health system's reviewer will ask you for.

If you are scoping a FHIR integration and want a plain-English read of what is realistic, talk to one of our engineers. We have shipped Epic and athenahealth integrations, and our 5-day free technical audit ends with a written report your team can plan from.