Skip to main content

How HealthEdge® Drives Product Innovation by Focusing on Quality Assurance

HealthEdge® is driving digital transformation by streamlining automation and delivering real-time business and clinical insights that impact payers, providers, and patients. These innovations empower health plan leaders to stay on top of constantly shifting industry regulations and consumer expectations.

As a next-generation SaaS company, HealthEdge provides an integrated ecosystem of advanced solutions for core administration (HealthRules® Payer), payment integrity (Source), digital care management (GuidingCare®) and member experience (Wellframe). Our solutions enable health plans to leverage new business models, reduce costs, and improve clinical outcomes across member populations.

We firmly believe that maintaining product quality is a collective effort that extends beyond our quality engineers (QEs). HealthEdge’s Customer Satisfaction (CSAT) survey helps us measure the quality of the products we deliver to our customers and how that affects their satisfaction. Used across industries as a key performance metric, CSAT score is based on a survey that asks customers how likely they are to recommend a product or service.

A culture of continuous improvement

Our approach to product development and innovation centers on delivering a high-quality digital solution that makes it easier for our customers to achieve their business goals. As an organization, HealthEdge is committed to continuous improvement, establishing quality standards and training to ensure consistent understanding and application of quality standards across the company.

The Quality Center of Excellence (QCoE) instills a culture of quality across scrum teams by adhering to industry standard testing practices and tooling. Some of the factors in this process include:

     - Automation-first approach to product development and innovation

     - Rigorous testing and quality checks

     - Proactive issue identification

     - Software development and feature planning

     - Continuous Integration and Delivery

Automation-first approach to product development and innovation

HealthEdge utilizes an automation-first approach.

     - Product developers ensure unit and integration testing is in place before code is merged (Test Driven Development).

     - Quality engineers extend and create automated tests in close coordination with developers to ensure complete test coverage.

A robust automation suite ensures all functionality is automatically tested. This further allows additional manual testing efforts to focus on corner cases, sanity testing, and the user experience.

Rigorous testing and quality checks

HealthEdge products must pass several quality checks—including build, unit, integration, database verification, production transaction test (PTT), system integration test (SIT), static code analysis and performance testing—before reaching any customer environments.

Builds are triggered automatically for feature branches. Targeted tests including unit, integration, and static code analysis are run before any code is merged. This triggers more complete and extensive sets of tests in downstream jobs. Multiple jobs, including Commit, DB verification and migration, Integration, PTT, SIT jobs, are run as part of continuous integration.

Once these jobs are successful, the distributions are made available to the Cloud Operations (Cloud Ops) team and for self-hosted customers as needed. Cloud Ops and Customer Service Managers (CSMs) work with clients to schedule and deploy releases into SaaS (Software as a Service) lower environments where Post Deployment Verification (PDV) and Functional tests are run. Once all PDV and Functional tests are completed in one-to-many lower SaaS environments and in conjunction with testing from customers QA team, deployment is made to production and final sanity checks are performed. 

Proactive issue identification

The HealthEdge testing methodology is centered around proactively identifying issues, conducting thorough and detailed testing, bridging the gap between our team and customers, and consistently delivering the highest quality possible.

This structured approach aligns with industry standards, defining the precise automation of tests and their optimal execution environments. It serves to foster collaboration and understanding across the HealthEdge organization, emphasizing a commitment to comprehensive excellence and quality delivery.

The specific definitions are as follows:

Unit Testing:

     - Validate individual components in isolation.

     - Ensure each unit functions correctly according to specifications.

Integration Testing:

     - Assess the interaction and collaboration between different components.

     - Identify and address issues related to the integration of modules.

Functional Acceptance Testing:

     - Verify broader functionalities of the system.

     - Confirm that features work as intended from an end-user perspective.

System Testing:

     - Examine the installation and verification of End-to-End system.

     - Upgrade time Quality Gate:

     - Identify database migration changes that cause long delays in the OLTP upgrade earlier and move the long-running scripts into either pre-migration or post-migration upgrade steps.

     - Detect and resolve any database migration errors discovered during upgrade testing.

