Epic EHR Integration: Technical Guide

•13 min read • Abdus Muwwakkil – Chief Executive Officer

Epic EHR Integration: Technical Guide

Integration Overview

Why Epic Integration Matters for Modern Healthcare

Epic Systems powers electronic health records for over 250 million patients across more than 2,000 healthcare organizations worldwide. For any clinical AI solution targeting enterprise health systems, seamless Epic integration is not optional—it’s essential. OrbDoc’s native Epic integration eliminates the documentation friction that costs clinicians 6+ hours daily, delivering AI-generated clinical notes directly into existing Epic workflows without disrupting established processes.

The strategic importance of Epic integration extends beyond technical interoperability. Health systems have invested millions in Epic implementations, and any new technology must enhance—not complicate—these existing workflows. OrbDoc achieves this through standards-based HL7 FHIR APIs, ensuring data flows bidirectionally between OrbDoc’s AI engine and Epic’s comprehensive patient records. This integration enables clinicians to access patient context, generate documentation, and commit finalized notes without leaving their familiar Epic environment.

Bidirectional Data Flow Architecture

OrbDoc’s Epic integration implements true bidirectional data exchange, distinguishing it from simpler one-way integrations. When a clinician initiates a patient encounter, OrbDoc retrieves relevant patient context from Epic—including demographics, active medications, problem lists, allergies, and recent visit summaries. This contextual data informs AI-generated documentation, ensuring clinical notes reflect the patient’s complete medical history rather than treating each encounter in isolation.

After the clinician reviews and approves AI-generated notes, OrbDoc commits the documentation back to Epic’s clinical repository. This return flow supports multiple note types including SOAP notes, progress notes, consultation reports, and procedure documentation. The integration handles Epic’s specific note formatting requirements, structured data fields, and attestation workflows, ensuring compliance with organizational documentation standards and regulatory requirements.

Real-Time vs Batch Processing

OrbDoc’s architecture supports both real-time and batch processing modes, providing flexibility for different organizational requirements and use cases. Real-time integration leverages Epic’s synchronous FHIR APIs to retrieve patient data on-demand and commit notes immediately upon clinician approval. This mode delivers the lowest-latency experience, enabling clinicians to complete documentation within seconds of encounter completion.

Batch processing mode accommodates high-volume scenarios and organizations with network constraints. OrbDoc queues note submissions and processes them asynchronously, with configurable retry logic and error handling. This approach reduces peak load on Epic servers and provides graceful degradation if network connectivity becomes intermittent. Organizations can configure batch windows during off-peak hours to minimize impact on Epic system performance.

Supported Epic Versions and Modules

OrbDoc maintains compatibility with Epic versions 2018 and later, covering the vast majority of active Epic installations. Our integration team continuously tests against Epic’s quarterly release cycle, ensuring compatibility with new features and API enhancements. We support Epic’s core modules including EpicCare Ambulatory, EpicCare Inpatient (Hyperspace), Emergency Department, and OpTime surgical documentation.

The integration leverages Epic’s App Orchard framework, following Epic’s best practices for third-party application integration. This approach ensures our integration meets Epic’s security, performance, and user experience standards. For organizations using Epic’s MyChart patient portal, OrbDoc can optionally integrate after-visit summaries and patient instructions, extending documentation efficiency to patient-facing communications.

Technical Architecture

HL7 FHIR R4 API Implementation

OrbDoc’s Epic integration is built entirely on HL7 FHIR (Fast Healthcare Interoperability Resources) Release 4, the current international standard for healthcare data exchange. FHIR’s RESTful API design, resource-based data models, and JSON/XML support provide a modern, developer-friendly approach compared to legacy HL7 v2.x messaging or proprietary Epic APIs.

Our integration utilizes the following core FHIR resources:

Patient Resource (/Patient/{id}) - Retrieves demographics, identifiers, contact information, and patient preferences. We support Epic’s extensions for patient photographs, preferred language, and emergency contacts.

Encounter Resource (/Encounter/{id}) - Manages encounter context including visit type, location, attending providers, and encounter status. OrbDoc creates encounters when initiating documentation workflows and updates encounter status upon note completion.

DocumentReference Resource (/DocumentReference) - Commits finalized clinical notes to Epic’s document repository. We support CCDA-formatted notes, plain text, and Epic’s proprietary SmartText templates. DocumentReference enables note versioning, addenda, and amendments according to organizational policies.

Observation Resource (/Observation?patient={id}) - Retrieves vital signs, lab results, and clinical observations relevant to current documentation. OrbDoc intelligently filters observations by date and relevance to reduce data volume while maintaining clinical context.

