Build 5 FHIR Applications in 10 Weeks

Get introduced to the bootcamp, meet the trainers, review pre-requisites, and understand course expectations before you begin the program.

Here are the technical requirements for the first FHIR app you will build, a Patient Management Application.

Learn how FHIR uses RESTful HTTP methods to perform CRUD operations on resources, and test these interactions using Postman.

Make GET requests to resources like Patient and use the metadata endpoint to inspect a server’s CapabilityStatement and verify supported operations.

Read a FHIR Resource StructureDefinition, including resource hierarchy, data types, cardinality, terminology bindings, and examples.

Perform FHIR REST operations such as create, read, update, delete, and basic searches against a FHIR server using proper JSON payloads.

Learn how different types of search parameters work, and explore techniques like chaining, modifiers, pagination, and filtering results.

Create a custom FHIR SearchParameter, and learn why support for it varies across different implementations between servers and vendors.

Introducing the coding tutorials that demonstrate the full implementation with real debugging, errors, and step-by-step development. Try it yourself first!

Set up the coding environment and fetch a patient list from a FHIR server. Display key patient details like, name, gender, and birth date.

Add pagination and sorting to the patient list by using FHIR search parameters. Implement next/previous controls and display patients in a predictable order.

Add routing to the app so users can navigate between the patient list, create patient page, and update patient page.

Build the patient form used for creating and updating a Patient resource, including field bindings, validation and date handling.

Implement complete create and update logic while effectively handling responses and managing errors in your application.

Add a search box to filter patients by their name or by an exact phone number for quick lookup from the patient list view.

Implement a debounced search for FHIR patient data, postponing API calls until the user stops typing to reduce unnecessary network requests.

Set up a HAPI FHIR server locally with Docker Compose, connect it to PostgreSQL, and use it as a fast, private FHIR endpoint.

In this live class, we will discuss how to build a simple patient management app to list all patients on a FHIR server, create new patients, edit patients, and search patients by name or phone number.

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

Requirements for the second FHIR app: a SMART on FHIR patient app that connects to Epic sandbox, retrieves patient details and displays them.

Learn how SMART leverages OAuth, scopes, and launch flows to allow apps secure access to EHR patient data without compromising privacy.

See how OAuth2 works by walking through the authorization code flow, scopes, consent, redirects, and token exchange.

Explore how OpenID Connect adds user identity to OAuth2, using scopes, ID tokens, and JWTs to share verified profile info for SMART on FHIR.

Discover how SMART on FHIR adds a .well-known/smart-configuration endpoint to FHIR servers, helping apps authenticate and interact with EHRs properly.

Understand how SMART on FHIR uses scopes to control exactly what an app can access, whether it’s acting as a patient, a practitioner, or a backend system.

Set up Postman to execute the full SMART on FHIR authorization flow using Epic’s sandbox environment for testing secure healthcare APIs.

Walk through the complete Epic login flow to obtain a real SMART on FHIR access token using Postman step by step guide.

Understand the SMART on FHIR “launch context” returned in the token response, including patient, encounter, and additional context keys.

Understand how US Core FHIR Profiles extend base FHIR with required elements, extensions, search parameters, and SMART-on-FHIR–aligned scopes.

Learn Epic's SMART-on-FHIR facade: authenticate as a patient, retrieve labs, vitals, medications, and understand the limits of an EMR-backed API.

Introducing the coding tutorial for the SMART-on-FHIR app; this and the following videos are optional for your reference only.

Set up the patient app from scratch: configure Svelte, Tailwind, and SMART on FHIR credentials, preparing the project for Epic FHIR integration.

Build the sign-in flow: generate authorization URL, redirect user to Epic, and handle the returned authorization code for SMART on FHIR login process.

Exchange the authorization code for an access token via POST request to Epic's token endpoint, enabling authenticated API calls to FHIR resources.

Learn to fetch patient data using the access token and build a "Patient Details" component showing name, gender, date of birth, and identifiers.

Learn how to track token expiry and clear expired tokens from local storage before continuing the SMART on FHIR app flow.

See how to verify that token expiry works correctly by refreshing the app and fully re-authenticating it after the token expires.

Learn to fetch a patient's medications using MedicationRequest endpoint, filter bundle entries, and display medication name, dosage, and reason clearly.

Learn to fetch lab results using the Observation endpoint with laboratory category, filter relevant entries, and display test name, value, unit, date.

Learn to fetch and display vital signs using the Observation endpoint, handle multi-component readings like blood pressure, and sort by date.

In this Live Class, we will discuss how to build a SMART Patient Application that connects to Epic

Learn to build a practitioner-facing SMART on FHIR app in Cerner: auto-launch with patient context, list vital signs, and write new information.

Learn how EHR launch works: understand iframe vs popup launches, the role of `iss` and `launch` parameters, and how apps receive SMART context.

Learn to register a SMART-on-FHIR practitioner app in Cerner sandbox, configure redirect & launch URLs and scopes, then simulate an EHR launch.

