OpenEMR vs Medplum

OpenEMR is a ready-made, ONC-certified practice EHR with billing. Medplum is a FHIR developer platform for teams building their own clinical applications. The right choice depends on whether you need a finished EHR or a foundation to build one.

On this page

OpenEMR or Medplum: when a ready-made EHR beats building your own

A ready-made EHR fits when clinical workflows, billing and certification must work on day one. OpenEMR is a GPL-3.0 electronic health records and practice management application with scheduling and billing, and it has ONC certification: its 7.0.0 release was certified on 7/19/22 as a 2015 Edition Base EHR. A custom build on Medplum fits when your organization needs a clinical application that differs from a standard practice workflow, and when you have the people to design, test and certify it. Neither path is universally better. The decision turns on three questions: whether clinical workflows, billing and certification must be production-ready at launch, whether your team has FHIR and application engineering capacity, and who owns HIPAA and compliance evidence.

Start with the day-one question. OpenEMR ships with patient charting, scheduling, billing and a FHIR R4 API that implements US Core 8.0 and SMART on FHIR v2.2.0, so most of the clinical and administrative functions already exist. Medplum provides building blocks: Medplum Auth, a clinical data repository, a FHIR R4 API with GraphQL support, an SDK, React components and Bots. Those blocks are the foundation of your application, not the application. Ask each vendor which certification edition and version covers the modules you plan to use, and confirm what your own clinical workflows require before you commit. Certification status applies to a specific release, so check that the version you deploy is the one the vendor documents.

The second question is team capacity. Medplum's self-hosting docs recommend AWS deployment with CDK and CloudFormation, and its upgrading guide requires each minor version to be applied in sequence, with post-deploy data migrations that can run for hours or days on large datasets. Someone must own that upgrade path, along with the Node.js, PostgreSQL and Redis stack beneath it. The third question is compliance. HIPAA has no certification; the rule is enforced through HHS complaints, compliance reviews and audits. Medplum describes compliance as a shared responsibility, so your team must document which controls it covers and which remain yours. Under either path, a business associate contract under 45 CFR 164.314 must set the vendor's Security Rule obligations in writing. Have your counsel and security team review that contract before go-live.

Which platform fits which scenario

This table maps common healthcare scenarios to the platform that fits each one better, and states the condition that makes it so. Read each row as a starting question: if the condition holds in your organization, the named platform is the likelier fit, and if it does not, the other option deserves a closer look.

ScenarioBetter fitCondition that makes it so
Multi-provider clinic needing scheduling and billingOpenEMRStaff need a working EHR with scheduling, billing and practice management from the start, and the clinic has no team to build clinical screens or workflows.
Health system building a patient-facing app on FHIRMedplumThe organization wants a FHIR R4 API, SDK and React components to build its own application, and has engineers who will own the app code and its release cycle.
Digital health startup with an engineering teamMedplumThe team plans to ship a product on a FHIR data layer, expects to write custom logic in Bots and components, and can take on the hosting and upgrade work or buy hosted service.
Public health program needing bulk data exportDepends on the data modelOpenEMR offers FHIR Bulk Data v1.0 export in NDJSON at system, patient and group level. Medplum fits when the program wants a FHIR repository it designs around, so confirm the bulk export behavior for your version before choosing.
Organization with an existing EHR that needs integrationDepends on the existing systemIf the current EHR is the system of record and you need a FHIR layer beside it, Medplum suits a new integration layer, while OpenEMR suits replacing or running clinical and billing workflows in one application.
Practice needing ONC-certified EHR evidenceOpenEMRBuyers ask for certified EHR software as part of procurement. OpenEMR 7.0.0 was ONC certified as a 2015 Edition Base EHR, and the project asks users to run version 8 to keep active certification, so confirm the current certification status with the project.
Team that needs a managed platform with a vendor-run compliance programMedplumMedplum's hosted plans and compliance documentation describe a shared responsibility model, so the team must confirm which controls Medplum operates and which fall to the customer under its agreement.

How OpenEMR and Medplum are built and deployed

OpenEMR is a PHP application that you run as a practice system on a relational database, while Medplum is a TypeScript server you run as a developer platform with its own data stores. Each card below covers one part of that difference, from runtime and data stores to hosting options and the skills your team needs to keep either one running.

OpenEMR runtime and database

