Solution Specification: IPS Integration for SHIF Claims Processing

1. Introduction

This solution specification outlines the technical implementation for integrating International Patient Summary (IPS) validation into the Social Health Insurance Fund (SHIF) claims processing workflow. The system connects healthcare information management systems (HIMS) with payer systems through an HIE Mediator, utilizing HL7 FHIR standards and Kafka-based asynchronous processing.

2. System Overview

The solution implements an end-to-end workflow for claims submission, processing, and validation using patient medication history from the IPS. The workflow spans across four key components:

  1. Healthcare Information Management Systems (HIMS)
  2. HIE Mediator
  3. Payer System
  4. Shared Health Repository (SHR)

3. Architecture

Architecture Diagram for IPS Integration with SHIF Claims

3.1 Component Descriptions

3.1.1 HIMS (Healthcare Information Management System)

  • Initiates claims in HL7 FHIR format
  • Polls for claim status updates
  • Receives final claim responses

3.1.2 HIE Mediator

  • Serves as integration hub between systems
  • Routes messages between HIMS and Payer
  • Provides REST APIs for claim submission and status checks
  • Maintains claim transaction logs
  • Handles authentication and authorization

3.1.3 Payer System

  • Processes claims against policy rules
  • Requests IPS data for validation
  • Makes claim adjudication decisions
  • Returns claim responses to HIE Mediator

3.1.4 HIE Shared Health Repository (SHR)

  • Stores and manages International Patient Summary (IPS) documents
  • Processes IPS retrieval requests via Kafka
  • Validates request authorization
  • Returns IPS data in HL7 FHIR format

4. Detailed Workflow

4.1 Claim Submission Flow

  1. HIMS to HIE Mediator

    • HIMS creates a FHIR Claim resource
    • HIMS POSTs the Claim to (Visit Claims guide) on HIE Mediator
    • HIE Mediator validates message structure and authentication
    • HIE Mediator assigns unique transaction ID and logs the request

  2. HIE Mediator to Payer

    • HIE Mediator forwards Claim to Payer system API
    • Payer acknowledges receipt with a 202 Accepted response
    • HIE Mediator returns transaction ID to HIMS

  3. Payer to HIE SHR

    • Payer extracts patient identifier from Claim
    • Payer requests IPS from SHR via this implementation -> (Visit IPS guide)
    • Request is queued in a Kafka topic for asynchronous processing
    • SHR processes the request and fetches IPS

  4. IPS Validation by Payer

    • SHR returns IPS as FHIR Bundle to Payer
    • Payer extracts medication history from IPS
    • Payer validates claim against medication history:
      • Verifies prescribed medications match claim
      • Validates prescription dates and duration
      • Checks for medication duplications or conflicts

  5. Claim Response

    • Payer creates ClaimResponse with status, approved amount, and reason
    • Payer sends ClaimResponse to HIE Mediator callback endpoint
    • HIE Mediator forwards response to HIMS via registered callback URL
    • HIMS processes and displays claim results

4.2 Status Polling

  • HIMS can poll HIE Mediator endpoint defined in the Claims documentation
  • HIE Mediator returns current processing status from its transaction log

5. Technical Specifications

5.1 API Specifications

5.1.1 HIE Mediator APIs

Claim Submission API

(Visit Claims guide)

5.1.2 Payer System APIs

IPS Retrieval API Visit IPS guide

5.2 Data Models

5.2.1 FHIR Resources

The solution utilizes the following FHIR R4 resources:

Claim - Contains service provider details, patient information, medications being claimed - Includes reference to prescriptions (MedicationRequest resources) - Includes coverage information (SHIF member details)

ClaimResponse - Contains adjudication outcome - Includes approved amount and currency - Provides detailed reason codes for approved/rejected items - References original claim

MedicationRequest - Part of IPS - Contains prescribed medication details - Includes dosage, duration, prescriber information - Contains dispense request details including refill information

Bundle (IPS) - Contains Composition, Patient, MedicationRequest, Condition, and other relevant resources - Structured according to IPS implementation guide

5.3 Security Specifications

  1. Authentication

    • OAuth 2.0 for all API endpoints
    • JWT tokens with appropriate claims and scopes
    • Token lifetime limited to 1 hour with refresh capability

  2. Authorization

    • Role-based access control (RBAC)
    • Specific roles for HIMS, Payer, and SHR interaction
    • Claims data access restricted by organization

  3. Data Protection

    • TLS 1.3 for all communications
    • Data encrypted at rest using AES-256
    • PII/PHI handling compliant with local regulations

  4. Audit Trail

    • All transactions logged with timestamp, user, action, and system
    • Immutable logs maintained for compliance purposes
    • Specific attention to IPS access events

