Worldwide there are many apps that are based on FHIR and connect to a FHIR store. That is a large and growing ecosystem, and for anyone who works with openEHR it raises a practical question: can those apps also work with an openEHR clinical data repository (CDR), without being rebuilt?
Open Health Hub, Syntaric and Cadasto have tested exactly that. In a test environment, the three parties connected the FHIR Viewer of Open Health Hub to an openEHR CDR, using the FHIRconnect standard. In this article I describe how this came about, what was done, how the architecture works and why I think this matters for the next generation of electronic health records.
How It Started
It started with a conversation between Martijn Verhoeven, founder of Open Health Hub, and me about connecting the Open Health Hub suite of FHIR applications to the Cadasto CDR. We both saw the big impact this could have for the health community, so we decided to do it and took the next steps.
What We Did
The parties connected the FHIR Viewer of Open Health Hub to the Cadasto CDR API. On behalf of Cadasto, Gertjan Bult, Manager Software Development, carried out the proof of concept together with Martijn of Open Health Hub and Gašper Andrejc of Syntaric. The first call took place on Thursday 3 September 2026, and the first results were shared on 25 September, so the work took a few weeks. As a result, FHIR resources could be written to and read from the openEHR CDR in both directions, through the FHIR REST API.
Figure: the FHIR Viewer of Open Health Hub in a demo environment, showing blood pressure observations (systolic and diastolic) and a list of conditions for a demo patient, retrieved via FHIRconnect from the openEHR CDR, the Cadasto CDR (demo data).
The test used FHIR R4 with three resources, Observation, Patient and Condition. The clinical data consisted of a blood pressure reading and a list of conditions (diagnoses). On the openEHR side the blood pressure reading was stored with the archetypes openEHR-EHR-COMPOSITION.blood_pressure.v0 and openEHR-EHR-OBSERVATION.blood_pressure.v2. No FHIR profiles were applied. The FHIRconnect context mapping for blood pressure points to the unprofiled Observation resource (http://hl7.org/fhir/StructureDefinition/Observation). The coding is LOINC 85354-9 (blood pressure panel) with the components 8480-6 and 8462-4, which matches the HL7 Vital Signs profile, but that profile was not enforced or validated in the test.
Patient data follows a different route. It does not go through FHIRconnect, because the Cadasto FHIR façade translates the FHIR Patient resource itself into a demographic PERSON in the Cadasto CDR.
It is important to be clear about the status. This was a test in a test environment. It shows that the approach works technically; the test setup itself is not a production deployment.
The Three Parties
Open Health Hub provides an extensive application platform for healthcare that is fully based on FHIR. The platform covers forms, embedded dashboards, workflow, and identity and compliance, and it uses FHIR and IHE SDC (Structured Data Capture) for data exchange. It is designed to work with existing EHR, EMR and portal environments.
Syntaric is a healthcare interoperability consultancy that works with FHIR, openEHR and IHE, founded by Gašper. Syntaric is co-creator of the FHIRconnect specification and founder of openFHIR, the software it built on the FHIRconnect specifications. openFHIR translates FHIR resources into openEHR compositions and the other way around.
Cadasto is an openEHR CDR vendor from Alkmaar, the Netherlands. The Cadasto CDR is a vendor-neutral openEHR data platform that fully conforms to the openEHR specifications. The Cadasto team has more than 20 years of experience with openEHR and is deeply involved in the openEHR community. The Cadasto CDR is in operational use at more than 20 healthcare organisations in the Netherlands. The CDR offers the openEHR APIs (EHR, AQL, Definitions, Demographics and Admin) and FHIR API endpoints. Those FHIR endpoints are provided by a FHIR façade on top of the CDR, not by a full FHIR server.
What FHIRconnect Is
FHIRconnect is a mapping specification for bidirectional mapping between openEHR and FHIR. The mappings are written in YAML. The idea is that one mapping file describes the relationship between an openEHR structure and a FHIR structure, and that the same file can be used in both directions: from FHIR to openEHR and from openEHR to FHIR.
The specification is open and vendor-neutral, and its documentation is published as version 1.0.0. FHIRconnect is the result of a research project, and its contributors are Diego Bosca, Gašper and Severin Kohler. Issues and discussion take place in the public GitHub repository, and there is an official mapping library. That library currently contains mappings for KDS, the German core dataset for research, as well as general archetype mappings.
The specification has a goal that goes beyond transformation. The mapping files should also serve as documentation of how data should be transformed between the two standards. Even an organisation that does not run a FHIRconnect engine can read the mappings and see how a FHIR element relates to an openEHR element. That matters for consistency, because the same clinical concept should be mapped the same way across institutions.
FHIRconnect organises mappings in three types of files:
- Model mappings describe the transformation between an openEHR archetype and a FHIR resource. They are the reusable base that communities share and maintain.
- Extension mappings add to, overwrite or append to model mappings. They are needed to map between openEHR templates and FHIR profiles or specific FHIR implementations.
- Context mappings define which profile is transformed into which template, and which mapping files are used for that. There is one context file for each profile and template that is mapped.
A typical example is a model mapping between the openEHR archetype for a problem or diagnosis and the FHIR Condition resource. This layered set-up is a sensible choice. The model mappings form a stable base at archetype level, and local or national variations are handled in extensions instead of in copies of the base.
How openFHIR Works
openFHIR is an engine that implements the FHIRconnect specification and runs FHIRconnect mappings. It offers a RESTful API with two mapping endpoints. One accepts a FHIR resource and returns the corresponding openEHR composition; the other accepts an openEHR composition and returns a FHIR resource. Both directions use a single mapping definition. The engine can also be hooked into message queueing systems for background mappings.
Atlas is the management interface of openFHIR from Syntaric. It is delivered as a Docker image alongside openFHIR and falls under the same openFHIR licence, which includes the Atlas option. Atlas needs an identity provider, such as Keycloak.
Figure: an illustration of Atlas, the management interface of openFHIR (Syntaric), in the workspace view. On the left is an openEHR flat composition, in the middle a FHIRconnect mapping for an archetype, and on the right the corresponding FHIR Bundle. The example content is the International Patient Summary template with demo data; these are not the mappings of this test.
A few properties of openFHIR are relevant for the architecture:
• It is a standalone component, packaged as a Docker container.
• It stores no clinical data. Clinical and operational data is mapped on the fly and is not stored or cached; only the mappings are stored.
• There is an open source edition on GitHub and an enterprise edition with a commercial licence. The enterprise edition adds, among other things, PostgreSQL database support, a terminology server integration, synchronisation of operational templates with openEHR servers, multitenancy, and Atlas, the management interface of openFHIR.
The test used the enterprise edition. During the test the engine ran version 3.0.2. openFHIR runs in its own container next to the Cadasto FHIR façade, in the same Kubernetes namespace, with its own PostgreSQL database for the mappings.
openFHIR can also translate FHIR search to openEHR AQL. This was added as a beta feature in openFHIR version 2.0.1, released on 14 March 2026. The test did not use this feature. The Cadasto FHIR façade builds the AQL for searches itself, based on its own configuration of search parameters per resource, and it publishes in its CapabilityStatement which search parameters it supports for each resource. openFHIR is only called for the conversion between FHIR and openEHR.
Figure: openEHR and FHIR are complementary: FHIRconnect maps between them in both directions.
Archetypes and Templates, Resources and Profiles
FHIR and openEHR model clinical information in different ways, and that difference is the reason a mapping layer is needed between them.
openEHR uses multi-level modelling. At the bottom there is a small, stable reference model that every openEHR system shares. On top of that are archetypes: reusable definitions of clinical concepts such as a blood pressure reading or a medication order, built and reviewed by clinicians in the Clinical Knowledge Manager (CKM). Templates combine and tailor archetypes for a specific use, such as a discharge summary. Applications are built on templates and read and write data through a standard REST API, and they query data with AQL.
FHIR is an HL7 specification for healthcare interoperability. It defines resources, such as Observation or Condition, which applications exchange through an API. Profiles constrain and extend those resources for a specific context, for example a national implementation guide.
The two approaches line up reasonably well, and FHIRconnect makes use of that. A model mapping sits at the level of an archetype and a base resource. An extension mapping sits at the level of a template and a profile. The clinical content stays defined in openEHR, where clinicians model it, and the exchange format stays FHIR, which the app developers already know.
Architecture
The architecture of the test has five parts, and the Cadasto FHIR façade is the hub. Cadasto built this façade, and it handles all FHIR communication with the app. The app authenticates with OAuth 2 against the Cadasto CDR API. openFHIR from Syntaric is a translation service beside the façade: the façade sends it a request and gets a reply back, and openFHIR translates between FHIR resources and openEHR compositions with FHIRconnect mappings. The façade does not access the database itself. It uses the openEHR API of the Cadasto CDR to write and read the data, and the Cadasto CDR stores the data as openEHR compositions, structured according to archetypes and templates.
When the app writes, it sends a FHIR resource to the Cadasto FHIR façade. The façade sends a request with the FHIR resource to openFHIR, openFHIR returns the openEHR data to the façade, and the façade writes that openEHR data to the Cadasto CDR through the openEHR API. Reading mirrors this. The façade reads the openEHR data from the Cadasto CDR through the openEHR API, openFHIR translates it into FHIR, and the façade returns the FHIR resource to the app. openFHIR does not talk to the openEHR API, the CDR or the app directly.
Diagram: the Cadasto FHIR façade is the hub. It talks FHIR with the app, calls openFHIR for the translation, and writes and reads the openEHR data through the openEHR API of the Cadasto CDR. The request and reply between the façade and openFHIR show the write flow. Reading mirrors it: the façade reads openEHR data through the openEHR API, sends it to openFHIR, gets FHIR back and returns it to the app.
For the app, the CDR looks like a FHIR endpoint. For the CDR, the data arrives as openEHR through its own openEHR API. Neither side has to give up its own standard, and each component has a clear task: the façade handles the FHIR communication, openFHIR handles the clinical mappings, the openEHR API gives access to the CDR, and the CDR stores the data.
A FHIR Façade on openEHR Is Not the Same as a FHIR Store
In many architectures, FHIR data is kept in a FHIR store or FHIR server. A typical data-centric set-up has an openEHR repository and a separate FHIR server, and without a mapping engine these systems remain isolated and cannot sync data.
What we tested is a different pattern. Here the Cadasto FHIR façade sits on top of the openEHR CDR. The data is stored once, at the source, in openEHR. When an app reads, the façade has openFHIR produce the FHIR representation on the fly, and when an app writes, the façade has openFHIR translate the incoming FHIR resource into an openEHR composition before the façade stores it through the openEHR API. Because openFHIR stores no clinical data, there is no second copy that has to be kept in sync, and no migration step between a FHIR store and the CDR.
This has consequences that are worth stating plainly. The quality of what the app sees depends on the quality of the mappings. Search behaviour depends on what the façade supports, which is why the façade publishes its supported search parameters per resource in its CapabilityStatement. These points are much easier to develop further with an open, shared mapping specification than with private, one-off conversions.
Why This Matters
Healthcare is not an exact science. It needs flexibility at the application level and at the database level, and separating application and database is essential. That is also one of the core ideas of openEHR: data is stored in a vendor-neutral format, separate from the applications that use it, so that an application can be replaced while the data stays meaningful.
This use case shows that two major healthcare standards, FHIR and openEHR, work together seamlessly and reinforce each other. With its flexible information model and stable technical framework, openEHR provides a stable foundation for a life-long EHR. FHIR has a very broad portfolio of apps that can communicate reliably with the database. Together they are a strong pair, and I am convinced that this is the future of the new generation of EHRs.
For organisations in the healthcare market this means they do not have to choose between the two standards. They can keep their clinical data in an openEHR CDR for the long term and still give FHIR applications access to it. For app builders it means that an openEHR CDR does not have to be a separate world with its own integration project, as long as the mappings exist.
Where We Stand
This test shows that a FHIR application, in this case the FHIR Viewer of Open Health Hub, can connect to an openEHR CDR through the Cadasto FHIR façade, which uses openFHIR and FHIRconnect mappings for the translation, and that data can flow in both directions. The Cadasto FHIR façade used in the test is a proof of concept and is not yet at production level.
I would like to thank the teams at Open Health Hub, Syntaric and Cadasto for the work they put into this. If you work with FHIR apps or openEHR CDRs and want to know more about this approach, feel free to contact me.
People involved
- Martin van der Meer, VAR Partner Manager, Cadasto (author):
https://www.linkedin.com/in/martinvandermeer/ - Gertjan Bult, Manager Software Development, Cadasto:
https://www.linkedin.com/in/gertjan-bult/ - Martijn Verhoeven, Founder / CTO, Open Health Hub:
https://www.linkedin.com/in/martijnverhoeven/ - Gašper Andrejc, Founder, Syntaric:
https://www.linkedin.com/in/andrejcgasper/
Sources
- FHIRconnect Specification Documentation, v1.0.0 (About, contributors, mapping library)
- FHIRconnect, Types of mapping files
- FHIRconnect, Model Mappings
- FHIRconnect, FHIRsearch and AQL
- openFHIR
- openFHIR release notes
- openFHIR, FHIR Search to AQL (GitHub discussion #12)
- Syntaric
- Cadasto
- Open Health Hub
- Open Health Hub FHIR IG (Implementation Guide)
- HL7 FHIR Foundation
- openEHR International
- openEHR, What is openEHR?