MedicationRequest Resource (/MedicationRequest?patient={id}) - Accesses active and historical medication orders. The AI engine considers current medications when generating assessment and plan sections, identifying potential drug interactions and contraindications.

Condition Resource (/Condition?patient={id}) - Retrieves problem lists and active diagnoses. This data populates the assessment section and ensures diagnostic continuity across encounters.

AllergyIntolerance Resource (/AllergyIntolerance?patient={id}) - Critical for patient safety, allergy data influences medication recommendations and procedure planning in AI-generated documentation.

Authentication and Authorization Architecture

OrbDoc implements OAuth 2.0 with SMART on FHIR (Substitutable Medical Applications, Reusable Technologies) for secure authentication and authorization. This industry-standard approach ensures OrbDoc operates under the authenticated user’s credentials and permissions, maintaining Epic’s existing role-based access controls.

OAuth 2.0 Authorization Flow:

  1. Initial Authorization: Clinician launches OrbDoc from within Epic (via App Orchard) or authenticates via OrbDoc’s standalone interface. OrbDoc redirects to Epic’s authorization server with client credentials and requested scopes.

  2. User Consent: Epic presents consent screen listing requested data access permissions. For integrated App Orchard deployments, organizations can configure pre-authorized scopes to streamline the user experience.

  3. Token Exchange: Upon user consent, Epic returns an authorization code. OrbDoc exchanges this code for an access token and refresh token via Epic’s token endpoint.

  4. Token Management: Access tokens typically expire after 1 hour. OrbDoc automatically refreshes tokens using the refresh token, ensuring uninterrupted access without repeated authentication. Tokens are encrypted at rest and never logged or exposed in error messages.

SMART on FHIR Scopes:

OrbDoc requests the following FHIR scopes to minimize data access while supporting comprehensive documentation workflows:

  • patient/Patient.read - Patient demographics
  • patient/Encounter.read patient/Encounter.write - Encounter management
  • patient/DocumentReference.write - Note submission
  • patient/Observation.read - Vital signs and results
  • patient/MedicationRequest.read - Medication lists
  • patient/Condition.read - Problem lists
  • patient/AllergyIntolerance.read - Allergy data

Data Models and Mappings

OrbDoc maintains sophisticated data mapping layers to translate between FHIR’s standardized resources and our internal AI models. Our mapping engine handles Epic’s extensive use of FHIR extensions, custom value sets, and organization-specific terminology.

Terminology Standards:

  • SNOMED CT: Primary clinical terminology for conditions, procedures, and clinical findings
  • LOINC: Lab and clinical observation identifiers
  • RxNorm: Medication coding
  • CPT/ICD-10: Procedure and diagnosis codes for billing integration

OrbDoc’s terminology service maps Epic’s coded data to human-readable text for AI processing and validates AI-generated codes against Epic’s configured value sets. This ensures documentation complies with organizational coding policies and billing requirements.

Epic SmartData Integration:

Many Epic organizations leverage SmartData elements—structured data fields embedded within clinical notes. OrbDoc supports SmartData population, enabling AI-generated content to populate discrete data elements for quality reporting, clinical decision support, and population health analytics. Our mapping engine identifies SmartData placeholders in note templates and populates them with appropriate coded values from AI-generated content.

Network Requirements and Architecture

Network Topology:

OrbDoc’s Epic integration operates via secure HTTPS connections to Epic’s FHIR endpoints. For on-premises Epic installations, organizations must configure firewall rules to allow outbound connections from OrbDoc’s infrastructure to Epic’s FHIR proxy servers. OrbDoc provides static IP addresses for allowlisting when required by organizational security policies.

Connectivity Options:

  1. Direct Internet Connection: OrbDoc’s cloud infrastructure connects directly to Epic’s internet-facing FHIR endpoints (typical for cloud-hosted Epic implementations)

  2. VPN Tunnel: For organizations requiring dedicated connectivity, OrbDoc supports site-to-site VPN tunnels with Epic’s data center

  3. On-Premises Deployment: Enterprise customers can deploy OrbDoc within their network perimeter, eliminating external connections (requires Enterprise license)

Performance Specifications:

  • API Response Time: <500ms p95 latency for data retrieval
  • Note Submission: <2 seconds for typical progress note
  • Concurrent Connections: Supports 1,000+ simultaneous user sessions
  • Bandwidth: <100KB per encounter data retrieval
  • Failover: Automatic retry with exponential backoff for transient failures

Architecture Diagram (Conceptual Description):

