Creuto is now an OpenAI Select Partner Read More

Custom Software Development

Patient portal development: build on the EHR's FHIR API

Patient portal development on a certified EHR: what the (g)(10) FHIR API guarantees, what Epic and Oracle Health make you license, and when to keep theirs.

Patient portal development: build on the EHR's FHIR API

Patient portal development for a US hospital group starts with a fact most agency guides skip: the API every certified EHR must expose to patient apps, defined in 45 CFR 170.315(g)(10), certifies reads and searches, not writes. By the end of this piece you will know which portal features ride on that guaranteed FHIR API, which depend on your EHR vendor's own APIs and licensing, and when keeping the vendor's portal is the better call.

That split decides cost, timeline and risk more than any front-end choice. Reading lab results, medications and allergies is standardized across certified EHRs. Booking an appointment, messaging a care team or uploading a blood-pressure reading is not, and that is where custom portals stall.

What the (g)(10) API guarantees a custom patient portal in November 2026

The (g)(10) criterion requires a certified Health IT Module to answer single-patient requests using US Core, support US Core search, let apps register with its authorization server, and revoke an app's access "within 1 hour" of a patient's request, according to the regulation text current to November 19, 2026. The standards behind it sit in 45 CFR 170.215 and 170.213:

LayerWhat is adopted nowWhat expired
Base standardHL7 FHIR R4 (4.0.1)None
Data profilesUS Core STU 6.1.0US Core 3.1.1, on January 1, 2026
Data setUSCDI v3USCDI v1, on January 1, 2026
AuthorizationSMART App Launch 2.0.0, with OpenID Connect Core 1.0SMART App Launch 1.0.0, on January 1, 2026
Refresh tokensAt least three months for confidential appsNone
RevocationWithin 1 hour of the patient's requestNone

Those versions came from the HTI-1 final rule, published January 9, 2024. The newer deregulatory rule, HTI-5, published October 28, 2026 and effective December 28, 2026, removes 14 certification criteria but keeps (g)(10), and deletes the expired US Core 3.1.1 and SMART 1.0 references from 170.215. It also drops the older (g)(7) patient-selection and (g)(9) all-data-request criteria from January 1, 2027, with ONC arguing that (g)(10) already covers that functionality. A guide that tells you to plan around SMART v1 is out of date.

Two smaller details help a buyer. ONC's certification companion guide lists US Core 7.0.0 and 8.0.1 as approved newer versions, so your EHR may serve more than the 6.1.0 floor. And the API conditions in 170.404, as revised by HTI-5, require certified API developers to publish, at no charge, the service base URLs for every customer using a (g)(10) module, so you can locate your organization's FHIR endpoint without a sales call.

Patient portal EHR integration splits into reads you get and writes you negotiate

The read side of a patient portal features list maps cleanly onto US Core. Version 6.1.0 has profiles for AllergyIntolerance, Immunization, MedicationRequest, laboratory results, vital signs, DocumentReference and Encounter, among others. It has no Appointment profile. Scheduling, secure messaging, bill pay and most forms sit outside the certified API, and no certification criterion makes them uniform across vendors.

Hospitals have moved on both sides, unevenly. ASTP/ONC's February 2026 data brief, built on 2024 AHA survey data, found 71% of non-federal acute care hospitals enabled patient access through a standards-based FHIR API, while 16% used only non-standards-based APIs. For patient-generated health data, 48% enabled submission through a standards-based API. Independent hospitals managed 29% on that measure, against 58% for system-affiliated ones.

The same brief says most exchange with third-party technology still runs through proprietary EHR APIs or non-API methods such as HL7 interfaces. Developers report the same thing. In a survey of 141 digital health companies that ONC summarized in February 2024, 57% used proprietary APIs alongside standards-based ones, and about half cited high fees as a barrier. That data predates the December 2022 API deadline, so treat it as a baseline rather than today's picture.

Epic's documentation shows what a write looks like. Filing a vital sign from a patient-facing app uses the Observation.Create API on an app whose primary user type is "Patients", and the patient needs an active MyChart account, per Epic on FHIR. On Oracle Health's Millennium platform, the R4 API accepts SMART v1 and v2 scopes, and data returned to a patient persona "may be filtered" compared with provider or system access. Each write path is planned per vendor, per API, which makes this API development and integrations work more than front-end work.