OpenEMR is a PHP application that runs on a MySQL- or MariaDB-compatible database. Recent releases require PHP 8.3 or later, so your team needs to own PHP runtime upgrades, web server configuration and database administration. Confirm which PHP and database versions your chosen release supports before you plan the host image, and check whether your DBA team is comfortable with the schema and backup approach used by the project.

Medplum server stack

Medplum's server is built on Node.js and TypeScript and uses PostgreSQL as its database and Redis as its cache. Operating it means your platform team owns three runtimes, the Node.js service, PostgreSQL and Redis, plus the client applications built against its FHIR API. Ask whether your Postgres and Redis operators already run these services in your environment, since both become part of your uptime and backup scope.

Medplum self-hosting targets

Medplum documents AWS deployment with CDK and CloudFormation as the recommended path, with Ubuntu via an APT repository, Docker, Kubernetes, DigitalOcean and building from source also available. Terraform-based GCP and Azure deployments are marked Beta, so do not plan production on them without testing. Choose the target your infrastructure team can operate, and confirm which option your security team will accept for network segmentation and secrets handling.

Docker and container options

OpenEMR offers Docker deployment options, which can speed up a test environment, but a container image still needs persistent volumes for documents, a managed database and TLS termination. Medplum also supports Docker and Kubernetes, which suit teams already running container platforms. Either way, your container team needs skills in image patching, secrets injection and volume backup. Ask the vendor which images and tags are supported for production before you adopt one.

Upgrade sequencing for Medplum

Self-hosted Medplum must move through each minor version in sequence, because skipping versions causes startup failures. Post-deploy data migrations can run for hours or days on large datasets, so an upgrade needs a maintenance window and a rehearsal on a copy of production data. OpenEMR upgrades follow a different path: its 8.x releases fixed security issues in FHIR APIs and the patient portal, so schedule patching as an ongoing task. Ask both vendors for their upgrade guides before you commit.

Skills each path requires

OpenEMR asks for PHP, web server and relational database administration, plus clinical configuration of the application itself. Medplum asks for Node.js and TypeScript, PostgreSQL and Redis operations, cloud infrastructure as code for CDK or Terraform, and application development against its FHIR API. Map these to your current staff before you decide. If your team lacks a skill, the gap is the cost to close, whether through hiring, training or a fixed-scope implementation partner.

Side-by-side: FHIR, SMART, certification and identity

This table compares how OpenEMR and Medplum handle licensing, FHIR and SMART support, OAuth and OpenID Connect, identity providers, certification and compliance documentation. Read each row as a question to confirm for your own version and deployment, because the two platforms serve different starting points.

CapabilityOpenEMRMedplum
LicenseGNU GPL v3.0, a copyleft license that applies to modifications you distributeApache 2.0, a permissive license that allows proprietary derivative work with attribution
FHIR APIFHIR R4 (4.0.1) with US Core 8.0 profiles, delivered as part of the EHR applicationFHIR R4 API with GraphQL support, as a developer platform for building new clinical applications
SMART on FHIRSMART on FHIR v2.2.0, with granular scopes for third-party appsSMART-on-FHIR supported through Medplum Auth; confirm the exact SMART version against current docs
OAuth and OpenID ConnectOAuth 2.0 and OpenID Connect, with PKCE for public appsOAuth, OpenID Connect and SMART-on-FHIR through Medplum Auth, with client credentials for server-to-server access
Identity provider optionsLocal accounts plus LDAP and Active Directory login (version 6.0.0) and Google Sign-In (version 6.1.0)Medplum as identity provider, external providers such as Google, Auth0 or AWS Cognito, corporate domain IdPs and multi-factor authentication
Bulk data exportFHIR Bulk Data v1.0 export at system, patient and group level in NDJSON; confirm scope for your deploymentConfirm bulk export support and limits against current Medplum documentation before design decisions
Certification statusONC certified as a 2015 Edition Base EHR for version 7.0.0 (certified 7/19/22); confirm the certified version and listing for your releaseCompliance documentation lists ONC certification; confirm which product, version and criteria the listing covers
Compliance documentationProject states ONC certification; your HIPAA safeguards and evidence are your own to produceDocumentation covers HIPAA, SOC 2 Type II, ONC, CFR Part 11, HITRUST e1, CLIA/CAP and ISO 9001, and states compliance is a shared responsibility

