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.
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.
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:
- The PA case managers receive the PA request forms (the
pa_formsforms) from the healthcare provider and upload them to thepa_forms_bktCloud Storage bucket. - The
ingestion_serviceservice listens to thepa_forms_bktbucket for changes. Theingestion_serviceservice picks up thepa_formsforms from thepa_forms_bktbucket. The service identifies the pre-configured Document AI processors, which are calledform_processors. These processors are defined to process thepa_formsforms. Theingestion_serviceservice extracts information from the forms by using theform_processorsprocessors. The data that's extracted from the forms is in JSON format. - The
ingestion_serviceservice writes the extracted information with field-level confidence scores into the Firestore database collection, which is called thepa_form_collectioncollection. - The
hitl_appapplication fetches the JSON information with confidence scores from thepa_form_collectioncollection. The application calculates the document-level confidence score from the field-level confidence scores that theform_processorsmachine learning (ML) models provide in the output. - The
hitl_appapplication 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 thepa_form_collectioncollection.
UR service flow of data
The following diagram shows the flow of data for the UR service.
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:
- The
ur_appapplication displays a list of PA requests and their review status to the UR specialists. The status shows asin_queue,in_progress, orcompleted. - The application creates the list from the
pa_form informationdata in thepa_form_collectioncollection. The UR specialist opens a request when they click an item from the list in theur_appapplication. The
ur_appapplication submits thepa_form informationdata to theprompt_modelmodel. 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}.The
ur_appapplication 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.The
ur_appapplication sends the prompt to theur_modelmodel 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.The UR specialists can use the
ur_search_appapplication to search for theclinical documentsfiles, thecare guidelinesdocuments, and theplan policy documentsfiles. These documents are pre-indexed and accessible to theur_search_appapplication.
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_processorsprocessors: Document AI processors that are trained to extract information from thepa_formsforms.The
pa_form_collectioncollection: A Firestore datastore that stores the extracted information as JSON documents in a NoSQL database collection.The
ingestion_serviceservice: 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_appapplication: A microservice web application that fetches and displays data values that are extracted from thepa_formsforms. 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_appapplication: 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 thepa_formsforms to theprompt_modelmodel to generate a prompt. It then passes the generated prompt to theur_modelmodel 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 thepa_formsforms.ur_model: A tuned LLM adapter that generates a draft recommendation based on the input prompt.
The
ur_search_appapplication: 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_modelandur_modelmodels 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_serviceservice, thehitl_appapplication, and theur_appapplication 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_modelorur_modelmodel 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_modelandur_modelmodels, 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 theeval_datasetbucket. - Document processor evaluation and retraining: To continuously evaluate
and retrain your Document AI
custom extractors, use the evaluation forms
in the
eval_formsbucket and the human-verified corrections from thehitl_appapplication. - Observability: To collect structured logs and track extraction
confidence scores, model inference latency, error rates, and token
consumption across the
ingestion_serviceservice 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_serviceservice, thehitl_appapplication, and theur_appapplication based on request concurrency and document payload sizes. To reduce cold-start latency for interactive clinical reviews in thehitl_appandur_appapplications, configure minimum instances and enable startup CPU boost. - Model inference latency: To reduce time-to-first-token when the
ur_modelmodel 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:
- Engage Google Cloud Consulting.
- Engage a partner who has built a packaged offering by using the products and solution components that this architecture describes.
What's next
- RAG infrastructure for generative AI using Agent Platform and Vector Search
- RAG infrastructure for generative AI using Agent Platform and AlloyDB for PostgreSQL
- RAG infrastructure for generative AI using GKE and Cloud SQL
- RAG infrastructure for generative AI using Gemini Enterprise and Agent Platform
- GraphRAG infrastructure for generative AI using Agent Platform and Spanner Graph
- Google Cloud options for grounding generative AI responses
- Optimize Python applications for Cloud Run
- For an overview of architectural principles and recommendations that are specific to AI and ML workloads in Google Cloud, see the AI and ML perspective in the Well-Architected Framework.
- For more reference architectures, diagrams, and best practices, explore the Cloud Architecture Center.
Contributors
Author: Dharmesh Patel | Industry Solutions Architect, Healthcare
Other contributors:
- Ben Swenka | Key Enterprise Architect
- Emily Qiao | AI/ML Customer Engineer
- Luis Urena | Developer Relations Engineer
- Praney Mittal | Group Product Manager
- Lakshmanan Sethu | Technical Account Manager
-
For more information about region-specific considerations, see Geography and regions. ↩