Enterprise Level EDI 835 and EDI 837 Integration for Solution Provider
There is a saying that “a chain is only as strong as its weakest link” – and it applies to a constraint in X12 EDI data integration for this company that provides revenue recovery solutions to healthcare clients. Specifically, it can apply to parsers (home-grown and commercial) that are simply not scalable or up to the complexities of EDI 835 and EDI 837 data intake. In this use case, the Client’s advanced processes using data science tools, in-house experts and root-cause analysis got bogged down by a weak link – their EDI data intake.
The Client’s home-grown parser couldn’t handle ingesting millions of EDI 835 and EDI 837 transactions. Nor could their parser deal with the inherent X12 EDI data quality challenges. Discover how PilotFish’s enterprise integration engine solution’s built-in EDI features and performance-tuned parsing enabled the Client to recover revenue for their hospital clients. Plus, in a nice turn, they now could quickly realize more revenue themselves.
The Client, a leading provider of revenue recovery solutions, works with hospital systems to maximize reimbursements from the Centers for Medicare & Medicaid Services (CMS) and private payers. Their multi-pronged process starts with hands-on root-cause analysis coupled with a team of experts that leverage collective intelligence and data science tools. Related services, for underpayments, denials recovery and prevention support, round out their offerings for current and ongoing recoveries for their healthcare system clients.
The Affordable Care Act has brought about many changes that directly impact the ability of healthcare systems to capture revenue and receive the full value for services that they provide. One is the change in payer responsibility. Higher deductible plans have raised patient out-of-pocket expenses. By implementing more stringent rules, thus increasing denials, healthcare payers have made the collection process more difficult too.
The Client specializes in recovering revenue for hospital systems. Their process involves receiving massive amounts of data from hospital systems in both EDI 835 (Health Care Claim Payment and Remittance Advice) and EDI 837 (Health Care Claim) formats, which then need to be processed. These files can include one transaction in each EDI file or there may be millions of transactions in a single EDI file. Next, once the files are received, the data needs to be parsed. Once parsed, data analysis using the Client’s collective intelligence and data science tools that leverage unique algorithms and databases can be utilized. The Client had been relying on its home-grown parser to process the EDI 835 and EDI 837 files. Slow processing time was an issue. With a projected tenfold growth in data volumes over the next two years, processing speed and scalability were significant concerns.
Changes to what gets classified as a medical necessity and new authorization rules further add to the complexity of collecting from payers. The ever-changing rules for Government CMS reimbursements leave hospital systems struggling with handling revenue cycle management in-house as well. Receiving payment for services rendered from these groups has become increasingly difficult. Managing the revenue recovery process involves far greater complexity than hospitals have had to deal with in the past. Hospitals are increasingly turning to solution providers for help.
The Client’s senior management decided to invest in an enterprise integration engine solution. With that, they defined a list of requirements. The solution needed to be robust and scalable to meet peak demand and projected growth. It had to include strong support for working with not only EDI data but also a diverse set of other data formats. The ability to clone interfaces was also essential for speeding up the onboarding of new customers. It had had to include a parser to free the IT team up from time-consuming maintenance of their home-grown system. The parser had to be extremely accurate to support data analysis and efficient to deliver high-performance requirements. They also identified the need for operational tools that would provide visibility and transparency into their messages at every stage.
Armed with requirements, research on the web led the Client to PilotFish and its interface engine solutions. After browsing the site, watching product videos and taking advantage of the company’s free 90-day trial – the Client downloaded the eiConsole for X12 EDI trial and completed the recommended tutorials. They found the software very easy to use and intuitive to work with. Their positive experience was further reinforced by very favorable reviews of PilotFish elicited by their peers in the industry.
PilotFish’s product’s graphical Integrated Development Environment (IDE) makes the product well suited for evaluations and demonstrations. Viewers are presented with the eiConsole’s visual interface, which features a graphical automated interface assembly line where interfaces are created by stepping through and configuring 7 stages. Each stage offers configuration panels with common default settings to make the process easy, even for beginners. The integrated components that make up the product are all graphical. From configuring the routes to performing transformations and data mapping to end-to-end testing and deployment, all the functions can be performed within the same application, graphically. The product was architected to allow non-developers and business analysts to work alongside developers as well as take on responsibilities for large portions of interface management and maintenance.
After additional product evaluation, the Client engaged PilotFish in a series of deep dives via WebEx demonstrations. Representative interfaces, that closely followed the Client’s use cases, were stepped through in the eiConsole. Data transformation using the eiConsole’s proprietary 3-pane drag & drop data mapper was covered in detail. The Client’s requirements were extensively covered with a demonstration of how each would be accomplished in the various integrated components of the eiConsole. Performance metrics of EDI messages for standard hardware configuration were reviewed. Strategies for working with large files and improving performance were discussed. Working with databases and scenarios for taking an EDI message, converting it into a JSON format, placing it into a relational database and distributing it in tables were walked through in the product. These sessions were followed by a working session to focus on the product’s broad EDI support. Each EDI-specific feature was demonstrated and shown how it could be utilized within the eiConsole.
The session covered:
- Directly parsing any HIPAA EDI X12 transaction into XML
- Being able to review and map XML using the human-readable “Friendly Names” feature
- Browsing and searching the hierarchy of any X12 Message during data mapping
- Validating X12 messages during processing for structure and SNIP levels
- Producing ANY X12 Transaction from a corresponding XML representation
- Automatically converting all encountered compact-consistent code values to human-readable text
- Scaling to Interface large X12 transactions through parallelized batch processing
With their checklist of requirements marked off, the Client proceeded to license the PilotFish integration engine solution consisting of the:
- eiPlatform, the Integration Engine production server
- eiConsole for X12 EDI, the graphical IDE for configuring, managing and maintaining interfaces
- eiDashboard, a web-based application for operational reporting & management
To jump-start their implementations and more quickly realize revenue, the Client engaged PilotFish for consulting services for a 3-month Pilot with five customers. The Kick-Off meeting outlined the goals of the Pilot – to establish best practices and the correct methodology and architecture so that it could be scaled up to the enterprise. The Client also presented their requirements for the initial interfaces. These were reviewed in detail.
Based on these requirements, a single PilotFish Solutions Architect was able to prototype out interface templates. The Client’s team came on-site for the standard four-day formal training program. (These are conducted classroom style with product demos followed by exercises to reinforce skills learned.) The last day and half of the training focused on the Client’s use cases. The previously configured templates were used by the class to get hands-on experience working with the software on their actual interfaces.
Over three months, the PilotFish Solutions Architect working with two of the Client’s trained team members were able to complete the Pilot. By using an agile development process, the PilotFish Solutions Architect was able to make modifications as client requirements changed, as they often do.
The final workflow consisted of:
- The Client’s customers uploaded their EDI 835 and EDI 837 data via SFTP
- A third-party app was used to move the data and drop it into folders
- From there, PilotFish was utilized to poll these folders on a scheduled basis
- PilotFish queried their database with the file name and hash to ensure the file had not yet been processed
- PilotFish transformed their EDI messages into XML using our “EDI/XML Transformer”
- PilotFish queried for client identification based on identifying fields in the message
- PilotFish transformed the message to JSON (their canonical/common data model)
- Data was inserted into Mongo using our “Mongo DB Processor”
- PilotFish converted JSON to SQLXML
- Using Pilotfish’s Database SQL Transport, it was inserted into their database
PilotFish’s eiDashboard, its Web UI for operational insight, was also configured to provide monitoring, logging, auditing and reporting. The eiDashboard gives the Client visibility into the health of their interfaces, allows them to view any errors and drill down into them to investigate.
The pilot was so successful that it allowed the Client to move right into production. Throughout the process, PilotFish validated that its proprietary EDI parser surpassed the Client’s home-grown parser in terms of accuracy and performance with very high volumes. The product’s automated interface assembly line process allowed them to create a master interface template that could be cloned and tweaked to quickly implement and onboard new customers. The product’s flexibility and extensibility allowed the two teams to follow an agile development approach and make adjustments rapidly, as needed. After the pilot, the Client’s monthly support plan was activated. Over a few months, with PilotFish’s responsive team to support them, the Client was able to roll out interfaces and onboard their 80+ customers.
The benefits went beyond the speed and efficiency that PilotFish provided. The big winners in this automation process were the Client’s customers – the hospital systems. Now more than ever, with hospital systems burdened with COVID-19 impacting every area of their business, being able to capture more revenue and recover more fees will help keep them as viable entities. With PilotFish as their new enterprise solution and its team of engineers to support them, the Client was able to make a fast and successful transition. The PilotFish team and its future-proof integration engine solution are there to support them in whatever lies ahead.
Throughout 20 years and hundreds of implementations, PilotFish has developed and refined a methodology for the configuration, testing, and deployment of interfaces and process orchestrations resulting in an unparalleled track record of success.
Through years of Bake-Offs and Proof of Concepts (POCs), we have demonstrated the value of our integration engine solutions to future customers. Let us conduct a Free Use Case Evaluation for you to determine where PilotFish can provide the most value to your organization and solve your most complex integration challenges.