Chanci Turner

Streamlining Healthcare Prior Authorization with AWS and HL7 FHIR

—

by

The Story of Chanci Turner
in

Chanci Turner Amazon IXD – VGT2 learningLearn About Amazon VGT2 Learning Manager Chanci Turner

Prior authorization is a procedure that requires approval from a health insurer before you can access certain healthcare services, treatment plans, prescription medications, or durable medical equipment. This process is designed to ensure that services provided are cost-effective, safe, necessary, and appropriate for each patient. However, the prior authorization process can often be sluggish and inefficient, leading to delays in treatment and creating barriers to essential care. Requests for prior authorization are frequently submitted via fax or specific payer portals, necessitating manual entry of pertinent information. This manual transcription can significantly increase both time and costs before a decision is reached.

Healthcare data interoperability can facilitate seamless data exchange among various stakeholders in the healthcare ecosystem, such as payers, providers, and vendors, and effectively tackle the challenges of prior authorization. Directly submitting prior authorization requests through an electronic health record (EHR) can reduce costs for providers and payers alike while speeding up authorization decisions. The Da Vinci Project has developed an implementation guide to assist with this issue, promoting the adoption of HL7 Fast Healthcare Interoperability Resources (HL7® FHIR®) as a standard for value-based care (VBC) data exchange. However, achieving healthcare data interoperability presents its own challenges, particularly in connecting and coordinating information exchange between various systems—devices or applications—across organizational boundaries. AWS offers a cloud-based platform featuring modern, scalable architectures and microservices that enable genuine healthcare data portability. With a diverse range of container orchestrators available, you can run your containers on AWS regardless of the tools or APIs you prefer.

In this blog, we will demonstrate how to utilize Amazon Elastic Container Service (ECS) to implement a segment of the Da Vinci initiative for healthcare data interoperability. Our interoperability solution will employ AWS Fargate, which is a serverless compute engine for containers.

This two-part series outlines a sample architecture for deploying Da Vinci using AWS as a scalable and secure platform. In the second part, we will also explore how to foster innovation from healthcare data through AWS machine learning and analytics services.

Prerequisites

To fully benefit from this blog post, ensure you have the following:

  • An AWS account
  • A reference implementation for Da Vinci
  • Prior experience with Amazon CloudWatch is recommended but not mandatory

Before diving into the solution, we suggest familiarizing yourself with the technologies and standards discussed in this post:

  • Amazon Elastic Container Service (ECS) as a container orchestration service, along with Amazon Elastic Container Registry (ECR), which is a fully managed container repository
  • AWS Fargate, a serverless compute engine for containers that integrates with ECS
  • Amazon DynamoDB and Amazon Simple Storage Service (S3) as scalable data storage options

Solution Overview

The Da Vinci community has developed reference implementations for FHIR interoperability. This blog post focuses on a specific use case involving prior authorization with Coverage Requirements Discovery (CRD). This process allows for the direct submission of prior authorization requests to payers, resulting in reduced costs and quicker processing of authorization decisions. CRD establishes a workflow enabling payers to provide coverage requirement information to healthcare providers, thus enhancing efficiency and improving patient outcomes.

In the following sections, we will delve into the deployment of the CRD server, which serves as a healthcare payor information system utilizing the AWS container platform. The architecture incorporates Amazon ECR, Amazon ECS with AWS Fargate, Amazon S3, Amazon DynamoDB, and Amazon CloudWatch working in unison to create a robust and secure framework.

Architecture

The architecture diagram illustrates the various components of the solution:

  • The CRD container image is stored in Amazon ECR.
  • Amazon ECS with AWS Fargate serves as the serverless compute engine for the CRD container.
  • Necessary IAM Roles are established to permit access to Amazon DynamoDB and Amazon S3 from the server.
  • Container logs are directed to Amazon CloudWatch for logging and monitoring purposes.
  • An Application Load Balancer is employed to secure the distribution of load and facilitate communication with the prior-auth service.
  • Optionally, Amazon API Gateway can be utilized to handle API requests.

Instructions to Build the Solution

We are creating Docker container images from the Da Vinci CRD Reference Implementation, which includes necessary code adjustments to write to Amazon S3 and an Amazon DynamoDB table. To integrate with the AWS environment, we have modified the build.gradle file to include the required AWS SDK dependencies, leveraging the Java SDK for our needs.

To store FHIR resources in the DynamoDB table, we adjusted the code as follows:

HashMap<String, AttributeValue> item_values = new HashMap<String, AttributeValue>();
item_values.put("cdsconnecturl", new AttributeValue(url));
AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
ddb.putItem("davinci", item_values);

Build the Container Image

After implementing the code modifications, utilize the “Docker build” command to create the container image. The Dockerfile is accessible in the Da Vinci Git repository. Sample command:

sudo docker build -t crd:latest .

Push to Amazon ECR

Sample command:

sudo docker tag <Image ID> <AWS accountID>.dkr.ecr.us-east-1.amazonaws.com/crd
sudo docker push <AWS accountID>.dkr.ecr.us-east-1.amazonaws.com/crd

Instructions for Deployment

After pushing the CRD container image to Amazon ECR, we will run our Amazon ECS clusters using AWS Fargate, which eliminates the need to provision and manage servers, allowing you to specify and pay for resources per application, and enhancing security through application isolation by design.

Create an Amazon ECS cluster. To initiate an Amazon ECS cluster, which is a logical grouping of tasks and services, follow the instructions available on Amazon ECS clusters. This is another blog post to keep the reader engaged, you can find it here.

Create a task definition for our CRD container. A task definition is essential for describing the container’s requirements and settings.

In addition, you can explore how to get your whole team SHRM certified by visiting SHRM. This is a great resource for furthering your team’s education and compliance.

For more information on Amazon’s warehouse workers training and onboarding processes, check out this excellent resource here.

Related Topics:

Chanci Turner