Build 5 FHIR Applications in 10 Weeks

Introducing the bootcamp, trainers, pre-requisites and setting expectations

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 understand why support varies across implementations.

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 the complete create/update logic and handle responses and errors.

Add a search box to filter patients by name or exact phone number.

Implement debounced search for FHIR patient data, delaying API calls until the user stops typing.

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

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

Learn how SMART uses OAuth, scopes, and launch flows to let apps securely access EHR data.

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

Explore how OpenID Connect adds standardized user identity on top of OAuth2, using scopes, ID tokens, and JWTs to share verified profile information that SMART on FHIR relies on.

Discover how SMART on FHIR adds a standardized .well-known/smart-configuration endpoint to any FHIR server, helping apps know exactly how to authenticate and interact with an EHR.

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 run the full SMART on FHIR authorization flow with Epic’s sandbox.

Walk through the full Epic login flow to retrieve a real SMART on FHIR access token using Postman.

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 how to work with Epic’s SMART-on-FHIR facade, authenticate as a patient, and retrieve real clinical data like labs, vitals, and medications while understanding the limits, filters, and quirks of an EMR-backed FHIR API.

Introducing the coding tutorial for the SMART-on-FHIR app (this and following videos are optional).

Set up the patient app from scratch by configuring Svelte, Tailwind, and your SMART on FHIR credentials, preparing the project for authentication and further Epic FHIR integration.

Build the sign-in flow by generating an authorization URL, redirecting the user to Epic, and handling the returned authorization code so your app can continue the SMART on FHIR login process.

Build the sign-in flow by generating an authorization URL, redirecting the user to Epic, and handling the returned authorization code so your app can continue the SMART on FHIR login process.

Learn how to fetch patient data using the access token and build a clean “Patient Details” component that shows the user’s name, gender, date of birth, and identifiers after login.

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 re-authenticating.

Learn how to fetch a patient’s medications using the MedicationRequest endpoint, filter bundle entries, and display medication name, dosage, and reason in a clean list.

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

Learn how to fetch and display vital signs using the Observation endpoint, handle multi-component readings like blood pressure, and sort results by date for a clear, structured view.

Learn how to build a practitioner-facing SMART on FHIR app inside Cerner, auto-launching with patient context, listing existing vital signs, and writing new information to the patient’s record.

Learn how an EHR launch works by understanding iframe vs popup launches, the role of the `iss` and `launch` parameters, and how apps receive context during SMART on FHIR authentication.

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

How to turn a Cerner EHR launch (with iss + launch) into a full SMART on FHIR OAuth2 flow in Postman, and add add `offline_access` to get a refresh token so your app can sync data in the background.

Learn how SMART v1 scopes work in Cerner by requesting the correct `user/Patient.read` scope and using the token’s patient id and `iss` URL to fetch the Patient resource.

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

Creates patient vital sign Observations in Cerner via FHIR, troubleshoots write failures due to code/unit mismatches, and understand constraints of EHR write APIs compared to read APIs.

Introducing coding tutorials that walk you through implementing the Cerner SMART app, that handle the launch flow, read patient details, and create a new vital sign.

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 the authorization URL with the launch token, handle the returned code, call the token endpoint, and retrieve the access token from Cerner.

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

Fetch a patient’s Observation resources from the FHIR server, filter out panel observations, and display vital-sign results by handling category filters, coded values, and varying EHR coding 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 a 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 the .well-known configuration, set scopes, include launch and audience parameters, and retrieve a patient resource using OAuth2.

Technical requirements for the SMART Backend Services app, that will retrieve all sandbox patients, analyze their lab reports for abnormalities, and email the results through an SMTP server.

Learn how backend apps get access tokens without user login using the Client Credentials grant, and how a signed JWT replaces a client secret to securely request an access token for FHIR API calls.

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 the helper scripts needed for the backend app, for generating RSA keys, serving a JWKS endpoint, exposing it through ngrok, and using a local SMTP server for testing email delivery.

How to use Ethereal as a dummy SMTP service instead of running a local mail server.

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 the export files to become ready.

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 each Patient and Observation record as it arrives, and ensure the stream resolves correctly even when Epic resets the connection.

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 of your journey so far and step into the coding tutorials for this module.

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 expose them through a FHIR search operation.

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 the SQL result into a FHIR Observation.