The integration architecture consists of five layers:

  1. User Interface Layer: Epic Hyperspace UI or OrbDoc native applications
  2. API Gateway Layer: OrbDoc’s FHIR-compliant API gateway with authentication, rate limiting, and request routing
  3. Business Logic Layer: Note generation AI, data mapping, and workflow orchestration
  4. Integration Layer: FHIR client, OAuth token management, and Epic-specific protocol handlers
  5. Epic FHIR Server Layer: Epic’s FHIR proxy, authentication server, and clinical data repository

Data flows bidirectionally through these layers with comprehensive audit logging at each hop. All connections use TLS 1.3 encryption with certificate pinning to prevent man-in-the-middle attacks.

Data Flow

Encounter Creation Workflow

The typical documentation workflow begins when a clinician initiates a patient encounter. In Epic-integrated deployments, this can occur three ways:

Epic-Launched Workflow:

  1. Clinician opens patient chart in Epic Hyperspace
  2. Clicks OrbDoc integration button in Epic’s Activities menu
  3. Epic passes patient and encounter context to OrbDoc via SMART launch parameters
  4. OrbDoc automatically loads patient data and presents recording interface
  5. No separate authentication required—clinician operates under existing Epic session

Standalone Launch with Context:

  1. Clinician opens OrbDoc mobile app or web interface
  2. Authenticates via Epic OAuth (if not already authenticated)
  3. Selects patient from OrbDoc’s interface
  4. OrbDoc queries Epic’s FHIR server for matching patient and creates encounter context
  5. Workflow proceeds with full patient data access

Batch Processing Mode:

  1. Clinician completes encounter documentation in OrbDoc offline
  2. Upon network reconnection, OrbDoc queries Epic for patient identifier
  3. Creates encounter record in Epic with appropriate timestamps
  4. Submits completed note as historical documentation

Note Generation and Submission

After capturing encounter audio or manual input, OrbDoc’s AI engine generates structured clinical documentation. The note generation process incorporates retrieved patient context to ensure clinical accuracy and continuity:

Generation Process:

  1. Context Assembly: OrbDoc compiles patient demographics, active medications, problem lists, allergies, and recent encounters into a context payload

  2. AI Processing: Our clinical AI model processes encounter audio/text alongside patient context, generating structured note sections (Subjective, Objective, Assessment, Plan)

  3. Clinical Logic: AI applies clinical reasoning—checking medication interactions, suggesting relevant ICD-10 codes based on problem lists, and identifying potential documentation gaps

  4. Template Application: OrbDoc applies organization-specific note templates, including Epic SmartText macros and SmartData fields configured by the health system

  5. Clinician Review: Generated note presents to clinician for review, editing, and approval within OrbDoc’s interface or Epic’s embedded view

Submission Workflow:

Upon clinician approval, OrbDoc commits the note to Epic via the DocumentReference FHIR resource:

POST /DocumentReference
Content-Type: application/fhir+json

{
  "resourceType": "DocumentReference",
  "status": "current",
  "docStatus": "final",
  "type": {
    "coding": [{
      "system": "http://loinc.org",
      "code": "11506-3",
      "display": "Progress note"
    }]
  },
  "subject": {
    "reference": "Patient/eXq8KdwhJRxH5bLIgvEQWUw3"
  },
  "context": {
    "encounter": [{
      "reference": "Encounter/eZlr5hJ2YV8QM3nKpAoBgDx7"
    }]
  },
  "content": [{
    "attachment": {
      "contentType": "text/plain",
      "data": "<base64-encoded note content>"
    }
  }]
}

Epic returns a DocumentReference ID confirming successful note storage. OrbDoc logs this ID for audit purposes and displays confirmation to the clinician. The note immediately becomes available in Epic’s chart review, appears in the encounter’s documentation list, and triggers any configured clinical decision support rules.

Patient Data Retrieval

OrbDoc employs intelligent data retrieval strategies to balance comprehensive context with API performance. Rather than retrieving all patient data, we implement selective retrieval based on encounter type and clinical relevance:

Initial Encounter Context (retrieved immediately upon encounter initiation):

  • Patient demographics and identifiers
  • Active medication list (last 90 days)
  • Current problem list (active conditions only)
  • Known allergies and intolerances
  • Most recent vital signs (last 7 days)
  • Upcoming appointments and recent encounters

On-Demand Retrieval (fetched when AI identifies relevant context needs):

  • Specific lab results mentioned in clinician narrative
  • Historical encounters of specific types (e.g., previous surgical notes)
  • Specialty-specific clinical data (e.g., oncology flow sheets for oncology encounters)
  • Imaging reports and procedure notes

