BXUP Track progress & test yourself — free
QA & Testing · Playbook · Core · ~5 min read
QA & TESTING · PLAYBOOK · CORE

Run the Healed-Test Audit Queue — Treat Every Heal as a Proposed Change

A healed test is an unreviewed edit to your safety net. The audit queue makes that edit visible: every heal becomes a queued diff with a required accept/reject decision, so a heal that masks a real regression is caught in review — not discovered in production a month later.

Tier: Core · Workflow area: Agentic test stack & self-healing

This playbook builds the operational workflow around self-healing: collecting heals into a queue, reviewing them with a three-question protocol, committing accepted heals so the baseline stays versioned, and turning rejected heals into filed bugs.

USE IT WHEN

Heals are flowing and need governance

  • Any self-healing mechanism is active — Healenium, Playwright healer, a vendor platform — and heals currently land without a decision trail.
  • An audit or client review asks "who approved this test change?" and the honest answer is "a similarity algorithm".
  • You suspect (or have been burned by) a green suite hiding a broken feature.
SKIP IT WHEN

There is nothing to queue

  • No self-healing in use and none planned — invest in resilient locators and ARIA snapshots instead.
  • Heal volume is so high the queue would drown reviewers — that is a locator-strategy crisis; fix the strategy before building process on top of it.

Prerequisites

  • A healing mechanism that exposes what it changed: Healenium's healing report, Playwright healer diffs, or a vendor's heal log/API.
  • A PR-based repo for the test suite — the queue's decisions land as commits.
  • A defect tracker, because rejected heals become bug reports.
  • Fifteen minutes a day of named reviewer time (rotate it like a triage duty).