Turn Cerner EHR launch (with iss + launch) into a full SMART OAuth2 flow in Postman, and add offline_access to get a refresh token for syncing.

Learn SMART v1 scopes in Cerner: request user/Patient.read scope and use the token's patient id and iss URL to fetch the Patient resource securely.

Fetch the patient's vital signs using the FHIR Observation API, and troubleshoot common scope and query issues.

Create patient vital sign Observations in Cerner via FHIR, troubleshoot write failures from code/unit mismatches, and understand EHR write API limits.

Introducing coding tutorials that walk you through implementing the Cerner SMART app, handling the launch flow, read patient details, and create vital signs.

Learn to read `iss` and `launch` parameters from the URL and use them to fetch the SMART configuration needed to start the OAuth launch flow.

Build the full SMART on FHIR OAuth2 flow: construct authorization URL with launch token, handle the code, call token endpoint, get access token.

Render a basic demographics banner by calling the FHIR Patient endpoint with the access token and without caching tokens across launches.

Fetch patient Observation resources from FHIR server, filter out panels, and display vital signs by handling category filters, codes, and EHR systems.

Create a new temperature Observation by building an input form, validating values, constructing a FHIR-compliant resource, and posting it to the EHR.

Automatically reload the patient's vitals after creating a new temperature entry, ensuring the UI reflects the newly created Observation without manual refresh.

Compare how SMART on FHIR v1 and v2 define authorization scopes, including the shift from broad read/write scopes to granular CRUDS permissions.

Register a SMART v2 app on Cerner, obtain .well-known configuration, set scopes, include launch and audience parameters, and retrieve patient resource.

Technical requirements for SMART Backend Services app: retrieve all sandbox patients, analyze lab reports for abnormalities, and email via SMTP.

Learn how backend apps get access tokens without user login using Client Credentials grant, where a signed JWT replaces client secret for FHIR API.

Generate a public–private key pair, understand its role in signing and verification, and register the backend application on Epic using the public key.

Build a JWT for the backend app using the required claims, timestamps, keys, and Epic’s token endpoint requirements.

Use the signed JWT to obtain an access token and make authorized FHIR API requests for patients and observations.

Explains how the FHIR Bulk API works, including starting a bulk export, checking job status, and retrieving NDJSON files for patients and observations.

Covers helper scripts for the backend app: generating RSA keys, serving a JWKS endpoint, exposing it via ngrok, and using local SMTP for testing.

Learn how to use Ethereal as a dummy SMTP service instead of setting up and running a local mail server during development and testing.

Recaps the key pieces needed for building the backend app, and introduces the upcoming coding tutorials.

Set up the environment for the backend app, expose your JWKS, and outline the full pseudocode for the end-to-end workflow.

Generate a signed JWT from your private key and exchange it for an access token using Epic’s token endpoint.

Make the Bulk API kickoff request using the access token, extract the Content-Location header, and implement polling logic to wait for export files.

Stream NDJSON files from the Bulk API output, handle connection resets, and parse each resource using a streaming approach instead of Axios.

Refactor the bulk-response handler to stream NDJSON efficiently, process Patient and Observation records as they arrive, handling connection resets.

Detect abnormal lab observations, generate clear summaries for each patient, and trigger an automated email with the results.

Schedule the backend script using a cron expression so it runs automatically at a fixed time each day.

For the last FHIR app in this course, you will build a FHIR Facade for a Postgres Database that can perform SQL queries via the FHIR REST API.

Learn how a FHIR Facade works, translating API calls into database queries and returning the results in FHIR format.

Learn how to spin up a Postgres instance with Docker and seed it with patient, blood pressure, and heart-rate data.

Explore how to query patients and observations in Postgres and reshape SQL results into valid FHIR resources.

Learn how syncing your data into a FHIR server or combining a server with a write-only facade can serve as practical alternatives to a custom FHIR facade.

Implement authorization and search-result redaction so your FHIR API returns only the data a user is permitted to access.

Share feedback on your journey so far, then proceed to explore the coding tutorials for this module at your own pace.

Get familiar with HAPI FHIR, the Java toolkit that powers your facade, covering its client features and plain-server framework before you start coding.

Set up a simple Java project with Maven, configure build settings, and produce an executable JAR that you’ll extend into a HAPI FHIR server.

Explore how to integrate Jetty with HAPI FHIR, configure a servlet, and spin up a self-contained FHIR server that responds to real API requests.

Build the facade logic by creating a Patient provider, wiring it into the servlet, and preparing to map database rows into FHIR resources.

Explore how to fetch patient rows from Postgres and make them available via a FHIR search operation through a REST endpoint.

Implement the FHIR read operation by querying Postgres for a single patient by ID, and handle missing records.

List Observations by fetching data from multiple tables, construct FHIR Observation resources and link them to the correct patient.

Retrieve individual Observation records by interpreting the resource ID suffix, selecting the right table, and converting SQL results into FHIR format.