What each license and edition covers

OpenEMR is licensed under the GNU GPL v3.0, so the software itself carries no license fee. Your spending goes to the infrastructure, the people who install and run the system, and any testing or assessment work you commission. Certification works differently from the license: the ONC certification applies to a specific released version and does not carry over to later versions automatically.

  • License: GNU GPL v3.0, with the software free to download and use under the license terms.
  • Certification scope: OpenEMR 7.0.0 was ONC certified on 7/19/22 as a 2015 Edition Base EHR, after testing by SLI concluded on 6/30/22.
  • Upgrade notice: The project's website told users to upgrade to version 8 by March 1, 2026 to keep their system's active certification.
  • Version currency: Recent releases such as 8.4.1, released September 20, 2026, include security fixes, so both the certification question and the patch question depend on the version you actually run.

Before committing, check the current certification listing and the upgrade notice on the project's site, and confirm which version your deployment would run.

Hosting, BAAs and who carries HIPAA responsibility

HIPAA duties attach to covered entities and their business associates for the electronic protected health information they handle, so the first decision is whether your organization is a covered entity, a business associate, or both once a platform vendor touches patient data. Under 45 CFR 164.314, a business associate contract must require the business associate to comply with the Security Rule, flow the same terms down to subcontractors that handle ePHI, and report security incidents, including breaches of unsecured PHI. Ask any vendor or host for that contract language in writing before pilot data moves. Also note that there is no HIPAA certification. HHS states that no Security Rule standard requires certification, so a vendor claim of being "HIPAA certified" should be treated as a question to answer, not as evidence.

With Medplum, the hosted service and the company's compliance documentation describe compliance as a shared responsibility between Medplum and its customers. Confirm in writing which controls Medplum operates (infrastructure, encryption, logging, backup, incident response) and which ones your team configures, such as user provisioning, MFA enforcement, client application scopes and the clinical apps you build on the FHIR API. Self-hosted Medplum moves more of that line onto your side. With self-hosted OpenEMR, the organization owns the hosting controls: the server, database, TLS termination, backups, access to the sites/ directory and the administrative scripts, and the patient portal exposure. The OpenEMR security guidance on allowing only HTTPS and removing setup scripts after installation is a checklist your own team must run and evidence. If you choose a cloud host for either path, get that host's BAA as well, and map every system that stores or transmits ePHI, including backups, logs and third-party SDKs.

Before signing, request four things in writing from every vendor and hosting provider: the BAA text, a responsibility matrix that assigns each Security Rule safeguard to a named party, the exact hosting boundary (regions, subprocessors, and where backups and logs live), and the incident notification timeline and contact. Compare the answers across the two paths. A hosted Medplum plan and a self-hosted OpenEMR deployment on a cloud account may both require a BAA with the cloud provider, but only one of them may hold the operational controls you are being asked to evidence. Independent auditors, not the vendor and not DeployOpen, issue any attestation you might later need, so ask which assessments the vendor holds and their scope before relying on them.

What drives the cost of running each path

Neither platform charges a license fee at its open-source tier, so the cost of OpenEMR and Medplum lies in the people, infrastructure and evidence around them. For OpenEMR, the one-time costs are configuration, interface work, data migration and the decision about who hosts it. The recurring costs are hosting, database and backup operations, patching and the staff who apply OpenEMR upgrades. For Medplum, the one-time costs include designing the application on the FHIR API, building SMART-on-FHIR apps and Bots, and setting up identity through Medplum Auth or an external provider. The recurring costs are the cloud footprint for the PostgreSQL and Redis services, engineering time to keep the application current, and any hosted or enterprise subscription you choose. Medplum's hosted tiers are priced on its pricing page, and you should compare those figures against your own infrastructure quote rather than assume either option is cheaper.

The largest variable on the Medplum side is upgrade effort. Its upgrading guide says self-hosted deployments must move through each minor version in sequence, that skipping versions causes startup failures, and that post-deploy data migrations can run for hours or days on large datasets. Plan a staging environment with a copy of production data, a maintenance window and a rollback path, and ask your team or DeployOpen to estimate the migration window against your data volume before you commit. OpenEMR upgrades carry their own cost, since the project's security fixes and its requirement to move to version 8 to keep certification active mean you should budget for regular upgrade testing. Security testing applies to both paths. Ask for the testing scope in writing, including the custom application and its FHIR and SMART endpoints, and confirm whether the quote includes retesting after each upgrade.