The workflow

  1. Make heals visible in one place. Configure the mechanism to emit heals as artifacts, not just runtime behavior. Healenium: enable the report UI/plugin and export healed selectors per run. Playwright healer: run it so patches arrive as diffs. Vendor tools: pull the heal log via API. Land everything in a queue — a heals/ directory of JSON entries, a dashboard, or simply draft PRs. A queue entry carries:

    {
      "test": "checkout.spec.ts > applies discount code",
      "old_locator": "#discount-apply",
      "new_locator": "button[data-testid='promo-apply']",
      "run": "nightly-2031",
      "confidence": 0.94,
      "status": "PENDING_REVIEW"
    }
    
  2. Review with the three questions — in order. For each queued heal:

    Q1  Is the new locator pointing at the SAME logical control?
        (Open the app or the DOM snapshot; don't trust the similarity score.)
    Q2  Did the app's INTENDED behavior change in this area?
        (Check the release notes / recent PRs for this UI. Renamed button: fine.
         Removed discount step: not fine.)
    Q3  Does the test still assert the outcome that matters, and did it truly
        exercise it in the healed run? (Read the healed run's assertion evidence.)
    

    Three yes/no/no-change answers in the right pattern → accept. Anything else → reject.

  3. Accept = commit, so the heal count returns to zero. An accepted heal is a locator improvement; put it in the suite:

    git checkout -b heal/checkout-discount-locator
    # apply the new locator in source, delete the queue entry
    git commit -m "Accept heal: #discount-apply -> data-testid promo-apply (UI refactor PR#412)"
    

    This step is what keeps the versioned suite identical to the executed suite. Runtime-healing tools that keep healing the same selector every night are telling you this step is being skipped.

  4. Reject = file the bug and pin the test red. If Q2 revealed a behavior change, the heal was masking a regression. Revert/block the heal, let the test fail honestly, and file the defect with the heal entry as evidence — "the healer re-pointed this test at X to keep it green" is a compelling repro narrative. Record it:

    REJECTED heal nightly-2031/checkout-discount
    Reason: discount no longer applied after redesign; heal re-targeted a decorative button
    Action: bug FE-2214 filed, heal reverted, test intentionally red until fix
    
  5. Use AI to pre-screen, never to decide. An assistant can batch-summarize the queue and flag suspicious entries — locator changes that jump to a different DOM region, heals coinciding with feature PRs, repeated heals on one test:

    Here are 12 healed-locator entries (JSON) and the list of app PRs merged this week.
    For each heal, flag LIKELY-BENIGN or NEEDS-SCRUTINY with one line of reasoning —
    e.g. heal coincides with PR touching that component's behavior, or new locator
    is in a different page region. Do not approve anything; this is triage ordering only.
    

    The human still answers the three questions for every entry; the model only orders the work.

  6. Report queue health weekly. Track: heals queued, accepted, rejected, median time-in-queue, and repeat-healers (tests healed more than twice — candidates for locator rewrite). Rejected-heal count is your caught-regression count; celebrate it.

Key Takeaway:

Accept-and-commit or reject-and-file — those are the only two exits from the queue. The moment a heal can take a third path (silently becoming tomorrow's baseline), the suite stops being evidence of anything.

Variations

  • PR-native queue: have every heal open a draft PR automatically; review happens in the code-review tool you already govern, with CODEOWNERS forcing the right reviewer.
  • Healenium-centric: schedule a nightly export of the healing report into queue entries; the similarity score becomes a triage hint, never an auto-accept threshold.
  • Vendor platforms: if the tool cannot export heals, run the POC-scorecard playbook question "show me every locator you changed this month" — inability to answer is a disqualifying finding.
  • High-churn periods: during a redesign, batch-review heals per feature area with the feature's developer in the room — Q2 answers arrive in seconds instead of archaeology.

Quality check

  • Zero silent heals: every heal in tool logs has a matching queue entry and decision; sample-audit monthly.
  • Baseline honesty: repo diff shows accepted heals committed; nightly runs show no recurring heal on the same selector.
  • Rejection evidence: rejected heals link to filed bugs; at least the calibration wrong-heal exists in the log.
  • Queue latency: median time-to-decision under 2 business days — a stale queue is a silent-heal factory with extra steps.
  • Repeat-healer list actioned: tests healed 3+ times have locator-rewrite tickets.

Pitfalls

  • Auto-accepting above a confidence score. Similarity measures DOM likeness, not behavioral sameness — the wrong heal often scores highest precisely because the replacement element looks right.
  • Reviewing the locator, skipping Q2. The queue's entire purpose is the behavior question; a reviewer who only eyeballs selector strings is decorating the failure mode.
  • Letting the queue back up. Fourteen stale entries get bulk-approved on a Friday; that batch is where the regression hides. Small daily reviews beat heroic weekly ones.
  • No committed baseline. If accepted heals live only in the healer's database, a tool migration or DB loss silently reverts your suite months backward.
  • Treating rejections as healer failures. A rejected heal is the system working — the healer surfaced a change, review caught the regression. The failure is a rejection that never got filed as a bug.

Restricted-environment variant

The queue itself is a governance asset for regulated and client-audited environments: it converts "AI modified our tests" into "every AI-proposed change carries a named approver and a timestamp." Keep queue entries free of client-sensitive data (URLs and selectors are usually fine; embedded test data may not be). If policy bars model-based pre-screening, skip step 5 — the queue works identically with human-only triage, just order by confidence score and PR-coincidence manually.

Success criteria

  • 100% of heals pass through the queue with a recorded decision; audit sampling finds no silent path.
  • Executed suite and versioned suite provably identical outside the review window.
  • At least one masked regression caught and filed via a rejected heal — the queue's existence proof.
  • Repeat-healer tests trending to zero as locator rewrites land.
Pro Tip

Put the weekly heal report next to your flake report in the quality dashboard. Heals and flakes are the two ways a suite lies to you — one by changing itself, one by changing its mind — and leaders who see both numbers weekly make better calls on agentic-tooling trust than any policy document achieves alone.

This is the free reading view. Open BXUP to track your progress, run the hands-on labs, and prove it with original, exam-pattern assessments.
© Anvi Innovate · BXUP — Be Exponentially Upskilled · BXUP is an independent learning platform, not affiliated with or endorsed by AWS, Microsoft, Google, NVIDIA, IBM, Salesforce, Databricks, Oracle or Anthropic. All trademarks belong to their respective owners. · bxup.in