Build 5 openEHR Applications in 10 weeks

Introducing the openEHR bootcamp, what you can expect, and what you need to get started.

This will be your journey through the bootcamp.

Why do traditional monoliths, shared databases and micro services fail in healthcare and why a common data platform is necessary.

Understand how the openEHR Reference Model, Archetypes, and Templates work together.

How the openEHR CKM and Discourse community support clinical modeling, archetype reuse, and collaboration.

Requirements for the first app you will build, a template to capture a patient's vital signs.

Get hands-on with openEHR with this quick-start guide to creating templates and using the openEHR REST API.

Set up your environment with Postman, Docker, Docker Compose, and a working terminal.

Set up your Postman environment by cloning the bootcamp repository and importing the openEHR collections and environments.

Run EHRbase with Docker and Postgres to create your local openEHR server environment.

Create a new Archetype Designer repository and import the full CKM archetype export.

Build a vital-signs template in the Archetype Designer and export it as an OPT file.

Upload your OPT file using the openEHR Template API with Postman.

Use the shared bootcamp openEHR endpoint instead of localhost for assignment submissions.

The next set of videos have coding tutorials, but before you go there, try to attempt the assignment by yourself!

Find and select the appropriate openEHR archetypes needed for the vital-signs template.

Combine pulse, BP, SpO₂, height, and weight archetypes into a complete openEHR template and export it as an OPT file.

Upload the generated OPT to the bootcamp’s shared endpoint and confirm the template is registered.

Here are the requirements for the first openEHR patient app you will build, where you can upload their details including vital signs and temperature.

Learn the relationship between templates, EHRs, and compositions in openEHR and how each maps to real clinical documentation.

Explore the example composition API and understand the supported formats.

Create your first composition by generating canonical JSON, updating key clinical values, and posting it using the openEHR Composition API.

Create a flat JSON composition and post the payload to the openEHR server.

Use the composition’s UUID to fetch it from the openEHR server and view the same clinical data in multiple equivalent serialization formats.

Update an existing composition using its full versioned ID, modify its clinical values, and commit a new version to the patient's EHR.

Retrieve any historical version of a composition using its versioned ID

Delete a composition using its versioned ID and confirm that it no longer appears in standard retrieval queries.

On the importance of practicing interacting with an openEHR system yourself, creating a template, posting a composition and querying it a few times with different templates.

Navigate the openEHR REST API documentation and compare it with the Postman workflows to interpret headers, content types, and request variations accurately.

Learn practical techniques to build your app without getting overwhelmed by the full openEHR spec.

Use the example endpoint to auto-generate a composition and swap the placeholder values with inputs from your form.

Generate valid openEHR compositions instantly by feeding your Web Template into Medblocks UI’s <mb-autoform> and exporting clean flat JSON.

Create a new EHR using the openEHR API and set up a SvelteKit project that stores and displays the EHR ID.

Use Medblocks UI to render your template as a working form, export the data as flat JSON, and submit compositions directly to an openEHR server from your SvelteKit app.

Use AQL to retrieve composition IDs and timestamps for a given EHR and render a structured list your app can iterate over.

Add delete controls to your composition list, send a DELETE request to the openEHR REST API, and refresh the list without reloading the page.

Bind existing compositions back into the form, detect when the user is editing, and send a version-safe PUT request while refreshing the list seamlessly.

Explore in detail how the openEHR REST endpoints work by inspecting headers, formats, and spec details.

Understand how subject IDs and namespaces map external identifiers to openEHR EHRs.

Get hands-on with the openEHR Reference Model by manually constructing a valid Composition in canonical JSON and posting it to the REST API.

Learn to construct a FLAT Composition directly from a web template.

Learn to translate a FLAT composition into its Structured JSON equivalent.

See how CTX helpers replace repetitive context fields by defining them once at the top of a FLAT composition.

Understand how directories and subfolders work in openEHR.

Explore how contributions act as transaction-like units in openEHR, allowing multiple compositions to be committed and versioned together.

Model a real gynecology case-record form as an openEHR template by analysing its clinical context, selecting archetypes, and defining terminology bindings.

Learn how openEHR front-loads complexity to help real-world clinical forms become structured, reusable data.

Create a custom archetype when CKM doesn’t have what your use case needs, and model how the information should be captured.

Understand how slots and clusters organize and extend openEHR models.

Learn how DV_TEXT fields can also accept DV_CODED_TEXT, letting you capture either free text or coded terminology in the same element.

See how to reference a FHIR ValueSet or SNOMED CT code inside an openEHR template, enabling server-side terminology validation for coded fields.