Quality Criteria:

     - Quality criteria ensure Functional Readiness, Interoperability & Compatibility, Serviceability, Performance & Scalability are validated for every release.

UAT/Prod like Testing:

     - Creates a test environment that closely matches production for various customers.

     - Batch and UI Transactions are measured from version to version to detect any performance degradation.

     - PTT claims adjudication results are also compared against known results and detect any differences within a customer-like environment.

     - System Integration Testing on selected customer-like environments.

     - Specific feature testing on customer data.

Software development and feature planning

HealthEdge understands that quality is a driving force for software vendor selection. That’s why it is an integral consideration at every step of the software development lifecycle (SDLC). The following diagram highlights how we put this into practice—from feature planning through release.

Feature prioritization and planning

New features undergo a prioritization process, led by the product owner, before they are introduced for discussion within the scrum team. The product owner evaluates features based on their business value and the specific customer problems they address. Subsequently, the planning team engages in discussions to further refine the required functionality. As the requirements become better understood, the team then makes an estimation of how many story points this feature will take to complete .

Together, the team covers the following:

     - Acceptance criteria

     - Design Considerations

     - Product Integrations

     - Functional and non-functional testing (ex. performance & security)

     - Story Point Estimation

     - Documentation

Bug prioritization and planning

Bugs undergo a prioritization process, led by the product owner, before they are introduced for discussion within the scrum team. The bug fixing process allows issues to be scheduled and fixed on a predictable schedule.

Sprint planning

At HealthEdge we follow industry-standard, best agile practices, with sprint planning being an essential component. During sprint planning, features and bugs that are ready to be developed are added to the scrum board. The team then sets the assignments based on their historical completion rate (velocity).


Feature Tickets:

     - Features are discussed, broken down and tasks are created per assignee.

Bug Fixes:

     - Bugs are discussed, broken down and tasks are created per assignee.

Testing only tickets:

     - Where needed, performance and automation related stories are created and assigned to appropriate resources.

Feature test driven development

HealthEdge practices test driven development, where tests are written before the feature is coded. Subsequently, the code is written until the test passes. When the developer believes their feature is complete, a subset of tests is run to provide fast feedback and, if these tests pass, the code is merged automatically for downstream testing.

Feature Grooming:

    - Technical grooming sessions are conducted after business grooming is complete. This is a review of functional and technical aspects of the tickets in the backlog to verify they are complete and ready for development.

Feature Development:

    - Development team starts the design and architecture from the acceptance criteria listed by Product Owners in the ticket.

Writing Unit & Integration Tests:

    - Tests are written to validate key acceptance criteria for the feature.

Code Review:

    - Once the above steps are complete, the code review will be done by subject matter experts (SMEs) to check that all standards and code coverage are followed.

Quality Assurance testing

Quality Engineers (QEs) write end-to-end tests and review them with the SMEs and Product Owners before execution. During execution, functional, regression, and impacted areas are covered as part of the testing. Additionally, QEs test specific tickets and features in customer-like environments when possible

Research quality knowledge base:

     - QEs investigate the internal quality knowledge base for existing functionality before preparing the test plan document.

Test cases writing and review:

    - QEs start writing the test cases based on acceptance criteria listed in the ticket. The test cases are reviewed with Product Owners and Development Leads. In some cases, test cases will also be reviewed with the client.

Test environment setup:

    - QEs set the test environment to the feature branch to test the above-mentioned test cases.

Functional verification:

     - During this phase, functional verification of test cases is completed, and any unexpected results will be raised.

Writing integration tests:

    - QEs contribute towards writing integrations test along with development team.

Automation tests:

    - QEs write automation scripts for all regression test scenarios.

Customer data testing:

    - QEs do a final round of testing in the customer–like environment to make sure the features work without any issues.

Bug bash:

    - Collaborative testing event on critical features that brings together QEs, Developers, Product Owners to “bash the product” to expose bugs.

