- /
- ... /
- GoodShape
Modernization & Quality Engineering for an Employee Wellness Platform
A long-term technology partnership supporting a UK workforce well-being leader in modernizing its platform, rebuilding architecture, and embedding QA directly into delivery.
client
GoodShape
cooperation
Since 2018
country
UK
industry
Healthcare / Workforce well-being
product
Enterprise employee wellness platform
About the platform
GoodShape is an employee wellness platform used by 200+ large UK employers. It offers absence management, clinical support, workforce analytics, and health data integration to simplify employee care and enable data-driven HR decisions.
Team
7
Engineers (Backend, Frontend, QA)
Tech stack
Front-end
React
Redux
Redux-Saga
AG Grid
react-jsonschema-form
Back-end
Java 17
Spring Boot
Spring Security
Spring Data
Spring AOP
Hibernate
Microsoft SQL Server
RabbitMQ
Keycloak
AWS SQS
JUnit
Mockito
Microservices
Git
Ant Design
Maven
Jenkins
Docker
Ansible
QA
Jira
Confluence
BrowserStack
Python
JavaScript
Robot Framework
Bitbucket
Behave Framework
Allure
Docker
Jenkins
Selene
Objectives
The client engaged us to:
- Modernize the platform architecture for continuous evolution.
- Improve reliability and resilience for enterprise clients.
- Enable safe, regular feature releases without service disruption.
- Align QA and development into a single workflow.
- Reduce operational overhead through automation.
The goal was clear: modernize the architecture, improve resilience, and enable continuous platform evolution, without disrupting active clients.
Backend engineering stream
Challenges
- Monolithic architecture with tightly coupled modules.
- No consistent coding standards across modules.
- Minimal documentation and architectural ownership.
- Business logic spread across layers.
- Obsolete libraries blocking upgrades.
- High regression risk when touching core functionality.
Backend engineering strategy
Backend work was structured around four principles:
- Stabilize before scaling.
- Decouple before extending.
- Automate for accelerating.
- Document for safer and faster expansion.
Our approach
Step 1
Architecture modernization & microservices adoption
We gradually transitioned the platform from a monolith toward a microservices-based architecture.
- Identified module boundaries suitable for extraction.
- Designed microservices around clear business capabilities.
- Introduced Java 17 and the modern Spring Boot stack.
- Implemented Spring Security with Keycloak for centralized auth.
- Introduced asynchronous communication via RabbitMQ and AWS SQS.
Step 2
Codebase refactoring & technical debt reduction
Before adding features, we reduced structural risk.
- Ran static code analysis across the entire codebase.
- Identified and eliminated thousands of code smells.
- Standardized naming, structure, and error handling.
- Refactored high-risk modules first (core flows, integrations).
Step 3
Engineering governance & documentation discipline
One of the biggest risks was knowledge loss.
- Introduced mandatory technical design documentation for large features.
- Established architecture discussions before implementation.
- Documented service responsibilities and data contracts.
- Standardized development practices across contributors.
Step 4
Adding new features and capabilities
Once the architecture was modernized and the codebase was refactored, our team started to work on new functionalities that would deliver value to the business and users. Key implementations:
Automated reporting engine
- Replaced manual creation of 50-slide PowerPoint reports.
- Eliminated repetitive human effort.
- Improved reporting consistency and delivery speed.
Push notification microservice
- Isolated communication logic.
- Enabled scalable, reliable message delivery.
Fitness tracker data aggregation service
- Centralized ingestion of health data.
- Enabled advanced analytics.
- Scaled to support 16 fitness tracker brands.
Backend engineering outcomes
- Platform scalability optimized.
- Architecture prepared for long-term evolution.
- Faster and safer feature delivery.
- Reduced operational and maintenance overhead.
- Stronger foundation for frontend modernization.
Frontend engineering stream
Challenges
- Outdated React ecosystem and libraries.
- Tight coupling between UI and business logic.
- Complex analytics views with performance bottlenecks.
- Heavy reliance on modal windows for data editing.
- A “facade” pattern complicating frontend–backend interaction.
- Increasing effort required to add or modify features.
Frontend engineering strategy
The strategy was based on four principles:
- Decouple before redesign.
- Stabilize data flows before polishing UI.
- Optimize performance where it affects user experience most.
- Refactor in parallel with QA coverage.
Our approach
Step 1
Frontend modernization and restructuring
The first step was addressing structural issues.
- Updated core React libraries to modern standards.
- Broke the frontend into smaller, logical subprojects.
- Separated business logic from presentation layers.
- Replaced the hard-to-maintain “facade” pattern for backend and frontend interaction with “inline-editing”.
Step 2
Performance & data handling optimization
Given the analytics-heavy nature of the platform, performance was critical.
- Optimized rendering for large datasets.
- Improved AG Grid integration for complex tables.
- Reduced unnecessary re-renders.
- Stabilized state management using Redux and Redux-Saga.
Step 3
UX & interaction model redesign
UX improvements were driven by business workflows, not visual trends.
- Replaced modal-based editing with inline-editing.
- Introduced multi-step forms using react-jsonschema-form.
- Improved consistency across complex workflows.
- Reduced context switching for users.
Step 4
Frontend governance & collaboration
The frontend engineer played an active role beyond implementation.
- Participated in architectural discussions.
- Proposed project modularization strategies.
- Helped define a clearer frontend structure.
- Closedly collaborated with backend and QA teams.
Frontend engineering outcomes
- Redesigned website.
- Modern tech stack.
- Optimized data processing.
- Faster implementation of new features.
- Stronger foundation for UI test automation.
Quality engineering stream
Challenges
- Backend automated tests were outdated.
- UI tests weren't automated at all.
- Regression testing depended heavily on manual effort.
- Feedback loops were rather slow.
- High probability of regressions when touching core flows.
- Quality validation was executed late in the delivery cycle.
QA engineering strategy
The QA stream directly reinforced engineering outcomes. Quality engineering was guided by four core principles:
- Update existing test suites.
- Expand automation where relevant.
- Integrate testing into the CI/CD pipeline to shorten feedback loops.
- Build confidence, not just test volume.
Our approach
Step 1
Test foundation stabilization
Before scaling automation, we focused on updating available scripts.
- Audited existing backend automated tests.
- Refactored unstable and flaky test scripts.
- Updated outdated Python environment and frameworks.
- Aligned tests with current application behavior.
- Removed false positives that reduced trust in test results.
Step 2
API-first automation strategy
To reduce regression time and increase coverage depth, we shifted focus toward API testing.
- Expanded automated API test coverage across core services.
- Validated business logic independently from UI changes.
- Reduced dependency on slow UI-based regression checks.
- Enabled faster detection of functional regressions.
Step 3
Frontend automation introduced from scratch
Frontend quality required a clean start.
- Designed frontend automation solution from zero.
- Automated UI tests aligned with real user workflows.
- Integrated frontend automation into CI/CD pipelines.
- Ensured consistent test execution across environments.
- Avoided brittle locator strategies to reduce maintenance overhead.
Step 4
CI/CD integration & execution optimization
Automation was embedded directly into delivery pipelines.
- Jenkins-based execution with Dockerized test environments.
- Parallel test execution across 15 threads.
- Dedicated smoke test suite for production confidence.
- Clear separation between smoke, regression, and extended suites.
- Testing shifted from a release-phase activity to continuous validation.
QA engineering outcomes
- ~3,800 automated test scripts implemented.
- 90% of test cases automated.
- ~95% regression coverage across critical flows.
- ~99% of smoke tests automated.
- Regression execution time reduced by 2–3x.
- ~95% reduction in post-release defects.
- Autotests aligned with the major Python update.
Business outcomes
Faster releases with lower risk
Automation enabled:
- Threefold acceleration of testing cycles.
- Predictable releases.
- Reduced regression bottlenecks.
Massive reduction in production defects
Post-release regression bugs decreased by ~95%.
Scalable architecture for growth
Microservices + automated QA enabled:
- Continuous feature expansion.
- Integration of new fitness devices.
- Stable support for 200+ enterprise clients.
Operational efficiency gains
- Automated reporting replaced manual PowerPoint workflows.
- Reduced manual QA and HR administrative workload.
- Engineering focus shifted to innovation rather than maintenance.
Client
success
GoodShape continues to lead its niche in workforce health solutions. Its platform is used by hundreds of large UK-based organizations with 2,000+ employees, including NHS, Philips, and Heathrow Express.
In 2020, GoodShape won GOLD at the ECCCSA Awards in the Most Effective Application of Technology category, outperforming major competitors, including Microsoft, which received Silver.
We’re proud to support GoodShape’s continued growth and to contribute to the ongoing evolution of its platform.
Facing similar challenges to GoodShape?