Compliance evidence is often the cost that surprises teams. Medplum's compliance documentation says compliance is a shared responsibility, so the policies, access reviews, risk analysis and vendor agreements that cover your application fall to your organization. OpenEMR's certification is a product-level attestation that does not transfer to your local configuration, so you still prepare evidence for your own deployment. Ask any quote to separate the one-time evidence build (policies, data flow diagrams, control mapping and a first risk assessment) from the recurring work of collecting evidence each year. Also ask who signs business associate agreements for hosting and subcontractors, because those contracts add legal and procurement effort that appears in neither product's license. Optional paid support from the vendor or an implementation partner should be quoted as a separate line with stated response expectations.

What each platform costs to run, by component

Both paths carry the same categories of cost, but the payer changes. OpenEMR is a ready-made application you host and operate yourself, while Medplum is a developer platform where you build the clinical application on top of it. Use these cards to map who pays for each component and what moves the total up or down.

Infrastructure and hosting

On the OpenEMR path, you run a PHP application on a MySQL- or MariaDB-compatible database, with Docker as one supported deployment option, so hosting cost is mostly servers, storage, backups and the network you place it on. On the Medplum path, the server runs on Node.js and TypeScript with PostgreSQL and Redis, and hosted plans are priced by the vendor. Ask each vendor which components they manage and which you keep. Your hosting bill depends on patient volume, availability targets and whether you run separate environments for development and production.

In-house skills and staffing

OpenEMR asks for administrators who can run PHP, the database, web server hardening and clinical configuration, and who can take on the project's Securing OpenEMR steps. Medplum asks for engineers who can write TypeScript applications against FHIR R4, configure SMART-on-FHIR and manage a Node.js and PostgreSQL service. The cheaper path depends on which skill set you already employ. Estimate the headcount for each path before comparing license-free options, because staff time is usually the largest recurring cost in either model.

Vendor and partner support

Medplum sells hosted plans and an Enterprise Self-Hosted option at custom pricing, and its published hosted pricing starts with a Free tier, then Production at $2,000 per month and Premium at $6,000 per month (Medplum pricing page). OpenEMR is free to use under GPL-3.0, so any support cost comes from a service provider or your own staff. Ask each party for a written scope covering incident response hours, upgrade assistance and who holds the on-call duty. Vendor support on the Medplum side is a contract line item, while on the OpenEMR side it is a separate, negotiated engagement.

Upgrades and patching

Medplum ships major versions once a year, minor versions two to three times a year and patch versions weekly, with security patches targeted within 7 days for critical vulnerabilities and 14 days for high ones (Medplum versioning policy). Self-hosted Medplum must move through each minor version in sequence, and post-deploy data migrations can run for hours or days on large datasets. OpenEMR's 2026 releases fixed security issues in FHIR APIs, the patient portal and billing, so you must schedule routine upgrades against your own change windows. Budget for test environments and rollback plans on either path.

Security testing

Under either path, you own testing of the application you deploy or build. On OpenEMR, the scope covers the hardened configuration, the FHIR API and the patient portal, which have had recent security fixes. On Medplum, your custom application, Bots, client credentials and SMART app scopes are added attack surface on top of the platform. Ask whether the testing budget covers application testing, API testing and the infrastructure underneath, and plan retests after each major upgrade or custom feature release.

Compliance preparation

Neither vendor's documentation removes your HIPAA obligations. Medplum's compliance docs list HIPAA, SOC 2 Type II, ONC certification and HITRUST e1 and state that compliance is a shared responsibility. OpenEMR's ONC certification is a product certification of the 2015 Edition Base EHR, not a HIPAA certification, and HHS states that no HIPAA Security Rule standard requires certification. Ask each party for its shared responsibility matrix, the evidence it supplies and what you must produce for your own risk analysis and business associate agreement. Assessment fees depend on the frameworks you pursue.

Moving data and workflows between the two

