Automate utilization-review of health insurance claims using generative AI

Last reviewed 2024-08-19 UTC

This document describes a reference architecture for health insurance companies who want to automate prior authorization (PA) request processing and improve their utilization review (UR) processes by using Google Cloud. It's intended for software developers and program administrators in these organizations. This architecture helps to enable health plan providers to reduce administrative overhead, increase efficiency, and enhance decision-making by automating data ingestion and the extraction of insights from clinical forms. It also allows them to use AI models for prompt generation and recommendations.

Architecture

The following diagram describes an architecture and an approach for automating the data ingestion workflow and optimizing the utilization management (UM) review process. This approach uses data and AI services in Google Cloud.

Data ingestion and UM review process high-level overview.

The preceding architecture contains two flows of data, which are supported by the following subsystems:

  • Claims data activator (CDA), which extracts data from unstructured sources, such as forms and documents, and ingests it into a database in a structured, machine-readable format. CDA implements the flow of data to ingest PA request forms.
  • Utilization review service (UR service), which integrates PA request data, policy documents, and other care guidelines to generate recommendations. The UR service implements the flow of data to review PA requests by using generative AI.

The following sections describe these flows of data.

CDA flow of data

The following diagram shows the flow of data when CDA ingests PA request forms.

PA case managers flow of data.

As shown in the preceding diagram, the PA case managers interact with the system components to ingest, validate, and process the PA requests. The PA case managers are the individuals from the business operations team who are responsible for the intake of the PA requests. The flow of events is as follows:

  1. The PA case managers receive the PA request forms (the pa_forms forms) from the healthcare provider and upload them to the pa_forms_bkt Cloud Storage bucket.
  2. The ingestion_service service listens to the pa_forms_bkt bucket for changes. The ingestion_service service picks up the pa_forms forms from the pa_forms_bkt bucket. The service identifies the pre-configured Document AI processors, which are called form_processors. These processors are defined to process the pa_forms forms. The ingestion_service service extracts information from the forms by using the form_processors processors. The data that's extracted from the forms is in JSON format.
  3. The ingestion_service service writes the extracted information with field-level confidence scores into the Firestore database collection, which is called the pa_form_collection collection.
  4. The hitl_app application fetches the JSON information with confidence scores from the pa_form_collection collection. The application calculates the document-level confidence score from the field-level confidence scores that the form_processors machine learning (ML) models provide in the output.
  5. The hitl_app application displays the extracted information with the field-level and document-level confidence scores to the PA case managers so that they can review and correct the information if the extracted values are inaccurate. PA case managers can update the incorrect values and save the document in the pa_form_collection collection.

UR service flow of data

The following diagram shows the flow of data for the UR service.

UR specialist flow of data.

As shown in the preceding diagram, the UR specialists interact with the system components to conduct a clinical review of the PA requests. The UR specialists are typically nurses or physicians with experience in a specific clinical area who are employed by healthcare insurance companies. The case management and routing workflow for PA requests is out of scope for the workflow that this section describes.

The flow of events is as follows:

  1. The ur_app application displays a list of PA requests and their review status to the UR specialists. The status shows as in_queue, in_progress, or completed.
  2. The application creates the list from the pa_form information data in the pa_form_collection collection. The UR specialist opens a request when they click an item from the list in the ur_app application.
  3. The ur_app application submits the pa_form information data to the prompt_model model. It uses the Gemini API in Gemini Enterprise Agent Platform to generate a prompt that's similar to the following:

    Review a PA request for {medication|device|medical service} for our member, {Patient Name}, who is {age} old, {gender} with {medical condition}. The patient is on {current medication|treatment list}, has {symptoms}, and has been diagnosed with {diagnosis}.
    

  4. The ur_app application displays the generated prompt to the UR specialists for review and feedback. UR specialists can update the prompt in the UI and send it to the application.

  5. The ur_app application sends the prompt to the ur_model model with a request to generate a recommendation. The model generates a response and returns it to the application. The application displays the recommended outcome to the UR specialists.

  6. The UR specialists can use the ur_search_app application to search for the clinical documents files, the care guidelines documents, and the plan policy documents files. These documents are pre-indexed and accessible to the ur_search_app application.

Components