Can a patient portal connect to Epic or Cerner? Yes, on the vendor's terms

A custom portal can connect to Epic and to Oracle Health (formerly Cerner) through their FHIR R4 APIs, but the route depends on which APIs you scope. Epic says apps using only USCDI APIs can have their client IDs automatically distributed to Epic organizations with auto-downloads enabled, and that registration is self-service. A portal that needs APIs outside that set goes through Epic's App Request Process, coordinated with the health system.

Four details from the same documentation shape the build:

  • Refresh tokens require the confidential client profile, and apps using confidential clients need developer action before an organization's download completes.
  • Once an app is marked Ready for Production, neither you nor Epic can change it. Apart from redirect URIs and JWK Set URLs, technical changes mean building a new app.
  • Epic licenses its APIs to healthcare organizations, not to developers, with fees based on production usage, and recommends organizations request a licensing estimate based on the app's scope.
  • When a patient-facing app connects, patients are redirected to their provider's MyChart page and sign in with MyChart credentials.

That last point is the one buyers miss. A branded portal that uses Epic's patient-facing OAuth flow does not replace MyChart's identity layer; it sits on top of it. If you want your own login and call the EHR with backend credentials instead, your portal makes the access decisions that the patient's SMART consent screen would otherwise make, and you own that logic and its audit trail.

Custom patient portal vs EHR portal: the strongest case for keeping the vendor's

The case for the stock portal is stronger than most build pitches admit. It already holds patient accounts, proxy rules and the scheduling, messaging and billing workflows your vendor built against its own database. Oracle's documentation notes that rules restricting parental access to adolescent records "vary from state to state", which is exactly the policy logic a custom build would have to reproduce.

Decision factorKeep the vendor portalBuild custom on the FHIR API
Reading recordsBuilt inStandardized through US Core and (g)(10)
Booking, messaging, uploadsBuilt inVendor-specific APIs, licensed by the organization
Patient sign-inVendor accountVendor account through SMART, or your own with backend access
Several EHRs in one groupA separate portal per EHROne front end over several FHIR endpoints
Change controlVendor release cycleYours, though Epic registrations are fixed once in production

Building is the right answer when the group runs more than one EHR, when the portal must combine EHR data with non-EHR systems, or when the patient experience is the product. It is the wrong choice if your feature list is mostly writes into a single EHR whose portal already handles them: you would rebuild those workflows through licensed APIs and still send patients through the vendor's login. The multi-EHR case matches ONC's survey, where about 3 in 4 companies integrated with more than one EHR reported extensive FHIR use, against 1 in 4 integrated with a single EHR.

HIPAA treats a hospital-run portal as your system, not the patient's app

The HIPAA Privacy Rule changes published November 19, 2026 define a "personal health application" as one where information is managed, shared and controlled by or primarily for the individual, and not by or primarily for a covered entity. A portal your hospital group commissions, brands and operates fails that test by design. The rule's reasoning for keeping personal health app developers outside HIPAA is that they do not act on behalf of a regulated entity; the team building your portal does.

The same rule cuts the time to answer an access request to 15 calendar days from 30, with one extension of up to 30 days. It takes effect January 19, 2027, and compliance is required by July 19, 2027. A FHIR-backed portal shortens that path for the data it shows, but it will not cover every record a patient can ask for.