6. Implementation Requirements

6.1 HIE Mediator Requirements

  1. Technical Stack

    • RESTful API framework
    • FHIR validation libraries (HAPI FHIR)
    • Relational database for transaction logging (PostgreSQL)
    • Message queue for reliability (RabbitMQ)

  2. Performance Requirements

    • Support for 100 transactions per second
    • Maximum response time of 500ms for API calls
    • 99.9% uptime requirement
    • Automatic recovery from failures

  3. Scaling Considerations

    • Horizontal scaling capability
    • Load balancing across instances
    • Database connection pooling

6.2 HIMS Integration Requirements

  1. FHIR Support

    • Implementation of Claim and ClaimResponse resources
    • Support for REST API calls
    • JSON parsing capabilities
    • Webhook endpoint for callbacks

  2. UI Requirements

    • Claim submission form
    • Claim status tracking interface
    • Response display with reason codes

  3. Configuration

    • API endpoint configuration
    • Authentication credential management
    • Timeout settings

6.3 Payer System Requirements

  1. Integration Capabilities

    • FHIR API client for IPS retrieval
    • Kafka producer/consumer for async processing
    • Business rules engine for claim adjudication

  2. Functional Requirements

    • Policy validation logic
    • IPS interpretation capabilities
    • Medication matching algorithms
    • Response generation with detailed reasons

6.4 SHR Requirements

  1. IPS Storage and Retrieval

    • FHIR server implementation
    • Support for IPS document structure
    • Fast query capabilities by patient identifier

  2. Kafka Processing

    • Topic and consumer group configuration
    • Message serialization/deserialization
    • Error handling and retry logic

7. Testing Strategy

  1. Unit Testing

    • Test individual components in isolation
    • Mock external dependencies
    • Cover critical business logic

  2. Integration Testing

    • Test component interactions
    • Verify correct message passing
    • Validate data transformations

  3. End-to-End Testing

    • Test complete workflow from claim submission to response
    • Verify correct handling of edge cases
    • Test with real-world data scenarios

  4. Performance Testing

    • Evaluate system under load
    • Identify bottlenecks
    • Verify scaling capabilities

  5. Security Testing

    • Penetration testing
    • Authentication/authorization verification
    • Data encryption validation

8. Deployment and Operations

8.1 Deployment Architecture

  1. Environment Setup

    • Development, testing, staging, and production environments
    • Configuration management for each environment
    • CI/CD pipeline integration

  2. Infrastructure Requirements

    • Kubernetes cluster for containerized deployment
    • Kafka cluster configuration
    • Database servers
    • Load balancers

  3. Monitoring and Alerting

    • Prometheus for metrics collection
    • Grafana for visualization
    • Alert configuration for critical errors
    • Transaction volume monitoring

8.2 Operational Procedures

  1. Backup and Recovery

    • Database backup schedule
    • Transaction log protection
    • Disaster recovery procedure

  2. Scaling Procedures

    • Horizontal scaling triggers
    • Resource allocation guidelines
    • Peak load handling

  3. Incident Management

    • Severity classification
    • Response procedures
    • Escalation paths

9. Implementation Roadmap

Phase 1: Core Integration (Timeline TBD)

  • Set up HIE Mediator basic architecture
  • Implement FHIR validation
  • Develop claim submission and status APIs
  • Create transaction logging

Phase 2: IPS Integration (Timeline TBD)

  • Implement Kafka integration
  • Develop IPS retrieval functionality
  • Create IPS validation logic in Payer system
  • Test end-to-end IPS retrieval

Phase 3: Complete Workflow (Timeline TBD)

  • Implement callback mechanisms
  • Develop full claim processing logic
  • Create error handling and retry mechanisms
  • Set up monitoring and alerting

Phase 4: Testing and Optimization (Timeline TBD)

  • Perform integration testing
  • Conduct performance testing
  • Implement security measures
  • Optimize system performance

10. Appendices

10.1 FHIR Profiles

Detailed FHIR profiles for: - SHIF Claim - SHIF ClaimResponse - IPS Document

10.2 Error Codes and Handling

Complete list of error codes, descriptions, and handling procedures.

10.3 Sample Messages

Examples of: - Claim submission - IPS document - ClaimResponse messages - Error responses

10.4 Glossary

Definitions of key terms and acronyms used in the specification.

Discard
Save
Draft
Edit Page New Page Revisions Page Settings

Previous Page

Left

Next Page

Right
Review Changes ← Back to Content
Message Status Space Raised By Last update on