This tiered approach minimizes latency while ensuring AI-generated notes incorporate clinically relevant context. OrbDoc’s caching layer stores retrieved data for the encounter duration, reducing redundant API calls if clinicians generate multiple notes during a single patient session.

Medication Lists and Problem Lists

Medication List Integration:

OrbDoc retrieves medications via the MedicationRequest FHIR resource, filtering for active and recently discontinued medications. We parse Epic’s medication data including:

  • Generic and brand names
  • Dosage, route, and frequency
  • Prescribing provider and start date
  • Prescription status (active, suspended, completed)
  • Administration notes and patient instructions

The AI engine references medications when generating assessment and plan sections. For example, if a patient presents with diabetes and the medication list shows metformin, the AI automatically includes medication compliance assessment in generated notes. When clinicians dictate new medication orders, OrbDoc can optionally generate prescription orders for Epic’s CPOE system (requires additional Epic configuration).

Problem List Synchronization:

Active diagnoses from Epic’s Condition resource populate OrbDoc’s problem list view, ensuring diagnostic continuity. When AI generates assessment sections, it references existing problem list items and suggests updates when clinical scenarios indicate disease progression or resolution. For example:

  • Patient with “Type 2 Diabetes Mellitus” on problem list presents for follow-up
  • AI-generated assessment includes diabetes status and references most recent HbA1c
  • If HbA1c indicates poor control, AI suggests problem list update to “Type 2 Diabetes Mellitus, inadequately controlled”

Clinicians can approve problem list changes within OrbDoc, which submits Condition updates to Epic via FHIR. This bidirectional synchronization maintains diagnostic accuracy and supports quality reporting initiatives tied to problem list documentation.

Orders and Results Integration

Lab Results Integration:

For encounters requiring lab review, OrbDoc retrieves relevant results via the Observation resource. Our filtering logic identifies results by:

  • Date relevance (typically last 30 days for acute care, 90 days for chronic disease management)
  • Clinical context (diabetes encounters prioritize HbA1c and glucose; cardiology prioritizes lipids and troponin)
  • Abnormal flags (out-of-range results highlighted for clinician review)

AI-generated notes incorporate lab interpretation when clinically appropriate. For example, elevated creatinine in a diabetic patient triggers nephropathy assessment language. Critical results automatically flag for clinician attention during note review.

Orders Integration (optional, requires additional Epic configuration):

Advanced Epic integrations enable OrbDoc to generate order requests based on AI-identified care gaps or clinician dictation:

  • Lab orders: “Order comprehensive metabolic panel” → generates CMP order draft
  • Imaging orders: “Get chest x-ray” → populates radiology order with clinical indication
  • Referral orders: “Refer to cardiology” → creates referral order with synthesized clinical summary

Generated orders remain in draft status pending clinician review and electronic signature within Epic’s ordering workflow. This integration reduces clicks required for common order entry while maintaining Epic’s clinical decision support and duplicate order checking.

Security & Compliance

Zero-Trust Security Architecture

OrbDoc’s Epic integration implements a zero-trust security model, assuming no implicit trust for any network connection, user session, or data access. Every API request undergoes authentication, authorization, and validation before accessing patient data:

Identity Verification:

  • Multi-factor authentication for standalone access
  • SMART on FHIR OAuth 2.0 for Epic-integrated sessions
  • Biometric authentication options for mobile applications
  • Session tokens expire after inactivity (configurable: 15-60 minutes)

Least-Privilege Access:

  • API scopes limited to minimum data required for documentation workflows
  • User roles enforce access controls (e.g., nurses cannot access all provider functions)
  • Data filtering enforces Epic’s existing patient-provider relationships and consent directives
  • Administrative functions require separate privileged authentication

Network Security:

  • All API traffic encrypted via TLS 1.3 with perfect forward secrecy
  • Certificate pinning prevents man-in-the-middle attacks
  • DDoS protection and rate limiting prevent abuse
  • Geographic IP restrictions available for on-premises deployments

Data Encryption

Encryption in Transit:

All data exchanged between OrbDoc and Epic travels over HTTPS connections with TLS 1.3 encryption. We enforce strong cipher suites and disable legacy protocols (SSL, TLS 1.0/1.1) vulnerable to known attacks. For VPN-connected deployments, we support additional IPsec encryption layers per organizational requirements.

Encryption at Rest:

