"RaftLabs elevated my ideas and brought them to life when everything seemed impossible."
Grady Lakshmono
CoFounder, Moka (acquired by Gojek) & Gula (acquired by Runchise)
EHR Integration Services
Most digital health companies underestimate EHR integration. The FHIR spec exists, but every major EHR vendor implements it differently. Epic's sandbox environment has its own certification process. Cerner's APIs have their own quirks. HL7 v2 messages look standard until you hit the proprietary segments that vary by hospital. At RaftLabs, we've built FHIR R4 integrations against Epic, Cerner, Allscripts, Meditech, and Athena. We know the certification workflows, the common data normalization traps, and how to architect a HIPAA-compliant data layer that your legal and compliance teams will accept. We handle the EHR side so your team can focus on the product.
FHIR R4 API integration with Epic, Cerner, Allscripts, Meditech, and Athena
HL7 v2 message parsing and transformation across ADT, ORU, ORM, and MDM message types
Bi-directional data sync covering patient demographics, appointments, lab results, medications, and diagnoses
HIPAA-compliant architecture with PHI handling, BAA support, and audit trails built in
Bring the problem, the current workflow, or the existing code. We reply with a practical next step within one business day.
Trusted by
The brief
Good software decisions begin with the constraint, not a list of features or a preferred technology.
Spending months on HL7/FHIR integration that should take weeks because your engineering team has no prior EHR experience?
Blocked from closing healthcare enterprise deals because you can't demonstrate a live Epic or Cerner integration?
Plain answer
RaftLabs builds FHIR R4 and HL7 v2 EHR integrations for digital health companies across the US, UK, Europe, Canada, GCC, South Africa, and Southeast Asia. We connect to Epic, Cerner, Athena, and Meditech with HIPAA-compliant architecture. Most integrations use both: HL7 v2 for live feeds and FHIR for on-demand data.
What to remember
A digital health team promised a hospital customer a live Epic integration by the next quarter. Four months in, they are still fighting Epic's sandbox. Cerner returns fields the spec never mentioned. An HL7 v2 feed keeps dropping messages nobody can trace.
The deal that was supposed to close is now waiting on an integration everyone assumed was routine. The FHIR spec was never the hard part. Every vendor implements it differently, and experience is the only thing that closes the gap.
The spec is public. The experience is not.
The FHIR spec is public. Epic publishes developer documentation. So why do digital health companies stall for months on integrations that look straightforward?
Three reasons. First, every EHR vendor implements FHIR differently. The spec is a framework, not a contract. Epic's FHIR implementation supports certain resource types and ignores others. Cerner's API quirks are different from Epic's. Athena has its own conventions. Your team needs EHR-specific experience, not just FHIR spec knowledge. Even technically complete integrations frequently hit data quality and routing problems that only surface against production systems.
Warning
Second, production access requires certification. Epic's App Orchard review, Cerner's code program, and similar vendor processes take weeks of their own. You can complete the technical integration while waiting for certification approval, but you cannot ship to customers until it clears.
Third, the data is messy. Patient demographics vary in completeness. Lab result units are non-standard. Medication names and codes differ between systems. Building a normalization layer that makes this data usable in your application adds time that most roadmaps do not account for.
RaftLabs has shipped HIPAA-compliant products since 2015, with FHIR R4 integrations built against Epic, Cerner, Allscripts, Meditech, and Athena. Healthcare engagements are built on HIPAA-compliant architecture, clients rate us 4.9/5 on Clutch, and the team that scopes your integration is the team that ships it.
Everything on the left should already be true for your product. Even one thing on the right, and a full EHR integration build isn't the right first step yet.
You're a digital health, telehealth, or remote patient monitoring platform that needs to connect to Epic, Cerner, Athena, or Meditech.
You're blocked from closing healthcare enterprise deals because you can't demonstrate a live Epic or Cerner integration.
Your engineering team has no prior EHR experience, and the roadmap can't absorb a four-to-six-month detour.
There's no EHR or clinical system in scope, just a standard application build.
You already have in-house FHIR and HL7 v2 expertise and only need extra hands.
The data carries no PHI and no HIPAA obligations to design around.
It is whether software is the right answer at all. We use four possible recommendations before discussing a development scope.
Choose a maintained product when it handles the core clinical data exchange workflow and the remaining gaps can be solved with configuration, a connector, or a small process change. Paying for software you do not have to maintain is often the better trade.
Keep the existing product when users still get value from it and the code can be understood safely. Start with evidence: where the code lives, how the data is organized, what is tested, which outside services it depends on, who can access what, and how updates go live.
Own the system when clinical data exchange shapes margin, customer experience, speed, or a product customers pay for. Start with one complete path and the system connections that path cannot work without.
Do not turn a changing policy into permanent software. Stabilise the rules, name the workflow owner, and measure the cost of the current process before paying for a product.
Not sure which path is yours? Bring it to a 30-minute call. Leave with the answer in writing.
Scope
Connection to Epic, Cerner PowerChart, Allscripts, Meditech, and Athena via their FHIR R4 endpoints, covering Patient, Encounter, Observation, Condition, MedicationRequest, and Appointment resources. OAuth 2.0 and SMART on FHIR authentication support patient- and clinician-facing access, and a normalization layer maps EHR-specific extensions and coding systems (SNOMED, LOINC, RxNorm, ICD-10) to a consistent internal representation.
Parsing and transformation of HL7 v2 messages from hospital interface engines and legacy EHR systems, handling ADT, ORU, ORM, MDM, and SIU message types over MLLP and TCP. An MLLP listener receives messages with acknowledgment handling and a reliability queue, transforming pipe-delimited HL7 into structured JSON or FHIR-equivalent resources, with error handling for malformed messages and non-standard vendor extensions.
SMART on FHIR applications that launch from within the EHR clinician workflow, receiving the current patient's FHIR ID for immediate querying without a separate search. Launch from Epic Hyperspace, Cerner PowerChart, or any SMART-compatible EHR, with App Orchard submission support: we prepare the technical documentation, complete Epic's review questionnaire, and handle clarification rounds.
Two-way data flow between your platform and the EHR: reading patient demographics, appointments, lab results, medications, and diagnoses, and writing structured data back into the EHR record. Write-back covers clinical notes as DocumentReference resources, care plan updates, appointment status changes, and observations, scoped against what each EHR vendor's API permits, with gaps flagged before we build.
PHI handling architecture designed for HIPAA compliance: encryption in transit (TLS 1.2 minimum) and at rest (AES-256), role-based access with minimum-necessary scope, full audit logging of every PHI access, and secure credential management. Data minimization stores only the fields your application needs, and architecture documentation is produced for your compliance team's HIPAA risk assessment and enterprise security reviews.
Master Patient Index (MPI) logic that resolves patient identity across multiple EHR systems and data sources: deterministic matching on exact field combinations, probabilistic matching with confidence scoring for partial matches, and a review queue for near-match exceptions. Deduplication handles name variations, address changes, and multiple MRN assignments, presenting one unified patient record with configurable thresholds.
Three layers of complexity compound on each other.
Proprietary implementations on top of open standards. FHIR R4 is a standard. But Epic's FHIR endpoints support a specific subset of resources, return vendor-specific extensions, and require Epic-specific authentication flows. What works in Epic's sandbox does not always work in Cerner's. What works in Cerner does not always work in Allscripts. Your team needs EHR-specific experience, not just FHIR knowledge.
Certification adds timeline independent of development. Epic's App Orchard review runs from submission to approval on its own clock. You can complete your technical integration in parallel, but you cannot connect to production Epic systems at a customer site until the review clears. That timeline needs to be on your product roadmap before you promise a launch date to a hospital customer.
Warning
Data quality is inconsistent. Patient records in production EHR systems contain incomplete fields, non-standard coding, duplicate entries, and historical data entered in free-text fields rather than structured codes. Building a normalization layer that makes this data reliably usable in your application, and deciding what to do when required fields are missing, adds meaningful development time that spec-reading does not reveal.
Tell us your target EHR, the data types you need to sync, and whether you need read-only or bi-directional. We'll scope the integration and give you a fixed price and timeline.
How it works
Every EHR integration follows the same four phases. Scope is locked and price is fixed before development starts.
We map the target EHR systems, the data types you need to access or write, your authentication patterns, and your HIPAA requirements. You leave discovery with a written scope document and a fixed-price quote. No development starts without your sign-off.
We build against sandbox credentials first. Epic, Cerner, and Athena all provide sandbox environments. If Epic is in scope, we prepare the App Orchard submission documentation in parallel so the review clock starts while we build.
We connect to production EHR endpoints at your first customer site, build the data normalization layer, and run live data validation. QA runs in parallel with every sprint. Bi-weekly demos so you see working software throughout.
Production deployment with monitoring activated on launch day. Handoff documentation covers the integration patterns, certification requirements, and normalization decisions so your team can extend the codebase.
We start with discovery. Before any code is written, we need to understand
That conversation produces a scope document with the exact API endpoints, data flows, and architecture decisions we will make.
From there, we build against the EHR sandbox environment first. Epic, Cerner, and Athena all provide sandbox credentials for development. We build and test against sandbox data before you have access to any patient information. That phase also covers the App Orchard submission documentation if Epic is in scope.
Production integration and normalization come next. We connect to production EHR endpoints at your first customer site, build the data normalization layer for that site's specific EHR configuration, and run live data validation against real (but de-identified in development) patient records.
We deliver working integrations, not architectural documents. Your engineering team inherits a codebase they can extend, test, and operate. We document
If you need to connect to Epic, Cerner, or any major EHR system, contact us and tell us which system and what data you need. We will scope it and give you a fixed price before you commit to anything.
What it costs
A first integration covers one EHR connection with FHIR R4 or HL7 v2 and HIPAA-compliant architecture, then grows from there.
Starting investment
Starts at $10K
The first phase is scoped around one EHR endpoint and its data mapping requirements. After a 30-minute call, you get a written build, buy, repair, or wait recommendation plus first-phase direction. Free, whether or not you build with us.
| HL7 v2 | FHIR R4 | |
|---|---|---|
| Standard | Older messaging standard | Modern REST API standard, required under US ONC interoperability rules |
| Best for | Real-time hospital event feeds: admissions, discharges, and lab results | Querying records or writing data back into the EHR |
| Timing | Real-time events as they happen | On-demand queries and writes |
Proof
Three-year average engagement. Founders and operators describing the work in their own words. No marketing varnish.
"RaftLabs elevated my ideas and brought them to life when everything seemed impossible."
Grady Lakshmono
CoFounder, Moka (acquired by Gojek) & Gula (acquired by Runchise)
Work with us
Bring the rough workflow, half-built product, or messy brief. We will map the smallest useful first move, then send scope, timeline, and price in plain English.
Straight answers to what buyers ask before they scope. Still stuck? .
HL7 v2 is the older messaging standard, still dominant for real-time hospital event feeds like admissions, discharges, and lab results. FHIR R4 is the modern REST API standard, required under US ONC interoperability rules, and the right choice for querying records or writing data back into the EHR. Most integrations use both: HL7 v2 for live feeds, FHIR for on-demand structured data. We scope which protocols your use case needs before building.
Epic's FHIR API implementation is more complete than most EHR vendors, but their certification and sandbox process adds time. To get production API credentials for an Epic customer, your application has to pass Epic's App Orchard review process. That involves submitting the app for review, demonstrating HIPAA-compliant data handling, and meeting Epic's technical requirements. The timeline from sandbox access to production approval typically runs 8 to 16 weeks, independent of the technical integration work itself. We have experience navigating the Epic App Orchard process. We know what documentation Epic requires, what the common rejection reasons are, and how to structure the integration to pass review without multiple rounds of changes. If your target customers are on Epic, and most large US hospital systems are, the certification timeline needs to be factored into your product roadmap from the start.
Each EHR assigns its own internal patient ID, and there is no shared universal identifier. Master Patient Index matching combines exact matches on name, date of birth, gender, and address with probabilistic scoring on partial matches. The hard part is the edge cases: name changes, address updates, transcription errors, and near-matches that could be one person or two. We build the deduplication logic between your platform and the EHR systems, so your application works with one clean patient record.
HIPAA is your organization's legal obligation as the business handling patient information, and it applies to a system like this one because the integration moves protected health information between your platform and the EHR. Compliance is shared. The build carries the technical safeguards: how patient information is handled, encryption at rest and in transit, who can see and change what, and a record of every access. Your organization still owns its policies, staff training, and the evidence its compliance team produces. No integration makes a business compliant on its own. On projects handling protected health information, RaftLabs signs a Business Associate Agreement before we access any patient data. If your legal team needs documentation of how patient information moves through the integration layer, we produce it.
There is no central Epic endpoint. Epic publishes FHIR APIs and supports SMART on FHIR, but ships vendor-specific extensions, so develop against Epic's docs, not standard FHIR. Production depends on each health system switching you on. The single most important thing to understand: you are not connecting to Epic, you are connecting to each health system that runs Epic, one approval at a time.
Ask how many EHR platforms the firm has actually shipped against, who owns the interface after go-live, and whether they work in your existing stack or arrive with a platform to sell. Ask which FHIR version and USCDI version the integration supports. Build FHIR-first against certified R4 APIs; keep the integration layer in code you own.
The biggest mistake is underestimating what comes after API access: data orchestration and compliance testing against real clinical workflows take the most effort. Mappings and edge cases still need humans. The approval process at Epic and at individual customer sites often takes longer than the development.
Ask the endpoint question: is there one place to connect, or do we need approval at every health system? Ask the version question: which FHIR and USCDI versions are supported, and are they pinned or assumed? Ask the ownership question: who holds the production alerts after go-live? Ask the workflow question: has the data been tested against real clinical workflows, or just a sandbox?
Most of our EHR integration clients are digital health startups, telehealth platforms, remote patient monitoring companies, and healthcare SaaS vendors that need to connect their product to a hospital or clinic's EHR system. We work with companies at Series A through Series C as well as established healthcare software vendors adding new integrations. We have shipped HIPAA-compliant integrations for US-based clients targeting Epic-heavy hospital networks and for UK-based clients connecting to NHS-adjacent systems. If your product is in healthcare and you need data from Epic, Cerner, Athena, or a legacy HL7 v2 interface, we have relevant experience.
Every project starts at $10K. A first integration covers one EHR connection with FHIR R4 or HL7 v2 and the architecture for handling patient information, then grows from there. A complete quote names the EHR systems in scope, the data types you need to read or write, who can see and change what in the integration, the interface engine or other system connections, moving your data over including how codes and fields line up between systems, and anything left out. Any change is priced and approved in writing before the work is done. The calendar is only partly coding: sandbox access, the EHR vendor review, and approval at each health system run on their own clocks. Epic review alone typically runs 8 to 16 weeks, independent of development, and each new health system is a separate approval.
You do, from day one. The integration code, the accounts it runs on, your patient and product data, and the project notes are in your name from the start, not handed over when the build ends. The notes cover the integration patterns, each EHR vendor's requirements, and the mapping decisions, so another capable team can pick the integration up and run it.
You already hold the integration code, the accounts in your name, your data, and current project notes, so there is nothing to extract from us and no unlock step. The integration keeps running while you decide what happens next. We do not offer source-code escrow, because nothing is held back for escrow to release.
Penetration testing is taken care of before launch. No production patient data is used in development, always. Backups are tested, always. When someone leaves a team, there are offboarding steps that remove their access. The third-party services the integration depends on, including the EHR vendor, any interface engine, and your hosting provider, are named in the scope document before signing, including any that process patient data. We claim practices we can show you, not certifications.
Support after launch is arranged as another fixed phase or an ongoing engagement, or your own team can run the integration from the project notes. Standing costs exist whoever runs it: hosting, EHR vendor and API access charges, interface engine charges where one is in scope, and updates and security patches as EHR vendors change their systems. Those costs are named in scoping before you sign, not discovered after launch.
We work on five principles. Switch to Async: progress and questions are shared in writing you can read between customer calls, not saved for a meeting. Be Prepared: calls are booked to settle a decision, with the question shared first. Write: data mappings, vendor requirements, and decisions are recorded where both sides can find them. Ask and tell: if a vendor review or a health system approval is going to slip, we say so plainly and early. Own: each part of the integration has a named owner on our side.
Yes. We sign your NDA before anything sensitive is shared. The target systems, data types, and customer details you share for scoping stay confidential.
No. The team that scopes your integration is the team that builds it. Our teams are in India and Ireland, and the people on your calls are the people on your project. The EHR vendor, an interface engine, and your hosting provider are services the integration connects to, not a handoff of the work.