Most healthcare applications need to interface with external systems. Since the interfaces that bridge software applications are complex, standards have been developed to simplify the process. Implementing code that adheres to standards requires a lot of time, and is often a source of overruns and rework. It is crucial to ensure the design and implementation of interoperability standards is carefully planned and estimated.
In healthcare, there are a broad range of standards for coding, formatting, and exchanging patient data. For example, electronic health records (EHR) alone use the following array of standards: HL7 v2.x, 3, X12 4010, 5010, CCR, CCD, ICD9/10, SNOMED, RxNorm, UNII, UCUM, NCPDP script 10.x, and CVX.
Consider a situation where a patient visits a hypertension clinic that records medications in RxNorm format, records active diagnoses in ICD10, and produces a CCD record from the visit. The document is then transferred via HL7 interface to the patient’s family doctor and to the hospital’s EHR system. Different systems interoperate using different standards, so applications often need to support many different standards. An EHR may need to exchange data with a patient registry that expects patients’ records in CCR format, a physicians’ portal that expects a CCD format, and a billing system that has its own custom format. What’s more, those standards are continually changing and evolving.
The first step towards ensuring that interoperability standards code is well planned and well estimated is to account for all the possible tasks that will be required of the software team during implementation.
These can include:
- Design planning to ensure that past, current, and future versions of each standard are supported.
- Documenting test cases for a full range of possibilities.
- Design handling of no-match cases so that these can be identified and fixed (if a received ICD-10 code does not match any real code, for example).
- Writing unit tests to ensure continued compliance with standards.
- Mocking remote end incoming messages and responses.
- Implementing logging of all exchanged data.
- Handling message replay needs in case of error.
- Spending time with the remote endpoints to conduct end-to- end testing.
A thorough, granular task breakdown and estimate helps to avoid the risk of rework as the software evolves. Without an automated mechanism to test the code, and separation from other parts of the application, maintaining compliance with the standard can quickly become unmanageable. Code regressions and quality assurance testing will ensure standard compliant interfaces work.
The best software teams make sure the program code is properly encapsulated and create automated unit tests so that the code that deals with the standard can remain in place until the next version of the standard is released. This also ensures unrelated features that are added to the software over time do not introduce regressions in the standards-specific code.
Interoperability is one of the biggest challenges in healthcare IT today. A plethora of standards have emerged to address this issue, but there are challenges in implementing and managing the code that implements these standards. By understanding the full range of implementation tasks, designing for encapsulation, and developing automated unit tests, you can avoid cost overruns upfront and over the course of the software lifecycle.
Download The Complete Guide to Engaging Digital Health Software