Benefit Rules Translator
Our large health insurance client initiated a 5 year program of business process re-engineering to change the entire way they specified coverage rules, provisioned benefits, and processed claims. The vision was to create a single “Source of Truth” repository of benefit policy information and business rules that could be used by various internal systems and by some external systems managed by their business partners.
One of the key long-term goals of this project was to migrate claims processing from a set of disparate regional systems to a single national claims processing system.
However, the code used by the claims system was entirely coded manually by specially trained developers. New benefit policy or simple changes often required several months of code development and testing before they could be moved to production. This process was costly and inefficient. Manually coding would sometimes result in subtle errors that could not easily be detected, meaning the company might pay claims incorrectly for long periods of time. The company decided that the best way to solve this problem would be to “translate” the repository of benefit information into the claims claims code in an automated way, such that the manual coding could eventually be eliminated with the time to production and probability of human errors reduced.
Jonah was asked to build a translator component that would transform the approved business rules held in the new benefit policy repository database into the machine code that is used by the claims system to process claims. The code would need to be run as an overnight batch process.
The primary challenge associated with this project was its complexity, for several reasons:
- Jonah was required to completely understand the code structures used by the claims system and how they relate to benefit policy in order to create accurate translations of benefit data.
- The translator needed to be optimized such that the claims code output was well structured and efficient.
- The translator had to be coded with an emphasis on performance. The translation of a large amount of benefit information was very system resource intensive, and the translation time window available overnight was limited.
- Extensive and very time consuming testing was required to ensure the code was error free.
The project carried significant risk in that any errors in translation would have a direct financial impact on the client by resulting in incorrect claims payment.
Jonah provided the following team of professionals to design and build the system:
- 1 Project Manager
- 3 Senior Technical Architects
- 1 Database Administrator
- 10 Software Developers
- 1 Quality Assurance Specialist
Our responsibilities on the project were as follows:
- Project planning and timeline estimation
- Requirements elicitation and documentation
- Technical Architecture / Design for all features and functions
- Participation in UI design discussions, creation of mockups
- n-tier enterprise software development using leading-edge technologies
- Quality Assurance
- Assist integration with the wider business systems and activities
- Ongoing Communication with our client's Technical Delivery Manager, Lead Architect, Lead DBA, Project Manager, Business Leads, and Developers.
The following technologies were used on the project:
- Spring MVC
- DOM2J / J2DOM, MSXML
- XML / XML Schema
- Session Beans
- Java / J2EE
- Websphere Application Server
- Oracle 10g
The solution is comprised of two components:
- the Translator and an associated batch framework which performs the data transformation and transfer of benefit information held in the benefit data repository
- A web-based application called NATE which is used to manage the Translation processes.
The Translator ‘translates” all the approved benefit business logic contained within the benefits policy repository database into the machine code required by the system to process incoming medical insurance claims. The translated data is then automatically transferred to the claims system for loading and testing. Results of the data load from the claims system are fed back to the translator. The feedback is used to update the internal state of the benefit business data so that only benefits successfully loaded to the claims system are used by the client’s business groups to provide customer information and support. Other key features of the application include:
- A batch processing framework and sequential dependency among multiple translation stages and steps
- An automated real-time benefit data translation engine
- An integrated benefit data change event logging and handling mechanism
- A benefit data inheritance calculation engine
- Event driven calculation and persistence of package level benefit set
- Batch-time translation and assembly of feed files of various claims system constructs
- FTP file transfer and file polling framework (i.e. the communication component between Translator and the claims system)
- Various persisted data snapshots to reflect the claims system's various promotion stages
A web-based application called NATE (NASCO Automated Translation Engine) was created to manage the translation process. The application displays all the required translation steps and how a particular translation run is progressing through those steps. Users can also manually initiate and cancel translation runs, set global translation parameters, manage alert e-mails, transfer code files, and manually edit claims code using the application.
The translator has been deployed to the production environment, and enhancements are continuing on an ongoing basis. Due to the innovative nature of the solution, a patent on the Translator was filed by our client in 2008.
The Translator will largely eliminate the need for manual coding of claims processing logic, which was originally done manually by specialized coders who required years of training.
By replacing these time-consuming coding processes, the Translator will reduce the time and cost required to implement new benefit policy in the claims processing system. For an average sized benefit package, it takes an experienced benefit file coder 30-50 days to code manually before any testing can begin. This is one of the reasons why the client normally has a delay of at least 90 days from the day a customer contract is signed to the day when a claim can be processed. The Translator component shortens such a delay to approximately 2 weeks, including testing.
As a secondary benefit, parallel testing of the old and new claims code has demonstrated that the Translator will also improve the accuracy of claims processing in terms of its alignment with actual insurance policy business logic.
This could have not been accomplished without your hard work and dedication. I still think this is the best team I have ever managed or worked with. Congratulations to you all!
- Dennis Nunnold
Application Design - Manager, Systems Development Services