The next set of lessons contain coding tutorials for modelling the gynaecology form. At this checkpoint, we want to encourage you to go over the fields and try modelling it yourself!

Model encounter-level context by creating a reusable cluster for department, unit, ward, and inpatient number, and attach it under the template’s context/extension section.

Capture chief complaints and patient narrative by combining the Story/History archetype with structured Sign/Symptom entries and duration.

Add relatives and their conditions under Family History, and model past medical issues by reusing Problem/Diagnosis with a past flag.

Model sexual history using the Sexual Health Summary archetype and capture menstrual details with the Menstruation Summary and LMP fields.

Capture general, abdomen, and pelvic findings using Physical Examination Findings, then add BP and a simplified urine dipstick panel.

Add a working Problem Diagnosis, capture medicines with Medication Order and procedures with Service Request.

Add terminology bindings: constrain diagnoses to disease concepts, limit meds to pharmaceutical products, and restrict service requests to procedure codes.

Build a clinical dashboard that queries an openEHR server with AQL and visualizes a patient’s vital signs.

Learn how AQL works and how to query openEHR compositions and archetypes using SQL-like paths and selectors.

Use AQL to retrieve values from different templates, join compositions with observations, and compare data with varying granularity.

Filter AQL queries by template ID and EHR ID using WHERE clauses, to target specific templates or a single patient’s EHR.

Turn hard-coded queries into reusable, dynamic AQL queries using $variable placeholders.

Learn how to create, version, and execute stored AQL queries so teams can reuse complex logic without rewriting AQL.

Learn how SELECT, FROM/CONTAINS, WHERE, and ORDER BY work in AQL.

Learn how FROM…CONTAINS selects compositions, observations, clusters, and elements across the openEHR hierarchy.

Understand how to extract exact data points like paths, elements, arrays, and aggregates, using the SELECT clause in AQL.

Filter AQL results using numeric, string, regex, and set-based conditions with AND/OR logic.

Understand how ORDER BY, LIMIT, and OFFSET control result ordering and paging through large AQL datasets.

Introducing the coding tutorials for this module. Try it yourself first before you go ahead!

Create new vital-sign compositions in the EHR so you have data to query and chart in the clinical dashboard.

Initialize a minimal SvelteKit app and verify the development environment before implementing the dashboard features.

Query multiple openEHR templates at once and extract vital sign data from different modelling styles using archetype-level AQL.

Add UI controls to switch query modes, run AQL from the frontend, shape the returned rows, and display formatted vital-sign data directly in your dashboard.

Feed your AQL result rows into Chart.js to visualize systolic and diastolic trends on a single timeline.

Build a practitioner-facing app that uses your template to create and list compositions against the shared openEHR server.

Learn practical techniques for building openEHR forms, using Medblocks UI, the EHRbase SDK, or fully manual composition creation.

Build a minimal openEHR form using plain HTML, CSS, and JavaScript, map user inputs into a flat JSON composition, and post it directly to the EHRbase composition endpoint.

Use Medblocks UI’s <mb-auto-form> to auto-generate openEHR forms from a web template and submit compositions without manually writing form logic.

Bind an existing openEHR composition back into a Medblocks UI form using bindValue and repopulate the fields from flat JSON.

Build fully customized openEHR forms using <mb-form>, with control over layout, styling, and component behavior.

Generate Java classes from an OPT and use the openEHR SDK client to create and commit compositions programmatically.

Test your skills by assembling the application end-to-end and preparing a functional demo to validate your progress.

Set up your SvelteKit project, install Medblocks UI, and load your gynecology case record template.

Structure your gynecology template into a stepwise form, keep hidden context fields valid, and export a complete composition ready for server submission.

Capture the patient’s presenting condition and build repeatable “signs and symptoms” fields using indexed paths and UI loops.

Turn a text field into a coded search input using mb-search, implement a handleSearch function, and bind selected terminology codes into a valid composition.

Model Past and Family History by combining mb-context for hidden defaults with repeatable Svelte blocks, searchable diagnosis fields, and structured relationship inputs.

Group sexual-history and menstrual fields into clean rows with buttons, and add examination findings using mb-context for general, abdomen, pelvic, urine tests, and blood pressure.

Add provisional + final diagnoses, medication orders and service requests as repeatable groups. Use mb-context for status fields.

Capture the form output with form.export(), build the composition POST URL with EHR and template IDs, and submit it to the openEHR REST API using a JSON fetch call.

Fetch compositions via AQL and display them with timestamps and IDs; and on user selection, retrieve the flat composition and bind everything back into the UI for review or editing.