How to build a patient portal on the EHR's FHIR API

  1. Find the endpoint and the documentation. (g)(10) requires API documentation at a publicly accessible hyperlink "without any preconditions or additional steps", and certified developers publish service base URLs. Start there.
  2. Split the feature list into reads and writes. Mark every feature as a US Core read, a vendor write API or a non-EHR system. Writes and non-EHR data are where estimates go wrong.
  3. Register as a confidential client. SMART App Launch 2.0 requires PKCE with the S256 method for all apps and says confidential clients should use asymmetric authentication if available. (g)(10) guarantees three-month refresh tokens to confidential apps and to native apps that can secure one.
  4. Scope narrowly with SMART v2 syntax. Version 2 maps .read to .rs, and a scope such as patient/Observation.rs filtered to the laboratory category asks only for what a results screen shows. (g)(10) requires these category-level scopes for Condition and Observation, and Epic warns that over-scoped apps get delayed or rejected by privacy reviewers.
  5. Design for revocation. Patients can deny offline access, and the authorization server must revoke within an hour, so the portal has to handle tokens that stop working mid-session.
  6. Budget for test data. Four in ten companies in ONC's survey cited a lack of realistic clinical test data. Sandbox records will not show you the edge cases of your own patient population.

Patient portal development cost: what moves the number

We will not quote a range for patient portal development cost, because the biggest drivers sit outside the code. The first is API licensing: Epic licenses its APIs to the healthcare organization with fees based on production usage, so that line lands on the hospital's budget. Regulation limits how vendors set those fees. Under 45 CFR 170.404, a certified API developer must publish its fees in plain language, base permitted fees on objective criteria applied uniformly, and may not set them by whether you compete with it.

The second driver is the write list from step two: each vendor API added brings licensing review, security review and per-vendor testing. The third is the number of EHRs. Our piece on API integration cost explains why published price ranges leave these out. On timing, our public figures are 6-10 weeks for a focused MVP and 3-6 months for larger enterprise platforms, depending on complexity, integrations and scope.

Before you commission a branded patient portal

Bring two things to the decision: the link to your EHR vendor's (g)(10) documentation and a feature list marked read, write or non-EHR. If most lines are reads, or the group spans more than one EHR, a custom front end on the FHIR API is a sound build. If most lines are writes into one EHR, keep the vendor portal and spend the budget elsewhere.

Healthcare is not yet in our case-study list, and we have not tested these flows against a production Epic or Oracle Health environment for this post; everything above comes from the regulation text and vendor documentation. If you want that read/write inventory turned into a scoped build, our web app development team will work through it with your EHR documentation in hand, and a paid discovery phase is the right container while the vendor licensing is still unknown.

Frequently asked questions

Building a patient portal on top of an EHR starts with the EHR's certified (g)(10) FHIR API documentation and service base URL. Split features into US Core reads, vendor-specific writes and non-EHR systems, register as a confidential SMART App Launch 2.0 client with PKCE, scope narrowly, and design for patient revocation within one hour.

Patient portal development cost depends less on screens than on integration: which vendor write APIs you need, how many EHRs the portal spans, and API licensing, which Epic charges to the healthcare organization based on production usage. Creuto's public delivery figures are 6-10 weeks for a focused MVP and 3-6 months for larger enterprise platforms.

A custom patient portal can connect to Epic and Oracle Health, formerly Cerner, through their FHIR R4 APIs using SMART on FHIR authorization. Epic automatically distributes apps that use only USCDI APIs, while portals that need scheduling or other non-USCDI APIs go through the health system's app request and licensing process.

A patient portal usually needs record access for results, medications, allergies and immunizations, plus appointment booking, secure messaging, forms and device readings. The record features map onto US Core profiles that certified EHRs must serve, while booking and messaging rely on vendor-specific APIs because US Core 6.1.0 has no Appointment profile.

The ONC (g)(10) criterion certifies single-patient and group data reads and searches, app registration, authorization, token introspection and revocation, but it does not require write capability. Writes such as filing a vital sign go through vendor APIs, for example Epic's Observation.Create API for patient-facing apps with MyChart users.

The HTI-5 final rule, effective December 28, 2026, kept the (g)(10) standardized API criterion while removing 14 other certification criteria. It deleted the expired US Core 3.1.1 and SMART App Launch 1.0 references, leaving US Core 6.1.0 and SMART App Launch 2.0.0 as the adopted versions for certified EHR APIs.

Written by

Akash Mohapatra

Akash Mohapatra

Co Founder & Director

21 Nov 2026

·

10 min read

Share

LET'S CONNECT

Connect with Creuto!

Ready to take the first step towards unlocking opportunities, realizing goals, and embracing innovation? We're here and eager to connect.