TLDR
- Imprivata's tests ran from three places: GitHub Actions, Azure DevOps and virtual machines teams had built themselves. Testkube is becoming the one place they run from; the DevOps team estimates about 70 percent of the old tooling is moving into it.
- Most of the platform's business logic sits in internal services that cannot be reached from outside the cluster. They used to be tested only through the public-facing services. Now they are tested directly, inside the cluster, in development, integration and staging.
- Each service carries its own tests, written in the same pull request as the code and run automatically after each deployment, with the result in Slack minutes later. Developers own the first layer of quality; QE moved to edge cases and end-to-end work.
- Per-service load tests, which had never worked, are being built through Testkube ahead of a large customer rollout.
- Next: Argo Rollouts with Testkube quality gates, so a single service is tested before it takes production traffic, replacing releases of 10 to 15 services at once.
About Imprivata
Imprivata makes identity and access management software for healthcare, including how clinicians sign in to clinical systems and how patients are identified. HIPAA and other healthcare regulations apply to everything it ships. Its cloud products run on a shared multi-tenant platform on Kubernetes in Amazon EKS, made up of dozens of microservices and deployed with Argo CD across development, integration, staging and production. A DevOps team of about ten supports the platform, with QE teams attached to each product.
The problem
As the platform grew, testing spread out. Some tests ran from GitHub Actions, some from Azure DevOps, some from virtual machines teams had set up themselves. Each had its own way of starting a run and reporting a result. For the DevOps team, which also has to answer the question "is this environment healthy?" whenever someone reports a problem, there wasn't a single place to look.
The harder problem was where tests could run from. Imprivata's platform has a layer of public-facing services that the user interfaces call, and behind them a larger set of internal services that hold most of the business logic. Those internal services are not exposed to the internet. In development and integration the team could open them up enough to test them. In staging and production it could not, so the only way to test an internal service was to call a public one and hope the request reached all the way down.
That outside-in approach caught the failures a customer would notice, but it missed the smaller ones inside. And when a test did fail, the cause was hard to find: a single public call might have touched four or five internal services, and working out which one had broken meant an investigation in Dynatrace, the observability tool.
Running tests after a deployment took several steps. Argo CD posted to Slack, a separate process polled Slack every few minutes, and that process started tests in GitHub Actions. It was reliable enough, but the trigger did not always fire, and when it did, it was not always right after the deployment.
A second delay sat in front of all of this: QE wrote test automation after a feature was deployed, so a new feature often had no automated tests for hours or days, and sometimes none at all.
Discovering Testkube
Testkube came in through the DevOps team, which keeps an eye on new tools and set up a trial to see how hard this one was to deploy and run. The deciding check was whether existing tests would work: the QE team ran some of their automated tests through Testkube, with DevOps helping on setup, and they did. Since Testkube runs anything packaged as a container or a script, the Python, .NET and Java tests the teams already had were a fit.
The case to DevOps leadership was that one tool could orchestrate any test framework the teams already used, in the cluster, instead of several tools in several places. The bigger risk was time rather than technology: QE engineers were stretched, and for a while the evaluation looked like it might stall for lack of people to verify it.
Tests that ship with the service and run inside the cluster
The platform and QE teams designed a five-step process that every onboarded service now follows. The same steps run in development, integration and staging.
- Code and tests in one pull request. A developer changes a service and updates its tests in the same repository and pull request.
- Built together. The service and its tests are each built as a container image, tagged with the same version.
- Deployed by Argo CD.
- Tests run inside the cluster. A Testkube trigger notices the new version, waits until the service is ready, and runs that service's tests against it from inside the cluster, where the internal services are reachable.
- Result to Slack. If the tests pass, the developer moves the change to the next environment.
Because the tests run inside the cluster, they reach the internal services directly. There are no hops through a public service, so a failure points at the service whose tests failed, and the developer can see straight away whether the change is green.
Running the same process in each environment removed a familiar problem: something that worked in a lower environment but not in a higher one. Tests are written, run and reported the same way from development through staging, which standardized testing across the platform and made the results easier for developers to trust.
Two decisions made it easy for teams to join:
- Tests belong to the service: the QE team split one large shared test project into a small set of tests per service, built at the same version as the service, so the matching tests run with each deployment and a rollback can be tested against the tests that match the older version.
- Onboarding is a few lines of configuration: a shared Helm chart, the packaging every service deploys with, takes the name of the test image and its parameters. Teams keep the frameworks they already use: pytest and Playwright on one team, NUnit on another, JUnit on a third.
Unit tests and UI tests against a mock backend still run in the CI pipeline. Everything that needs a live, deployed service runs through Testkube, which for most teams has taken over the test-running role GitHub Actions used to play.
What changed for developers and QE
The most visible change is who writes which tests. Before, developers built a feature and handed it to QE, who wrote the automation afterward. Now the developer writes the first tests with the feature and sees the result shortly after deploying to development. Developers own the first layer of quality, and the work that reaches QE is already in better shape.
That took a layer of routine work off QE. The team stopped writing basic checks, such as whether an endpoint returns 200, because those now arrive with the code. QE time goes to end-to-end and user-facing tests and to edge cases, since the expected functionality is already covered by the developers' tests.
On the development side, more developers write tests than before, because the tests now have somewhere to run the moment the code lands. The relationship between development and QE changed with it: less handing work over the fence, more agreeing up front on who covers what, with developers taking the small checks and QE the critical, customer-facing ones.
Problems are caught in the lower environments right after a deployment, before manual QA would have found them, and fewer low-level bugs make it to integration.
| Area |
Before |
With Testkube |
| Where tests run from |
GitHub Actions, Azure DevOps and hand-built VMs |
One place, inside the cluster (about 70 percent moved so far, DevOps estimate) |
| Internal services in staging |
Reachable only through public services |
Tested directly, with the same tests as in lower environments |
| Finding the failing service |
An investigation across four or five services in Dynatrace |
The failing tests point to one service |
| Starting tests after a deployment |
Slack polling and a GitHub Actions trigger that did not always fire |
A Testkube trigger runs the tests as part of the deployment |
| Tests for a new feature |
Written by QE after deployment; the wait could be hours or days |
Written by the developer in the same pull request as the code |
| Who writes what |
QE wrote basic checks and the automation |
Developers write the first layer; QE focuses on edge cases and end-to-end |
| Load tests per service |
Never got working |
Being built through Testkube, one service so far, more planned |
The outcome
Testing at Imprivata is moving from multiple tools to one. The DevOps team estimates that about 70 percent of the tooling that used to run from GitHub Actions, Azure DevOps and custom VMs is moving into Testkube, with more teams still onboarding, and the team now has one place to see the state of testing across the platform. Internal services that could only be tested from the outside in staging are tested directly, with the same tests, in development, integration and staging.
On one of the platform's most important services, the time from merging code to having test results from the deployed version dropped about 40 percent. Most of the gain came from replacing the Slack polling with a trigger inside Kubernetes.
More services are tested than before and fewer basic bugs reach integration; nobody has counted either, and this case study does not claim a number. Per-service load tests, which the team had wanted for years and never had working, are being built through Testkube, along with an end-to-end load test ahead of a large group of new customers expected on a facial recognition service in late 2026 and early 2027.
Three product and platform teams run tests through Testkube today, and the setup one QE team built was copied by a second product team.
When we asked how they would make the case to a peer at another company, the DevOps team's answer was about shape rather than numbers: Testkube runs any kind of test, and having every test in one place, orchestrated by one tool with the Kubernetes, Argo CD, Slack and PagerDuty integrations already there, simplifies things more than any single feature does.
What's next
Today some production releases at Imprivata ship 10 to 15 services at once to a second Kubernetes cluster standing up for the release, with a staging call and a production call of 10 to 15 people, each running one to two hours. It is expensive and time-consuming, and it is the process the DevOps team most wants to replace.
The team is running a proof of concept of Argo Rollouts with Testkube as the quality gate: one service deploys, Testkube tests that version before customer traffic reaches it, and only if the tests pass does it go live, with the option of sending a small share of traffic first. This approach means teams can roll out and test their own changes almost immediately, and features reach customers sooner.