This sequence shows which parts of an OpenEMR deployment can move to a Medplum-based application as standard FHIR data, which parts must be rebuilt, and how to confirm the result before switching live users over.

  1. Inventory clinical, billing and custom workflows

    Start by listing every workflow your staff depend on in OpenEMR: scheduling, encounters, orders, clinical documentation, billing and claims, patient portal use, reports and any local customizations or forms. Assign each one an owner in clinical operations and one in IT. Note which items are standard OpenEMR screens and which were built or modified by your team or a vendor. The output is a signed-off inventory that separates data to move from behavior to rebuild. Ask your OpenEMR support or integration partner to confirm which modules and custom code exist in your installation, since that list usually drives the scope.

  2. Map OpenEMR data to FHIR R4 and US Core

    For each data domain in the inventory, identify the target FHIR R4 resource and the US Core profile it should conform to, such as Patient, Encounter, Condition, Observation, AllergyIntolerance, MedicationRequest and Procedure. OpenEMR's FHIR API implements FHIR R4 (4.0.1) and US Core 8.0, so compare its output against those profiles first. Document fields that have no direct counterpart, local code systems and free-text content. The output is a field-level mapping document that a clinical informaticist and a developer have both reviewed. Confirm each mapping against the exact profile versions your Medplum project will validate against.

  3. Extract data with Bulk Data export

    Use OpenEMR's FHIR Bulk Data v1.0 export at system, patient or group level, which produces NDJSON files. Run extraction against a copy of production, not the live system, and scope it to the patient populations and resource types in your mapping. Record the counts exported per resource type and keep the export logs with the run. The output is a set of NDJSON files with a reconciliation report showing counts by resource type. Ask OpenEMR's maintainers or your vendor to confirm which scopes and resources your installed version supports before you plan the run.

  4. Load and transform into the target platform

    Convert the NDJSON files into the target model, applying the mapping rules and resolving local codes to standard terminologies where the source data allows. On the Medplum side, load the resources through its FHIR R4 API using a client credential with the minimum scope needed for the import. Keep the transformation scripts in version control so every rule can be reviewed and rerun. The output is a loaded test environment with error logs, rejected records and a list of mappings that needed manual decisions. Where you add Medplum Bots or HL7 interfaces, document them as new build work, not as migrated logic.

  5. Rebuild billing, workflow and custom screens

    Billing does not move as data. Claims logic, fee schedules, payer rules, superbills and the workflows that drive them must be redesigned and built in the new application, then tested against real payer rules and your billing staff's sign-off. Custom OpenEMR screens, forms and reports also need to be rebuilt with the Medplum SDK and React component library, or the team must decide to retire them. Integrations, such as lab, pharmacy, fax or SMS connections, need their own build and security review. The output is a rebuilt feature list with each item marked as rebuilt, retired or deferred. This is the largest source of cost and schedule risk in the sequence.

  6. Validate data, security and compliance evidence

    Compare record counts, sampled patient charts and key clinical values between source and target. Test access control end to end, including SMART scopes, identity provider configuration, multi-factor authentication and audit logging, because the new system will have its own access model. Review the business associate position for every hosting provider and vendor, since Medplum's compliance documentation states that compliance is a shared responsibility. The output is a validation report signed by clinical, billing and security owners, plus an updated risk analysis for the new environment. Confirm with your compliance advisor which evidence your regulators or auditors will expect.

  7. Cut over and plan for the cost of reversal

    Schedule the cutover with a rollback plan, a read-only window for OpenEMR, and a defined owner for reconciling any changes made during the transition. Run both systems in parallel only as long as your validation plan requires, and retire OpenEMR access for staff once the sign-off is complete. Keep the final export and the mapping documents archived. The output is a documented cutover record and a decommissioning checklist. Note that switching back later repeats most of this sequence in reverse, so the cost of leaving either platform is largely the cost of rebuilding the workflows you chose not to carry across.

Where implementation projects run long on each path