Patient data cached within OrbDoc’s infrastructure is encrypted using AES-256 encryption:

  • Database encryption: All patient data stored in encrypted databases with hardware security module (HSM) key management
  • File storage: AI-processed audio and generated notes encrypted with unique per-file keys
  • Backup encryption: All backup archives encrypted before transmission to offline storage
  • Key rotation: Encryption keys automatically rotate every 90 days with zero-downtime re-encryption

End-to-End Encryption Options:

Enterprise deployments can enable end-to-end encryption where patient data is encrypted on the client device and only decrypted after retrieval from Epic. This ensures OrbDoc’s infrastructure never processes unencrypted PHI, providing maximum data protection for highly sensitive environments.

Audit Logging and Monitoring

OrbDoc maintains comprehensive audit logs for all patient data access and clinical documentation activities:

Logged Events:

  • User authentication and authorization (success and failures)
  • Patient record access with user, timestamp, and access reason
  • API calls to Epic FHIR endpoints with request/response metadata
  • Note generation, editing, and submission events
  • Configuration changes and administrative actions
  • Security events (failed authentication, suspicious activity)

Log Retention:

  • Clinical activity logs: 7 years (regulatory requirement)
  • Security logs: 3 years minimum
  • Audit logs: Immutable, tamper-evident storage with cryptographic hashing

Monitoring and Alerting:

  • Real-time alerts for authentication failures or unusual access patterns
  • Performance monitoring for API latency and error rates
  • Integration health checks with automatic escalation for outages
  • SIEM (Security Information and Event Management) integration for enterprise customers

Epic administrators can access OrbDoc audit logs via secure API or scheduled reports, supporting Joint Commission compliance, security incident investigations, and access audits.

Epic App Orchard Certification

OrbDoc has achieved Epic App Orchard certification, demonstrating compliance with Epic’s rigorous security, interoperability, and user experience standards. App Orchard certification requires:

  • FHIR API compliance testing and validation
  • Security review including penetration testing and vulnerability assessment
  • User interface consistency with Epic’s design guidelines
  • Performance testing under simulated production loads
  • Business associate agreement (BAA) and liability insurance verification

App Orchard certification enables streamlined deployment for Epic customers, with OrbDoc appearing in Epic’s app marketplace. Organizations can deploy OrbDoc via Epic’s standard third-party application provisioning process, reducing IT overhead and accelerating time-to-value.

Certification Status:

  • Current certification version: Epic FHIR R4 (2024)
  • Supported Epic versions: 2018 and later
  • Recertification: Annual testing against latest Epic releases
  • Security attestation: SOC 2 Type II, HITRUST CSF certified

Implementation Requirements

Technical Prerequisites

Organizations planning Epic integration should verify the following technical prerequisites before beginning implementation:

Epic Configuration Requirements:

  • Epic version 2018 or later with FHIR APIs enabled
  • App Orchard provisioned and configured (or equivalent FHIR proxy)
  • OAuth 2.0 authentication server configured for third-party applications
  • FHIR resource permissions enabled for Patient, Encounter, DocumentReference, Observation, MedicationRequest, Condition, AllergyIntolerance
  • SSL/TLS certificates valid and trusted by standard certificate authorities

Organizational Requirements:

  • Business Associate Agreement (BAA) executed between organization and OrbDoc
  • Security risk assessment completed and documented
  • Clinician training plan for OrbDoc workflows
  • IT support resources identified for integration troubleshooting
  • Change management approval per organizational policies

User Access Requirements:

  • Clinicians require Epic user accounts with appropriate clinical role
  • FHIR API access enabled for provider user class
  • OrbDoc licenses provisioned (per-user or per-organization basis)
  • Single sign-on (SSO) configured if using Epic-launched workflow

Network and Firewall Configuration

Firewall Rules (for on-premises Epic installations):

Organizations must configure firewalls to allow outbound HTTPS connections from Epic’s FHIR proxy servers to OrbDoc’s infrastructure:

  • Destination IPs: OrbDoc provides static IP ranges for allowlisting (varies by customer region)
  • Ports: 443 (HTTPS) outbound
  • Protocol: TCP
  • TLS Version: TLS 1.2 minimum, TLS 1.3 preferred

DNS Requirements:

  • DNS resolution for OrbDoc API endpoints (api.orbdoc.com)
  • DNS resolution for Epic’s OAuth authorization server
  • Corporate proxies must allow HTTPS traffic without SSL inspection (to preserve end-to-end encryption)

Bandwidth Considerations:

  • Typical encounter: 100-500 KB data transfer (retrieval + note submission)
  • Audio upload: 1-5 MB per encounter (if using voice documentation)
  • Concurrent users: Plan for 50 Kbps per simultaneous user as baseline
  • Peak usage: Consider 3-5x baseline during high-volume clinic hours