The architecture contains the following components:

  • Cloud Storage buckets: UM application services require the following Cloud Storage buckets in your Google Cloud project:

    • pa_forms_bkt: A bucket to ingest the PA forms that need approval.
    • training_forms: A bucket to hold historical PA forms to train the Document AI form processors.
    • eval_forms: A bucket to hold PA forms to evaluate the accuracy of the Document AI form processors.
    • tuning_dataset: A bucket to hold the data that's required to tune the large language model (LLM).
    • eval_dataset: A bucket to hold the data that's required to evaluate the LLM.
    • clinical_docs: A bucket to hold the clinical documents that the providers submit as attachments to the PA forms or afterward to support the PA case. The search application in Agent Search indexes these documents.
    • um_policies: A bucket to hold medical necessity and care guidelines, health plan policy documents, and coverage guidelines. The search application in Agent Search indexes these documents.
  • The form_processors processors: Document AI processors that are trained to extract information from the pa_forms forms.

  • The pa_form_collection collection: A Firestore datastore that stores the extracted information as JSON documents in a NoSQL database collection.

  • The ingestion_service service: A microservice that reads the documents from the bucket, passes them to the Document AI endpoints for parsing, and stores the extracted data in the Firestore database collection.

  • The hitl_app application: A microservice web application that fetches and displays data values that are extracted from the pa_forms forms. It also renders the confidence score that the form processors (ML models) report to the PA case manager so that they can review, correct, and save the information in the datastore.

  • The ur_app application: A microservice web application that UR specialists can use to review the PA requests by using generative AI. It passes the data that's extracted from the pa_forms forms to the prompt_model model to generate a prompt. It then passes the generated prompt to the ur_model model to get the recommendation for a case.

  • Agent Platform foundation models: Agent Platform provides a variety of generative AI foundation models, such as Gemini models, that you can tune to reduce cost and latency. The models that are used in this architecture are as follows:

    • prompt_model: A tuned LLM adapter that generates prompts based on the data that's extracted from the pa_forms forms.
    • ur_model: A tuned LLM adapter that generates a draft recommendation based on the input prompt.
  • The ur_search_app application: A search application that's built with Agent Search to find relevant information for UR specialists from clinical documents, UM policies, and coverage guidelines.

Products used

This reference architecture uses the following Google Cloud products:

  • Gemini Enterprise Agent Platform: A comprehensive platform that lets you build, scale, govern, and optimize enterprise‑grade AI agents.
  • Agent Search: A platform that lets you create and deploy enterprise-grade AI-powered agents and applications.
  • Document AI: A document processing platform that takes unstructured data from documents and transforms it into structured data.
  • Firestore: A NoSQL document database built for automatic scaling, high performance, and ease of application development.
  • Cloud Run: A serverless compute platform that lets you run containers directly on top of Google's scalable infrastructure.
  • Cloud Storage: A low-cost, no-limit object store for diverse data types. Data can be accessed from within and outside Google Cloud, and it's replicated across locations for redundancy.
  • Cloud Logging: A real-time log management system with storage, search, analysis, and alerting.
  • Cloud Monitoring: A service that provides visibility into the performance, availability, and health of your applications and infrastructure.

Use case

UM is a process used by health insurance companies primarily in the United States, but similar processes (with a few modifications) are used globally in the healthcare insurance market. The goal of UM is to help to ensure that patients receive the appropriate care in the correct setting, at the optimum time, and at the lowest possible cost. UM also helps to ensure that medical care is effective, efficient, and in line with evidence-based standards of care. PA is a UM tool that requires approval from the insurance company before a patient receives medical care.

The UM process that many companies use is a barrier to providing and receiving timely care. It's costly, time-consuming, and overly administrative. It's also complex, manual, and slow. This process significantly impacts the ability of the health plan to effectively manage the quality of care, and improve the provider and member experience. However, if these companies were to modify their UM process, they could help ensure that patients receive high-quality, cost-effective treatment. By optimizing their UR process, health plans can reduce costs and denials through expedited processing of PA requests, which in turn can improve patient and provider experience. This approach helps to reduce the administrative burden on healthcare providers.

When health plans receive requests for PA, the PA case managers create cases in the case management system to track, manage and process the requests. A significant amount of these requests are received by fax and mail, with attached clinical documents. However, the information in these forms and documents is not easily accessible to health insurance companies for data analytics and business intelligence. The current process of manually entering information from these documents into the case management systems is inefficient and time-consuming and can lead to errors.

By automating the data ingestion process, health plans can reduce costs, data entry errors, and administrative burden on the staff. Extracting valuable information from the clinical forms and documents enables health insurance companies to expedite the UR process.

Design considerations

This section describes design factors, best practices, and recommendations in alignment with the Google Cloud Well-Architected Framework. Consider this information when you use this reference architecture to develop a topology that meets your specific requirements for security, reliability, cost optimization, operational efficiency, and performance.

Security, privacy, and compliance

This section describes the factors that you should consider when you use this reference architecture to design and build a topology in Google Cloud that meets your security, privacy, and compliance requirements.