On the OpenEMR path, the schedule usually slips in configuration and integration rather than in installation. Standing up the application is the short part. The longer work is mapping clinical workflows to templates, forms, scheduling rules and billing setup, then deciding which external systems (labs, imaging, payers, a patient portal) must talk to OpenEMR through its FHIR API. Hosting hardening adds its own queue: the Securing OpenEMR guide asks you to allow only HTTPS, consider opening only port 443, remove setup.php and other admin scripts after installation, and block direct web access to sites/*/documents. Confirm who owns each of those steps, and whether your web server and firewall team can make those changes within your change-control process. Identity is the other common delay. OpenEMR's LDAP and Active Directory login validates passwords against the directory but still requires the user to exist in OpenEMR, so account provisioning and deprovisioning must be designed, not assumed. Google Sign-In, added in version 6.1.0, needs its own review of which accounts are allowed.

On the Medplum path, the schedule usually slips earlier, in application architecture and FHIR data modeling. Your team must decide which resources hold clinical data, how custom extensions and profiles represent local concepts, and where business logic lives: in the React front end, in Bots for server-side logic, or in both. Each of those choices affects validation and testing later. Identity provider configuration is the next risk. Medplum supports its own identity provider, external providers such as Google, Auth0 or AWS Cognito, domain-level corporate identity providers, client credentials and multi-factor authentication, and the combination you choose needs explicit testing for both clinician and patient flows. Self-hosting adds upgrade sequencing: Medplum's upgrading guide says each minor version must be applied in order, skipping versions causes startup failures, and post-deploy data migrations can run for hours or days on large datasets. Plan a staging rehearsal with a production-sized copy of the data before you commit to a date.

Validation of the clinical application itself is the step most often underestimated on either path. A certified EHR arrives with its certification scope already defined, but a custom application built on Medplum does not inherit any certification, and Medplum's compliance documentation states that compliance is a shared responsibility between Medplum and its customers. Confirm early which clinical workflows, safety checks, audit logging and access rules your organization must test and document, and who signs off on them. Ask your implementation partner to show how test evidence, change records and access reviews will be produced during the build, not after it. The schedule risk is usually the gap between a working prototype and an application your quality, security and compliance owners will accept. Agree on that acceptance standard in writing before fixing the scope.

Questions buyers ask before choosing between OpenEMR and Medplum

What does it cost to run OpenEMR compared with Medplum?

OpenEMR's software is free under GPL-3.0, so its recurring cost sits in infrastructure, administration, support and upgrade work. Medplum has two paths. Its hosted plans, listed on its pricing page, are Free, Production at $2,000 per month, Premium at $6,000 per month and custom-priced Enterprise. Self-hosting is either a free Community option or custom-priced Enterprise Self-Hosted. Self-hosting removes the subscription but adds engineering time for upgrades, PostgreSQL and Redis operations, backups and monitoring. The main cost drivers are user count, data volume, uptime requirements, the number of integrations and how much custom clinical application code you write. Ask for a quote that separates one-time build costs from recurring hosting, support and upgrade work.

How long does implementation take and what sets the timeline?

The timeline depends on scope, and no duration should be accepted unless it is written into the agreement. For OpenEMR, the main drivers are workflow configuration, scheduling and billing setup, data migration from an existing system, lab and imaging interfaces, and staff training. For Medplum, the timeline depends mostly on the custom application you build, including its data model, SMART app flows, identity integration, Bots and the front end built with its SDK and React components. Upgrade discipline also affects planning. Self-hosted Medplum must move through each minor version in sequence, and post-deploy data migrations can run for hours or days on large datasets. Ask for milestones, the assumptions behind each one and the dependencies on your identity provider, network approvals and clinical sign-off.

Can our team implement it without outside help?

It can, if your team already has the right skills, and the skills differ by platform. OpenEMR is a PHP application on a MySQL- or MariaDB-compatible database, and recent releases require PHP 8.3 or later and offer Docker deployment options, so a team with PHP, database and Linux operations skills can run it. Medplum requires TypeScript and React skills to build applications, plus Node.js, PostgreSQL and Redis operations if you self-host, and working knowledge of FHIR and SMART on FHIR. A common approach is to bring in outside help for the first deployment, hardening and integrations, then move routine operations in-house. DeployOpen plans, implements, customizes, integrates, hardens, documents and supports self-hosted platforms in your own infrastructure, under fixed-scope agreements with ongoing retainers available. Compare your skills against the written scope before deciding.

What does the work need from clinical and IT staff?

Clinical staff define how the software should behave, and IT staff define how it is hosted, secured and connected. For OpenEMR, clinicians shape scheduling templates, encounter forms, billing rules and patient portal workflows, while an administrator configures access controls, password policy and the hardening steps in the project's securing guide, such as HTTPS only and removing setup scripts after installation. For Medplum, which supplies building blocks, clinical staff must review the data model and workflow logic of any application you build. IT staff own identity integration, network controls, backups, logging, patch intake and the cloud accounts. Assign a named clinical owner and a named IT owner for each platform, and set aside time for testing and training. Ask who will own workflow decisions after go-live.

Does OpenEMR's ONC certification cover our setup?

It covers only the tested version and scope, so it may not cover your setup in full. OpenEMR 7.0.0 was ONC certified on 7/19/22 as a 2015 Edition Base EHR after testing by SLI concluded on 6/30/22. The project's website told users to upgrade to version 8 by March 1, 2026 to keep their system's active certification. A heavily customized build, a different database or hosting stack, or an added module may fall outside what was tested, so confirm the current certified version and scope on the project's certification page and with your compliance lead. Medplum's compliance documentation also lists ONC certification, but that applies to the platform's documented scope, not to an application you build on it. Either way, certification is not HIPAA compliance, because no HIPAA certification exists and the Security Rule still applies to your deployment.

Who signs the business associate agreement for each setup?

Your organization signs a business associate agreement with each vendor or service provider that creates, receives, maintains or transmits ePHI on your behalf. Under 45 CFR 164.314(a)(2)(i), the contract must require the business associate to comply with the Security Rule, flow the same terms down to subcontractors that handle ePHI, and report security incidents, including breaches of unsecured PHI. For self-hosted OpenEMR in your own cloud account, the agreements usually involve your cloud provider and any hosting or support vendor you use, and the project itself does not operate your deployment, so confirm whether any agreement with it is needed. For hosted Medplum, ask Medplum for its BAA terms and what they cover. Ask DeployOpen whether its role under a given scope creates a business associate relationship. Your counsel should map which parties touch ePHI in each design.

How does switching later affect data and workflows?

Data moves more easily than workflows, custom code and staff habits. OpenEMR implements FHIR Bulk Data v1.0 export at system, patient and group level in NDJSON, which supports bulk extraction for migrations, and its FHIR API implements FHIR R4 (4.0.1) with US Core 8.0 and SMART on FHIR v2.2.0. Medplum offers a FHIR R4 API, but its custom applications, Bots and SMART integrations would need to be rebuilt or re-tested on any other platform. Whichever path you choose, plan an export path, a documented data model and a re-import test from the start. Ask each vendor or implementer which export formats are supported, how much reconciliation the target needs and who owns the mapping work. Plan for parallel running and retraining, because changing workflows often takes more effort than moving data.

How DeployOpen helps you choose, implement or migrate

DeployOpen approaches OpenEMR vs Medplum as a scoping question first: whether your team needs a ready-made practice EHR or a FHIR developer platform to build a custom clinical application. We plan, implement, customize, integrate, harden, back up, document and support the path you choose inside your own cloud accounts, data centers or air-gapped networks.

How we scope

  • Written scope fixes which workflows, FHIR resources, SMART apps and identity sources are in or out before work starts
  • We record hosting location, BAA position and the shared-responsibility split with the vendor so ownership is explicit
  • Engagements are fixed-scope, with deliverables and timelines agreed in writing before any build begins
  • Quotes follow from the written scope, so you can compare the EHR path and the developer platform path on the same basis

How we build

  • We configure or customize the chosen platform, covering OpenEMR's FHIR R4, US Core and SMART on FHIR settings or Medplum's Auth, repository and Bots
  • Identity integration is set up against your existing identity provider, including multi-factor authentication and client credentials for server-to-server access
  • Security testing of applications and APIs is planned alongside the build, so findings are fixed before go-live
  • Hardening follows the vendor's own guidance, such as HTTPS-only access and removing setup scripts after installation

How we hand over

  • Handover documentation covers deployment, upgrade steps, configuration keys and the operating runbook for your team
  • Backup and restore procedures are documented and exercised so your staff can run them without us
  • Compliance readiness material is prepared as evidence for your independent auditors, which DeployOpen does not issue
  • Knowledge transfer sessions are scoped in writing so your engineers know how to extend the platform

How we support

  • Ongoing support, upgrades and continuous testing are available as retainers after handover
  • Upgrade planning tracks the vendor's release cadence, including any required sequence of minor versions
  • Periodic security testing can be scheduled against the platform and any custom applications built on it
  • Ask us to confirm in writing which vendor versions, support windows and hosting options apply to your environment

Sources and further reading

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.