Load Balancer Configuration (if applicable):

  • Health check endpoint: https://api.orbdoc.com/health
  • Session affinity: Not required (stateless API design)
  • Timeout settings: 60 seconds minimum for note generation API calls

Epic Team Involvement Required

Successful Epic integration requires coordination between OrbDoc implementation specialists and the organization’s Epic team. Typical Epic roles involved include:

Epic FHIR Administrator:

  • Provisions OrbDoc application in App Orchard or FHIR proxy
  • Configures OAuth 2.0 client credentials and redirect URIs
  • Enables required FHIR resource permissions
  • Reviews and approves API scopes requested by OrbDoc

Epic Clinical Informatics:

  • Reviews note templates and SmartText integration requirements
  • Configures DocumentReference types for OrbDoc-submitted notes
  • Maps OrbDoc note sections to Epic note template sections
  • Validates coded data mappings (diagnosis codes, medication codes)

Epic Security/Compliance:

  • Reviews OrbDoc security documentation and BAA
  • Approves network connectivity and firewall changes
  • Conducts security testing in non-production environment
  • Approves production deployment per security policies

Epic Analyst (Application Coordinators):

  • Configures user roles and access permissions
  • Tests end-user workflows in Epic test environment
  • Develops training materials specific to organizational workflows
  • Provides post-deployment user support

Implementation Timeline

Typical Epic integration implementations follow a 4-6 week timeline:

Week 1: Discovery and Planning

  • Kickoff meeting with organizational stakeholders and OrbDoc team
  • Technical architecture review and prerequisites verification
  • Network assessment and firewall change requests
  • BAA execution and compliance documentation review

Week 2: Non-Production Configuration

  • App Orchard provisioning in Epic test environment
  • OAuth configuration and FHIR permissions enablement
  • OrbDoc test environment configuration with Epic test endpoint
  • Initial connectivity testing and authentication validation

Week 3: Integration Testing

  • End-to-end workflow testing in Epic test environment
  • Note template mapping and SmartText configuration
  • User acceptance testing with pilot clinicians
  • Performance testing and optimization

Week 4: Training and Preparation

  • Clinician training sessions (virtual or in-person)
  • IT support training for troubleshooting common issues
  • Production environment preparation (firewall rules, App Orchard production config)
  • Go-live planning and communication

Week 5-6: Production Deployment and Support

  • Production App Orchard provisioning and connectivity validation
  • Phased rollout to pilot users
  • Monitoring and troubleshooting during initial production usage
  • Feedback collection and optimization
  • Full production rollout upon pilot success

Complex deployments involving multiple Epic instances, custom note templates, or extensive SmartData integration may extend to 8-12 weeks. Organizations with prior third-party FHIR integration experience typically complete implementation faster.

Case Study: Regional Health System Epic Integration

Organization Background

A 12-hospital regional health system in the southeastern United States deployed OrbDoc to address physician burnout driven by documentation burden. The organization operates on Epic 2020, with 850 employed physicians and advanced practice providers across primary care, specialty clinics, and hospital-based services.

Initial Challenges:

  • Physicians spending 2-3 hours daily on after-hours documentation
  • Patient satisfaction scores declining due to clinicians focusing on computer screens during visits
  • High documentation variability across providers impacting quality metrics
  • Prior voice recognition solutions required extensive template management and post-editing

Implementation Approach

The health system’s Epic integration followed a 5-week implementation timeline:

Week 1-2: Technical Foundation

The IT team provisioned OrbDoc in Epic’s App Orchard test environment and configured OAuth 2.0 authentication. Network team opened firewall rules allowing outbound HTTPS from Epic’s interconnect server to OrbDoc’s cloud infrastructure. Clinical informatics team mapped OrbDoc’s standard note structure to the organization’s Epic note templates, including SmartText macros for billing codes and quality measures.

Week 3: Pilot Testing

Ten primary care physicians in two clinics tested OrbDoc in Epic’s test environment. Initial testing revealed that the organization’s complex SmartData fields for chronic disease management required custom mapping. OrbDoc’s implementation team worked with the Epic analyst team to configure AI-generated content to populate these discrete data elements automatically.

Week 4: Optimization and Training

Based on pilot feedback, the team refined note templates to match organizational documentation preferences. Training sessions educated physicians on optimal voice documentation techniques and how to review and approve AI-generated notes efficiently. Epic security team conducted penetration testing and approved production deployment.

Week 5: Production Launch