In the United States, the Health Insurance Portability and Accountability Act (HIPAA, as amended, including by the Health Information Technology for Economic and Clinical Health (HITECH) Act) requires compliance with the HIPAA Security Rule, Privacy Rule, and Breach Notification Rule. Google Cloud supports HIPAA compliance, but ultimately, you are responsible for evaluating your own HIPAA compliance. Complying with HIPAA is a shared responsibility between you and Google. If your organization is subject to HIPAA and you want to use any Google Cloud products in connection with Protected Health Information (PHI), you must review and accept Google's Business Associate Agreement (BAA). The Google products that are covered under the BAA meet the requirements under HIPAA and align with Google Cloud's ISO/IEC 27001, 27017, and 27018 certifications and SOC 2 report.

Not all LLMs that are hosted in Model Garden support HIPAA. Evaluate and use only the LLMs that support HIPAA.

To assess how Google's products can meet your HIPAA compliance needs, you can review the third-party audit reports in the Compliance resource center.

Consider the following security and privacy controls when you select AI use cases and design your architecture:

  • Data governance and privacy: As described in Agent Platform and zero data retention and Data governance and generative AI, Agent Platform, Agent Search, and Document AI don't use customer data, usage data, content, or documents to train Google's foundation models without your prior permission or instruction. You can tune the foundation models with your data and documents within your secured tenant on Google Cloud.
  • Prompt and response screening: To help protect the prompt_model and ur_model models against prompt injection attacks, jailbreak attempts, and sensitive data leaks, you can integrate Model Armor with Agent Platform to screen prompts and responses.
  • PHI discovery and de-identification: To help minimize the exposure of PHI and personally identifiable information (PII) in unstructured PA forms and clinical documents before model inference or indexing, you can use Sensitive Data Protection to discover, classify, and de-identify sensitive data.
  • Perimeter security: To help mitigate data exfiltration risks across your healthcare data pipeline, you can use VPC Service Controls to establish a service perimeter around your Agent Platform, Agent Search, Document AI, Cloud Storage, and Cloud Run resources.
  • Database access control: Firestore server client libraries use Identity and Access Management (IAM) to manage access to your database. To learn about Firebase's security and privacy controls, see Privacy and Security in Firebase.
  • Container encryption and secrets management: To help protect sensitive data, you can encrypt the container images for the ingestion_service service, the hitl_app application, and the ur_app application by using customer-managed encryption keys (CMEKs) and integrate the services with Secret Manager.
  • Platform security controls: Agent Platform implements Google Cloud security controls to help secure your models and training data. Some security controls aren't supported by all generative AI features in Agent Platform. For more information, see Security controls for machine learning services and Security controls for generative AI.
  • Least privilege: Use IAM to implement the principles of least privilege and separation of duties for your cloud resources. This control lets you limit access at the project, folder, or resource level.
  • Storage encryption: Cloud Storage automatically encrypts data at rest. To learn more about additional methods to encrypt data, see Data encryption options.

Google's products follow Responsible AI principles.

For security principles and recommendations that are specific to AI and ML workloads, see AI and ML perspective: Security in the Well-Architected Framework.

Reliability

This section describes design factors that you should consider when you build and operate reliable infrastructure to automate PA request processing.

The Document AI form_processors processors are regional resources. Document AI stores data synchronously across multiple zones within a region and automatically load-balances traffic across the zones. If a zone outage occurs, data isn't lost1. If a region outage occurs, the service is unavailable until Google resolves the outage.

You can create the Cloud Storage buckets in one of three locations: regional, dual-region, or multi-region. Cloud Storage replicates data in regional buckets synchronously across multiple zones within a region. For higher availability, you can use dual-region or multi-region buckets, where Cloud Storage replicates data asynchronously across regions.

In Firestore, the information in the pa_form_collection collection can be replicated across multiple data centers to support high availability and scalability.

The ingestion_service service, the hitl_app application, and the ur_app application run as regional Cloud Run services. Cloud Run stores data synchronously across multiple zones within a region and automatically load-balances traffic across those zones. For best practices when you design resilient Cloud Run services, see Cloud Run general development tips. If you run batch document ingestion tasks as Cloud Run jobs, individual job tasks might fail due to transient errors. To handle such failures, configure task retries and checkpointing. For more information, see Jobs retries and checkpoints best practices.

To help ensure consistent throughput and predictable latency when the prompt_model and ur_model models process high volumes of PA requests, you can use Provisioned Throughput on Agent Platform.

For reliability principles and recommendations that are specific to AI and ML workloads, see AI and ML perspective: Reliability in the Well-Architected Framework.

Cost optimization

