AI-Powered EHR Onboarding Automation

The Problem

A mid-size regional health system was drowning in manual data entry. Onboarding new patients to their EHR platform required 45+ minutes per patient — staff manually transcribing handwritten intake forms, verifying insurance information, and mapping medical codes. The error rate sat at 12%, creating downstream billing issues and clinical documentation gaps.

Staff burnout was increasing. The onboarding backlog caused 3-5 day delays in care documentation. The health system needed a solution that could handle the volume, maintain accuracy, and comply with HIPAA requirements.

The Dataset

We worked with 100,000+ patient intake forms spanning PDFs, handwritten documents, and faxed pages. For validation, we had access to 1.3M historical EHR records, ICD-10/CPT code mapping databases, and insurance verification APIs.

Data quality was a major challenge—handwritten forms had variable layouts, inconsistent formatting, and frequently illegible sections. Around 15% of forms contained non-standard fields added by individual clinics.

Model & Approach

We built a three-model ensemble pipeline rather than relying on a single approach:

• LayoutLM v3 (fine-tuned): Form understanding and entity extraction—trained on 8,000+ annotated form samples to understand checkboxes, structured fields, and free-text areas.
• GPT-4: Entity normalization—mapping extracted entities to standard medical terminologies (ICD-10, CPT, SNOMED CT) and resolving ambiguities.
• Rule-based validators: Deterministic checks for medical coding compliance, insurance format validation, and cross-field consistency.

The ensemble approach—ML extraction → LLM normalization → deterministic validation—dramatically outperformed any single model, particularly for edge cases in medical coding.

Architecture

Three-stage event-driven pipeline:

1. Stage 1 — OCR + Layout Analysis: Documents scanned via high-accuracy OCR with layout-aware preprocessing. Form type classification determines which extraction template to apply.
2. Stage 2 — Entity Extraction + Classification: LayoutLM v3 extracts structured entities (patient name, DOB, medication list, diagnoses). GPT-4 normalizes free-text entries to standard codes.
3. Stage 3 — EHR Integration: FHIR R4-compliant data mapping pushes validated records to the EHR system. HL7v2 adapters handle legacy system integration.

Dead-letter queues capture failed extractions requiring human review—less than 5% of total volume. A human review dashboard surfaces these cases with pre-populated suggestions.

Deployment

HIPAA-compliant AWS environment with VPC isolation. ECS Fargate for serverless compute (no data on persistent servers). S3 with server-side encryption for document storage. CloudWatch + PagerDuty for monitoring and alerting.

All services covered under a Business Associate Agreement (BAA). Zero PHI exits the secure VPC. Audit logging captures every data access for compliance reporting.

Results

ROI

$2M annual savings in administrative labor costs. Payback period: 4.5 months. Staff reallocated 2,100 hours/month from data entry to direct patient care—a qualitative improvement that's hard to put a dollar figure on but transformed the care experience.

Why It Was Hard

Handwritten forms with variable layouts were the biggest technical challenge. Standard OCR models failed on ~30% of handwritten fields. We needed layout-aware understanding, not just character recognition.

HIPAA compliance required zero-trust data handling—no cloud service could touch PHI without BAA coverage. Integration with the legacy EHR system (HL7v2, not FHIR-native) required building custom adapters. Edge cases in insurance code mapping (same procedure, different codes by payer) needed extensive rule-based post-processing.

What We Learned

Ensemble approaches (ML + LLM + rules) outperform any single model for healthcare document processing. Each layer catches what the others miss. The LayoutLM model handles structure, GPT-4 handles semantic understanding, and rules catch compliance edge cases.

Human-in-the-loop review for less than 5% of cases provides the necessary safety net without bottlenecking throughput. The key is making the review interface fast—pre-populated suggestions reduced human review time from 8 minutes to 90 seconds per case.

FAQ