Skip to content
Case study · Healthcare platform

Radiatus OneHealth: 25 modules on an unmodified OpenEMR

Practices wanted online booking, reminders, claims, denials and engine monitoring without migrating their records or giving up a certified EHR. We built all of it around OpenEMR, over its APIs, and left its code exactly as released.

Physician typing patient notes at a desk computer
Case study at a glance
  • 25 modulesBooking to denials
  • Core untouchedOpenEMR 8.2.0, checksum-pinned
  • SMART backendSigned-JWT client credentials
  • Full exportEvery record as NDJSON

The problem

OpenEMR is certified, free and widely used, but practices want features it does not ship. The usual answer is to fork it, and forks fall behind: every customised core file turns an upgrade into a project, and certification questions follow.

What we built

A platform in four parts: OpenEMR as released, a bridge that talks to it over SMART on FHIR backend services, 25 modules on a multi-tenant kernel, and ONEemr, a modern screen set on the same database.

Where it stands

Live at openemr.radiatus.com with all 25 modules. OpenEMR stays upgradeable because nothing in it was changed, and a practice can export every record and leave.

Numbers you can check

Every figure on this page comes from the running product or its source code, checked on 7 November 2026. None is a client result.

FigureWhat it countsWhere it comes from
25Modules, from Booking and Remind to Claims, Remit, Eligibility, PriorAuth and EngineOne directory with a module manifest each in the platform code
8.2.0OpenEMR version, run exactly as releasedOpenEMR's version file, checked against a pinned checksum before each deploy
7Resources in the canonical model: Patient, Practitioner, Location, Appointment, Encounter, DocumentReference, CoverageThe bridge's data model, versioned in every payload
RS384Signing algorithm for the SMART backend-services JWTThe algorithm OpenEMR's backend-services support accepts
6HL7 v2 scheduling events read by the reminder module (SIU S12, S13, S14, S15, S17, S26)The module's HL7 ingestor
1 per clinicDatabase and encryption key per tenantThe multi-tenant kernel's design

Why not fork OpenEMR?

Most OpenEMR vendors customise core files: a changed form here, a patched controller there. Each change is small, and together they make every upgrade a merge exercise. Practices end up several versions behind, missing security fixes, and nobody can say with confidence whether the system still behaves like the certified product.

We set one rule before writing any code: OpenEMR's code is never modified. It runs as released, its version is pinned with a checksum, and a deploy script refuses to continue if the files differ. Everything we add lives outside it and reaches it the way any third-party application would.

How the platform reaches OpenEMR

The bridge is the only component that talks to OpenEMR's APIs. It authenticates with SMART on FHIR backend services: an OAuth 2.0 client-credentials grant with a signed JWT assertion (RS384, which OpenEMR's implementation supports) and system-level scopes limited to the resources it needs, such as system/Patient.read, system/Appointment.read and system/Coverage.read.

Data from OpenEMR is normalised into a small, FHIR-shaped canonical model of seven resources. Every payload carries a canonical_version, so modules can be upgraded independently of the bridge. Changes are picked up by polling, written to an encrypted outbox and delivered to modules as signed webhooks, which means a module outage never blocks the EHR and nothing is lost while a module restarts.

ONEemr is the exception that proves the rule: it is a second set of screens for clinicians that works on OpenEMR's own database, so a practice can switch between the classic and modern interface without migrating anything. OpenEMR's code is still untouched.

The modules and the standards behind them

The 25 modules share one kernel: one database and one encryption key per clinic, a database-backed job queue, and an audit log in which each entry is chained to the hash of the one before and database triggers refuse updates and deletes. The healthcare-standard work sits inside individual modules:

  • Remind reads HL7 v2 scheduling messages (SIU S12, S13, S14, S15, S17 and S26), so reminders follow bookings made in any system that emits them.
  • Claims builds X12 837P files (005010X222A1); Remit parses X12 835 remittances and maps denial reason codes; Eligibility builds X12 270 requests and parses 271 responses.
  • Engine monitors the practice's own integration engine (Open Integration Engine, Mirth Connect up to 4.5.2 or BridgeLink); it has its own case study.
  • Migrate exports every record as NDJSON, so leaving the platform never depends on our goodwill.

What was hard

Living with an API you do not control

OpenEMR's FHIR API is broad but not complete, and its standard REST API covers different ground. The bridge had to choose, per resource, which API to read, and the canonical model hides that choice from the modules. When OpenEMR adds coverage in a later release, only the bridge changes.

Change detection without hooks

An unmodified core cannot call out when a record changes, so the bridge polls. Polling intervals, cursors and an outbox with retries replaced the event hooks a fork would have added, at the cost of a short delay rather than a modified EHR.

Tenancy and evidence

Health data for different clinics never shares a database or a key. The append-only audit log exists because the first question in any security review is "who looked at this record?", and the honest answer must not be editable.

The stack

LayerChoiceWhy
EHR coreOpenEMR 8.2.0, unmodifiedCertified, open source, upgradeable because it is never forked
IntegrationSMART on FHIR backend services, FHIR R4, OpenEMR standard REST APIThe supported way for a third party to read and write OpenEMR
PlatformPHP 8.3, MariaDB 10.11, no frameworkFew moving parts on a long-lived healthcare system
MessagingEncrypted outbox, signed webhooks, database job queueNo message is lost when a module restarts
Standards in modulesHL7 v2 SIU, X12 837P, 835, 270/271, NDJSON exportWhat US practices exchange with schedulers, payers and clearinghouses
SpeechAWS Transcribe or Sarvam for ambient-note transcriptionChoice of provider by region and language

What it does not do yet

  • Claims are generated as 837P files for the practice to upload to its clearinghouse. Direct clearinghouse submission is not built yet.
  • Eligibility requests (270) are built and responses (271) parsed, but no live clearinghouse connection is configured yet.
  • Ambient notes transcribe the visit and draft a structured note from rules. They do not use a large language model.
  • Engine monitoring needs a small agent running beside the practice's integration engine.

What this means for your OpenEMR or EHR project

If you run OpenEMR and need features it does not have, the same approach applies: build alongside it over SMART on FHIR and its REST API, keep the core upgradeable, and keep an export path. Our OpenEMR services team does this for practices and health-tech builders.

The bridge pattern (backend-services authentication, a small canonical model, an outbox and signed webhooks) is how we approach any EHR integration, whether the other side is OpenEMR, Oracle Health or a hospital's own system. See FHIR interoperability and HL7, FHIR and EDI integration.

FAQ

Questions about this case study

No. OpenEMR 8.2.0 runs exactly as released, its files are pinned with a checksum, and every Radiatus component reaches it over its FHIR and REST APIs. ONEemr adds a second set of screens on the same database without changing OpenEMR code.

With SMART on FHIR backend services: an OAuth 2.0 client-credentials grant using a signed JWT assertion (RS384), with system-level scopes limited to the resources the platform needs.

No. The modules work against the practice's existing OpenEMR data. If a practice leaves, every record can be exported as NDJSON.

Not yet. It generates X12 837P claim files and parses 835 remittances; the practice uploads claims to its own clearinghouse. Direct submission is on the roadmap.

Yes. The same pattern of a bridge over standard APIs, a small canonical model and signed webhooks works for most EHRs. Tell us which system and which workflows, and we will propose a scope.

Work with the team that built it

Need something like this for your organisation?

Tell us what you are connecting, running or securing. The engineers behind this case study reply personally.

  • A senior engineer reads every enquiry
  • Happy to sign an NDA first
  • You get a written next step, not a sales sequence
Last updated