This section provides guidance to help you optimize the cost of your PA and UR automation architecture. You can manage your overall cost when you monitor resource usage and select appropriate service tiers.

  • Cloud Storage storage classes: Use the different storage classes (Standard, Nearline, Coldline, or Archive) based on how frequently your workloads access the data. Nearline, Coldline, and Archive are more cost-effective for less frequently accessed data.
  • Cloud Storage lifecycle policies: Implement lifecycle policies to automatically transition objects to lower-cost storage classes or delete them based on age and access patterns.
  • Document AI: Document AI is priced based on the number of deployed processors and the number of pages that the Document AI processors parse. Consider the following strategies:
    • Processor optimization: Analyze workload patterns to determine the optimal number of Document AI processors to deploy, and avoid overprovisioning resources.
    • Page volume management: Preprocess documents to remove unnecessary pages or optimize resolution, which helps reduce processing costs.
  • Firestore: Firestore is priced based on document reads, writes, and deletes, index entries, database storage, and network bandwidth. Consider the following strategies:
    • Data modeling: Design your data model to minimize the number of index entries and optimize query patterns for efficiency.
    • Network bandwidth: Monitor and optimize network usage to avoid excess charges, and cache frequently accessed data.
  • Cloud Run: Cloud Run charges are calculated based on CPU usage, memory, and the number of requests. Allocate CPU and memory resources based on workload characteristics, and use autoscaling to adjust resources dynamically based on demand.
  • Agent Platform: Foundation models are charged based on input and output token counts. Optimize your prompts and response generation for token efficiency. When the prompt_model or ur_model model repeatedly references shared clinical guidelines or system instructions across requests, you can use context caching to reduce input token costs.
  • Agent Search: Agent Search charges depend on your query volume, indexed storage, and the advanced features that you enable, such as Enterprise edition features and generative responses. For predictable search workloads, you can also evaluate the subscription-based configurable pricing model, which lets you subscribe to storage and query capacity and selectively enable add-ons.

You can also apply the following general practices to help optimize costs:

  • Monitoring and alerts: Set up Cloud Monitoring and billing alerts to track costs and receive notifications when usage exceeds your thresholds.
  • Cost reports: Regularly review cost reports in the Google Cloud console to identify trends and optimize resource usage.
  • Committed use discounts: If you have predictable workloads, consider committing to resource usage for a specified period to receive discounted pricing.

For cost optimization principles and recommendations that are specific to AI and ML workloads, see AI and ML perspective: Cost optimization in the Well-Architected Framework.

Operational efficiency

This section describes design factors and best practices to help you evaluate, monitor, and operate your PA and UR automation workloads efficiently.

  • Generative AI model evaluation: When you refine prompt templates or evaluate new model versions for the prompt_model and ur_model models, use the Gen AI evaluation service in Agent Platform. Systematically measure response quality, groundedness, and adherence to clinical review criteria, by using the benchmark data in the eval_dataset bucket.
  • Document processor evaluation and retraining: To continuously evaluate and retrain your Document AI custom extractors, use the evaluation forms in the eval_forms bucket and the human-verified corrections from the hitl_app application.
  • Observability: To collect structured logs and track extraction confidence scores, model inference latency, error rates, and token consumption across the ingestion_service service and the applications, use Cloud Logging and Cloud Monitoring.

For operational excellence principles and recommendations that are specific to AI and ML workloads, see AI and ML perspective: Operational excellence in the Well-Architected Framework.

Performance optimization

This section describes design factors and recommendations to help you design a topology in Google Cloud that meets the performance and latency requirements of your workloads.

  • Cloud Run resource configuration: Configure CPU limits and memory limits for the ingestion_service service, the hitl_app application, and the ur_app application based on request concurrency and document payload sizes. To reduce cold-start latency for interactive clinical reviews in the hitl_app and ur_app applications, configure minimum instances and enable startup CPU boost.
  • Model inference latency: To reduce time-to-first-token when the ur_model model evaluates complex clinical cases against large policy contexts, use context caching and reserve capacity with Provisioned Throughput on Agent Platform.

For performance optimization principles and recommendations that are specific to AI and ML workloads, see AI and ML perspective: Performance optimization in the Well-Architected Framework.

Deployment

The reference implementation code for this architecture is available under open-source licensing. The architecture that this code implements is a prototype, and it might not include all the features and hardening that you need for a production deployment. To implement and expand this reference architecture so that it meets your requirements, contact Google Cloud Consulting.

The starter code for this reference architecture is available in the following Git repositories:

  • CDA git repository: This repository contains Terraform deployment scripts for infrastructure provisioning and application code deployment.
  • UR service git repository: This repository contains code samples for the UR service.

You can choose one of the following two options to implement support and services for this reference architecture:

What's next

Contributors

Author: Dharmesh Patel | Industry Solutions Architect, Healthcare

Other contributors:


  1. For more information about region-specific considerations, see Geography and regions.  ↩