Building a National FHIR R4 Platform for 20,000+ US Skilled Nursing Facilities — with QAPI & CMS 5-Star Automation

20,000+ SNFs (PointClickCare, MatrixCare, Netsmart, AHT...)
    │  HL7 v2 ADT / ORU / MDS 3.0
    ▼
Azure Event Hubs  (per-facility partitioning, 1M+ msgs/day)
    │
    ▼
Azure Functions  — HL7 → FHIR R4 Mapper  (C# + Firely SDK)
    │  Validated FHIR R4 Transaction Bundles
    ▼
Azure Health Data Services  (FHIR R4 Server — multi-tenant)
    │  FHIR REST API  +  $everything  +  bulk export
    ├──► QAPI Compliance Engine  (.NET 8 worker)
    ├──► CMS 5-Star Rating Engine  (.NET 8 worker)
    ├──► Agentic Medical Director  (Claude + GPT-4o)
    └──► 10+ EMR Micro-Apps  (Angular 17 Module Federation)

public class AdtA01ToFhirMapper : IHl7Mapper<AdtA01Message>
{
    public Bundle Map(AdtA01Message msg)
    {
        var patient = new Patient
        {
            Id = msg.PatientId.ToFhirId(),
            Name = [new HumanName { Family = msg.PatientName.LastName,
                                    Given  = [msg.PatientName.FirstName] }],
            BirthDate  = msg.DateOfBirth.ToFhirDate(),
            Identifier = [new Identifier { System = "urn:oid:2.16.840.1.113883.4.1",
                                           Value  = msg.Ssn }]
        };
 
        var encounter = new Encounter
        {
            Subject = new ResourceReference("Patient/" + patient.Id),
            Status  = Encounter.EncounterStatus.InProgress,
            Class   = new Coding("http://terminology.hl7.org/CodeSystem/v3-ActCode", "IMP"),
            Period  = new Period { Start = msg.AdmissionDate.ToFhirDateTime() }
        };
 
        return FhirBundleBuilder.Transaction(patient, encounter);
    }
}

public async Task EvaluateQapiThresholdsAsync(string facilityId)
{
    var metrics = await _metricsService.GetCurrentMetricsAsync(facilityId);
 
    foreach (var metric in metrics.Where(m => m.IsBelowThreshold))
    {
        var plan = await _qapiPlanGenerator.GenerateAsync(new QapiContext
        {
            FacilityId  = facilityId,
            MetricCode  = metric.Code,
            CurrentRate = metric.Rate,
            Benchmark   = metric.NationalBenchmark,
            TrendData   = metric.Last12Months
        });
 
        await _notificationService.AlertQapiTeamAsync(facilityId, plan);
        await _fhirClient.CreateAsync(plan.ToFhirTask());
    }
}

public async Task<StarRating> ComputeFiveStarRatingAsync(string facilityId)
{
    // Pillar 1: Health Inspection score from CMS Care Compare feed
    var inspectionScore = await _inspectionService.GetScoreAsync(facilityId);
 
    // Pillar 2: Staffing — RN hours/resident/day + total staffing
    var pbj = await _pbjService.GetStaffingMetricsAsync(facilityId);
    var staffingScore = _staffingScorer.ComputeScore(pbj);
 
    // Pillar 3: Quality Measures — 15 short-stay + 16 long-stay MDS measures
    var qmScores = await _qmService.ComputeAllMeasuresAsync(facilityId);
    var qmScore = _qmScorer.ComputeOverall(qmScores);
 
    // Weighted composite → 1-5 star rating
    return _ratingCalculator.Calculate(inspectionScore, staffingScore, qmScore);
}

public class AgenticMedicalDirector
{
    public async Task<DirectorResponse> RunAsync(FacilityContext ctx)
    {
        // 1. Pull current FHIR data for this facility
        var snapshot = await _fhirService.GetFacilitySnapshotAsync(ctx.FacilityId);
 
        // 2. Build structured prompt with clinical context
        var prompt = _promptBuilder.Build(new MedicalDirectorPrompt
        {
            QapiMetrics       = snapshot.QapiMetrics,
            FiveStarRating    = snapshot.CurrentRating,
            AtRiskResidents   = snapshot.AtRiskResidents,
            RecentIncidents   = snapshot.Last30DayIncidents,
            PendingDeficiency = snapshot.OpenCmsDeficiencies
        });
 
        // 3. Run Claude for clinical reasoning (long context, nuanced)
        var analysis = await _claude.CompleteAsync(prompt, model: "claude-opus-4-5");
 
        // 4. Run GPT-4o for structured action plan output (JSON schema)
        var actionPlan = await _openAi.StructuredOutputAsync<QapiActionPlan>(
            analysis.Summary, responseFormat: QapiActionPlan.Schema);
 
        return new DirectorResponse { Analysis = analysis, ActionPlan = actionPlan };
    }
}