Skip to main content
Software Delivery & Engineering OpsLast reviewed 2026-09-20

TestOps

Operating the test infrastructure: environments and data that are available when needed, suites that finish quickly, and a flake rate low enough that a red build is believed.

Overview

Read the full TestOps guidance
WHAT IT IS TestOps is the operation of everything tests need in order to be useful: environments that exist when someone needs one, representative and safe test data, suite runtime short enough to sit inside a feedback loop, parallelisation, and a flake rate low enough that a failure is taken seriously. **Not this:** TestOps is not QAOps: it owns the machinery that runs tests — environments, data, runtime and reliability — not the strategy deciding what quality means and what to test. WHY IT EXISTS A test suite nobody believes is worse than no suite, because it costs time and provides false comfort. Flakiness is the mechanism: once a red build is routinely re-run rather than investigated, the signal is gone and genuine regressions ship behind the noise. The second reason is throughput — a forty-minute suite changes how engineers work, encouraging large batched changes, which is the opposite of what testing is meant to enable. WHEN TO USE IT Adopt it when re-running a failed build is the normal response, when engineers wait on a shared environment, or when test data is a copy of production that nobody has thought hard about. The trigger is behavioural: watch what people do with a red build. WHO OWNS IT A platform, developer-infrastructure or dedicated test-infrastructure team owns environments, runners and data tooling. Individual teams own their own tests' reliability — flake ownership must sit with the test's author or it becomes nobody's. Privacy and security own what may be used as test data, which is a /privacyops question whenever production data is involved. WHAT GOOD LOOKS LIKE Flake rate is measured per suite and per test, and a persistently flaky test is quarantined or deleted rather than tolerated. Suite runtime is measured and budgeted. Environments are provisioned on demand rather than queued for. Test data is generated or masked rather than copied wholesale from production. A failure points at what broke rather than requiring archaeology. Test infrastructure is treated as production infrastructure, with ownership and alerting. HOW TO IMPLEMENT Measure flake rate first — most organisations have never quantified it and are shocked. Quarantine the worst offenders immediately so the signal returns while the underlying fixes happen. Budget suite runtime and enforce the budget by parallelising or moving tests to a layer where they belong. Replace shared long-lived environments with on-demand ones where the architecture allows. Deal with test data deliberately, because copying production is the easy path with the worst privacy profile. Coordinate with /qaops on what belongs at which layer rather than deciding it inside the infrastructure. HOW TO ASSESS YOURSELF Ask what your flake rate is; if nobody knows, that is the answer. Watch what happens to the next red build. Ask how long it takes to get a clean environment. Take the scored self-assessment at /assess and sequence the findings with /roadmaps.

Capabilities

  • Flake management

    Measuring flake rate per test and quarantining persistent offenders, because a disbelieved suite has no value.

  • Suite runtime budgeting

    A stated budget for how long feedback may take, enforced by moving or parallelising tests rather than by hope.

  • Test data management

    Representative data that is generated or masked rather than copied wholesale from production.

  • Test environment provisioning

    Environments available on demand rather than queued for, so testing is not rationed by scarcity.

  • Test parallelisation

    Running suites concurrently with isolation strong enough that parallelism does not itself create flakiness.

Practices

  • Flake quarantine review

    A recurring pass over quarantined tests so quarantine is a waiting room rather than a graveyard.

  • Test data refresh

    Periodically regenerating or re-masking test data so it stays representative without drifting into real personal data.

Metrics

  • Environment wait time

    How long an engineer waits for a usable test environment.

    Unit: minutes. Good direction: down.

  • Flaky Test Rate

    Share of test runs failing without a code change.

    Unit: %. Good direction: down.

  • Suite runtime

    Wall-clock time for the suite that gates a change, measured where it sits in the feedback loop.

    Unit: minutes. Good direction: down.

  • Test flake rate

    Share of test failures that pass on re-run without a code change — the number that decides whether red is believed.

    Unit: percent. Good direction: down.

Tools

  • Allure Report

    Test reporting that aggregates history, making flake and failure patterns visible across runs.

    Visit site ↗
  • GitHub Actions

    Pipeline automation integrated with the repository: build, test, scan, and deploy workflows.

    Visit site ↗
  • Playwright

    Browser automation framework with tracing and retry controls useful for diagnosing and containing flakiness.

    Visit site ↗
  • Testcontainers

    Runs real dependencies in disposable containers so tests get an environment on demand instead of a shared one.

    Visit site ↗

Architecture patterns

Reference architectures and their trade-offs live in the blueprints library.

Maturity

  1. L1 ReactiveRed builds are re-run rather than investigatedrequired stage

    Flakiness has destroyed the signal, so failures are noise and genuine regressions ship behind them.

  2. L2 RepeatableFlake rate is measured per suiterequired stage

    The size of the problem is known, which is the precondition for anyone being allowed to act on it.

  3. L3 StandardizedPersistent flakes are quarantined and environments are on demand

    The signal is restored while fixes happen, and nobody waits in a queue for somewhere to run tests.

  4. L4 MeasuredSuite runtime is budgeted and enforced

    Feedback time has a stated limit, held by moving or parallelising tests rather than by hoping.

  5. L5 OptimizedTest data is generated or masked by default

    Representative data is produced deliberately rather than copied from production, and test infrastructure is run like production.

Maturity for testops is measured, not guessed — every score traces to your answers. See how maturity is scored.

Put it to work

Sources