OrbDoc deployed to production for the initial pilot group, with daily monitoring and support. After two weeks of stable operation and positive physician feedback, the organization expanded to additional specialties in phases. Full deployment completed over 12 weeks post-launch.

Technical Solutions to Key Challenges

Challenge 1: Complex SmartData Population

The organization used extensive SmartData fields for quality reporting, particularly for diabetes, hypertension, and preventive care measures. Standard FHIR DocumentReference submission couldn’t populate these discrete fields.

Solution: OrbDoc developed custom note formatting that embedded SmartLink commands within generated notes. When Epic imported the note, SmartLink commands triggered SmartData population with AI-extracted values. For example, AI-extracted blood pressure readings automatically populated the BP SmartData element, flowing into quality dashboards without manual re-entry.

Challenge 2: Medication Reconciliation Workflow

Physicians required medication reconciliation documentation that compared Epic’s medication list with patient-reported medications during the encounter.

Solution: OrbDoc enhanced its Epic integration to retrieve Epic’s current medication list and present it alongside AI-transcribed patient-reported medications. The reconciliation interface highlighted discrepancies, enabling physicians to approve, modify, or discontinue medications directly within OrbDoc. Approved changes submitted back to Epic via MedicationRequest updates, maintaining list accuracy.

Challenge 3: Performance During Peak Clinic Hours

Initial testing revealed API latency spikes during 8-10 AM when hundreds of physicians simultaneously accessed Epic for morning clinics.

Solution: OrbDoc implemented intelligent caching and pre-fetching. When physicians opened their clinic schedules in Epic, OrbDoc pre-loaded patient context for scheduled appointments, distributing API load across the morning rather than concentrating it at encounter start. This reduced perceived latency from 3-5 seconds to <1 second for encounter initiation.

Results and Outcomes

Six months post-deployment, the health system reported measurable improvements:

  • Documentation Time: Average 50% reduction in time to complete clinical notes
  • After-Hours Work: Physicians reduced after-hours charting by 1.5 hours daily
  • Patient Satisfaction: Patient ratings for “provider listened and explained clearly” increased 12%
  • Documentation Quality: Note completeness scores improved, with 95% of notes including all required elements
  • Adoption: 78% of eligible physicians actively using OrbDoc within 6 months

The integration proved stable with 99.7% uptime, experiencing no security incidents or data breaches. Epic team reported minimal support burden, with most user issues resolved through standard OrbDoc support channels rather than requiring Epic analyst involvement.

Troubleshooting & Support

Common Integration Issues

Authentication Failures

Symptom: Users receive “Authorization Failed” errors when launching OrbDoc from Epic or during standalone authentication.

Common Causes:

  • OAuth client credentials misconfigured in Epic App Orchard
  • Redirect URI mismatch between OrbDoc configuration and Epic settings
  • User lacks required FHIR API permissions in Epic role
  • Access token expired and refresh token invalid

Resolution Steps:

  1. Verify OAuth client ID and secret in Epic App Orchard match OrbDoc configuration
  2. Confirm redirect URI exactly matches (case-sensitive, including trailing slashes)
  3. Check user’s Epic role includes FHIR API access permissions
  4. Review Epic audit logs for specific OAuth error codes
  5. Test authentication with OrbDoc-provided troubleshooting tool

Patient Data Retrieval Errors

Symptom: OrbDoc displays “Unable to load patient data” or shows incomplete patient context.

Common Causes:

  • FHIR resource permissions not enabled in Epic for required resources
  • Patient consent directives block third-party access
  • Epic FHIR server rate limiting due to high volume
  • Network connectivity issues between Epic and OrbDoc infrastructure

Resolution Steps:

  1. Verify all required FHIR resources (Patient, Encounter, DocumentReference, etc.) enabled in App Orchard configuration
  2. Check patient’s consent status in Epic—some patients may opt out of third-party data sharing
  3. Review Epic FHIR server logs for rate limiting or quota errors
  4. Test connectivity with manual FHIR API call from Epic’s test environment
  5. Contact OrbDoc support with specific patient identifier and error message for investigation

Note Submission Failures

Symptom: Clinician approves note in OrbDoc, but note doesn’t appear in Epic chart.

Common Causes:

  • DocumentReference permissions insufficient (read-only instead of write)
  • Note template format incompatible with Epic’s document repository
  • Encounter status prevents note attachment (e.g., encounter not opened in Epic)
  • Network timeout during submission for large notes

