Build 5 openEHR Applications in 10 weeks

Get introduced to the openEHR bootcamp, what to expect, and the requirements to get started with hands-on exercises.

Follow your full journey through the openEHR bootcamp, gaining practical skills and completing hands-on exercises.

Learn about the prerequisites and resources needed for this course to ensure a smooth start to your learning journey.

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 to structure and manage clinical data.

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

Discover the requirements for your first app, including building a template to capture a patient's vital signs accurately.

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

Learn how to set up your development environment with Postman, Docker, Docker Compose, and a terminal for FHIR testing.

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

Learn how to efficiently run EHRbase with Docker and Postgres to set up your local openEHR server environment for testing.

Learn how to create a new Archetype Designer repository and import the full CKM archetype export for openEHR projects.

Step-by-step complete guide to building a vital-signs template in Archetype Designer and exporting it as an OPT file.

Step-by-step guide to uploading your OPT file using the openEHR Template API via Postman for testing and integration.

Learn how to use the shared bootcamp openEHR endpoint instead of localhost for submitting assignments and testing data.

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

Learn how to find and select the correct openEHR archetypes required to build an accurate vital-signs template.

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

Learn how to upload a generated OPT to the bootcamp’s shared endpoint and confirm that the template is registered.

Join the introductory class to kick off the openEHR Bootcamp and get started with hands-on exercises and learning.

Students present their demos of building openEHR templates, highlighting their understanding and practical skills.

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 learn about the supported formats for sending and receiving openEHR data.

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

Learn how to create a flat JSON composition and post the payload to the openEHR server for accurate data entry.

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.

Learn how to retrieve any historical version of an openEHR composition using its versioned ID for accurate record tracking.

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

On the importance of practicing with an openEHR system yourself: creating a template, posting a composition, and querying it 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.

Discover practical and effective techniques to build your app without being overwhelmed by the full openEHR specification.

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 data as flat JSON, and submit compositions directly to an openEHR server.

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 for accurate data integration.

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

Step-by-step guide to constructing a FLAT Composition directly from a web template for accurate openEHR data entry.

Step-by-step guide to translating a FLAT openEHR composition into its structured JSON equivalent for proper usage.

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

Learn how directories and subfolders work in openEHR to efficiently organize archetypes, templates, and composition data.

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

In this class, we thoroughly discuss the Module 2 exercise, its objectives, and how to approach building your solutions.

Students will present their demos from the second module, showcasing their progress and practical implementations.

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 work to organize and extend openEHR models for flexible and reusable clinical data.

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.

he next set of lessons contain coding tutorials for modelling the gynaecology form. At this checkpoint, try modelling it yourself before continuing!

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

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.

Learn how to turn hard-coded queries into reusable, dynamic AQL queries using $variable placeholders for flexibility.

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

Learn exactly how SELECT, FROM/CONTAINS, WHERE, and ORDER BY statements work in AQL to query openEHR data effectively.

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.

Learn how to filter AQL results using numeric, string, regex, and set-based conditions with AND/OR logic efficiently.

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

Get introduced to the coding tutorials for this module and try exercises yourself to strengthen your practical skills.

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 flat JSON composition, and post it directly to EHRbase.

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.

Learn how to set up your SvelteKit project, install Medblocks UI, and load the 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 relationship inputs.

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

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

Discover openEHR for healthcare data standardization. Build interoperable systems with archetypes and templates.

Fetch compositions via AQL and display them with timestamps and IDs; on user selection, retrieve the flat composition and bind it into the UI.