Functional demonstration:

    - When the ticket is ready, a functional demo is given to internal stakeholders to make sure the acceptance criteria is covered.

Customer demonstration:

    - Demonstrations are also given to customers to further confirm expected requirements are met.

Root Cause Analysis (RCA):

    - Every bug ticket goes through an RCA before it can be closed. The scrum team conducts a retrospective to determine what process was missed and how we can prevent this issue from happening again.  

Continuous Integration and Delivery

Continuous Integration

At HealthEdge, we use a continuous integration workflow to ensure we create and test high-quality products quickly, securely, and efficiently. This workflow allows us to implement quality and security checks for every check-in. For quality checks, we run tests to provide rapid feedback. If there are test failures, developers are blocked from checking in additional changes until tests are passing again. For security checks, we leverage static code analysis and report any security vulnerabilities.

Types of Tests

Unit Tests: 

    - Tests that focus on validating a very specific piece of code. 

Integration Tests: 

    - A comprehensive suite of product regression tests.  

Database Verification Tests: 

    - Tests that verify new database schemas match upgraded database schemas. 

Production Transaction Tests: 

    - Production Transaction Tests use customer data and configuration to do A/B testing from one version to another and report any claim adjudication differences. 

System Integration Tests: 

    - System Integration Tests use customer data for specific test scenarios. 

Static Code Tests: 

    - Automated tools are used to identify code coverage, code violations, bug leakage, duplication on code, code smells, and vulnerabilities. 

End To End Tests (E2E): 

    - During System Testing, multiple products are installed together, and roundtrip tests are executed to confirm end to end processing. 

Database Migration Tests: 

    - Specific versions are selected based on expected paths a customer will take to ensure that the database migration scripts are successful. 

Performance Tests: 

    - A dedicated, production-grade system where key metrics are measured and compared from version to version to ensure that performance has either improved or not degraded. 

Release Readiness

For every product release, HealthEdge Quality team follows a stringent Quality Criteria which comprises of below checks followed by a Go/No-Go meeting before giving a release sign off.

    - Functional Readiness

    - Interoperability & Compatibility

    - Serviceability

    - Performance & Scalability

    - Stabilization Period Evaluation

    - System Integration Testing (SIT)

    - Data Migration Testing

    - Real World Data Testing – Production Transaction Testing (PTT)

    - Testing Improvements

Continuous Delivery

HealthEdge follows Continuous Delivery practices to deliver fully tested releases ready for customer environments through a general availability (GA) or a release candidate (RC) program. GA releases are available to all customers. The Release Candidate (RC) program allows participating customers to test features and provide feedback within a defined 4-week window prior to GA.

Deployments in SaaS environments are scheduled into customers’ lower environments first and then, upon successful acceptance testing, releases are deployed into production. Post Deployment Verification (PDV) checks, User Acceptance Tests (UATs) and Functional Tests provide the necessary quality checks for each environment before code is promoted to the next environment. HealthEdge Customer Service Managers (CSM) and Cloud Operations (Cloud Ops) members work closely with clients and follow specific protocols for each deployment to ensure there is no negative impact to the customer experience.

Production monitoring

At HealthEdge, the Incident Management team uses AppDynamics to monitor hosted customers, and proactively views and escalates issues affecting performance. This allows us to maintain system availability, enhance the user experience, and resolve issues as soon as possible. Monitors are set up to continuously check metrics and alert the Incident Management team when critical shifts occur, allowing them to act quickly to resolve the issues.

In Summary

We truly believe that simplification and standardization have biggest impact on Quality. The above-mentioned practices lay a sturdy groundwork for our quality program. QCoE team ensures stringent quality criteria is met for releases and monitors Objectives and Key Results (OKRs) to gauge whether quality is trending in the right direction.

Authors: David Price, David Tauer, Karthikeyan Thirugnanam, Nischal Kondareddy, Rahul Jain, Sanchit Chavan