Resolution Steps:

  1. Confirm DocumentReference.write permission enabled in App Orchard
  2. Review note format in OrbDoc—verify it matches Epic’s accepted document types
  3. Check encounter status in Epic—encounter must be active or open to accept notes
  4. For large notes (>100 KB), investigate network timeouts and consider increasing Epic’s FHIR server timeout settings
  5. Review DocumentReference submission logs in OrbDoc admin portal for specific error codes

Performance and Latency Issues

Symptom: Slow response times when loading patient data or submitting notes.

Common Causes:

  • Network bandwidth constraints during peak usage
  • Epic FHIR server performance degradation
  • Inefficient FHIR queries retrieving excessive data
  • Geographic latency between Epic data center and OrbDoc infrastructure

Resolution Steps:

  1. Monitor network utilization during problem periods—identify bandwidth bottlenecks
  2. Review Epic FHIR server performance metrics (CPU, memory, response times)
  3. Analyze FHIR query patterns—optimize queries to retrieve only necessary data
  4. Consider dedicated VPN tunnel or ExpressRoute connection for consistent performance
  5. For cloud-hosted Epic, verify OrbDoc infrastructure deployed in geographically proximate region

Monitoring and Alerting

OrbDoc provides comprehensive monitoring tools for IT teams managing Epic integrations:

Integration Health Dashboard:

  • Real-time API success rates (target: >99.5%)
  • Average API response times (target: <500ms p95)
  • Authentication success/failure rates
  • Note submission success rates
  • Active user sessions and concurrent usage

Automated Alerts:

Organizations can configure alerts for:

  • API error rate exceeds threshold (e.g., >1% failures over 5 minutes)
  • Authentication failures spike (potential security incident)
  • Note submission failures for specific users or clinics
  • API latency exceeds SLA (e.g., p95 >2 seconds)
  • Epic FHIR server connectivity loss

Alerts deliver via email, SMS, or integration with organizational incident management systems (PagerDuty, ServiceNow, etc.).

Audit and Compliance Reports:

Scheduled reports provide:

  • User access audit logs (patient accessed, timestamp, user identity)
  • Failed authentication attempts by user and IP address
  • API usage metrics by user, clinic, and resource type
  • Note submission volumes and average completion times
  • Compliance metrics (e.g., note completion within 24 hours of encounter)

Support Escalation Process

Level 1: User Support

Clinician-facing issues (authentication problems, UI questions, workflow guidance) typically handled by organizational IT helpdesk or OrbDoc’s user support team:

  • Contact: [email protected]
  • Hours: 24/7 for critical issues, 8 AM - 8 PM ET for general support
  • Response Time: <1 hour for critical issues, <4 hours for standard issues
  • Resolution: User training, account configuration, basic troubleshooting

Level 2: Integration Support

Technical issues requiring Epic expertise or API troubleshooting handled by OrbDoc’s integration engineering team in collaboration with Epic analysts:

  • Contact: [email protected]
  • Hours: 8 AM - 6 PM ET business days, on-call for critical production issues
  • Response Time: <2 hours for critical issues, <8 hours for standard issues
  • Resolution: FHIR API debugging, Epic configuration review, note template modifications

Level 3: Epic Vendor Escalation

Critical issues involving Epic platform bugs or FHIR API defects escalated to Epic through organization’s Epic technical services agreement:

  • Contact: Via organization’s Epic TS contact
  • Response Time: Per organization’s Epic support agreement
  • Resolution: Epic platform patches, FHIR API updates, App Orchard configuration changes

Critical Incident Process:

For production outages impacting clinical workflows:

  1. Immediate notification to organizational IT leadership and OrbDoc on-call engineer
  2. Joint troubleshooting session within 30 minutes (screen share, log review)
  3. Hourly status updates until resolution
  4. Post-incident review within 48 hours with root cause analysis and prevention measures

OrbDoc maintains 99.9% uptime SLA for Epic integration APIs, with financial credits for unplanned downtime exceeding SLA thresholds.

Additional Resources

Documentation:

  • OrbDoc Epic Integration Developer Guide
  • FHIR API Reference Documentation
  • Epic App Orchard Configuration Guides
  • SmartData Integration Specifications

Training:

  • Clinician Training Videos (15-minute quick start)
  • IT Administrator Training (2-hour technical deep dive)
  • Epic Analyst Collaboration Workshop (4-hour hands-on configuration)

Community:

  • OrbDoc User Community Forum
  • Monthly Epic Integration Office Hours (live Q&A with engineering team)
  • Release Notes and Integration Updates

Contact:

This technical guide reflects OrbDoc’s Epic integration capabilities as of October 2025. Epic integration features and FHIR API support evolve continuously. Contact OrbDoc’s integration team for the latest capabilities and Epic version compatibility.