I find the breaking point first. so production never has to.

✅ SLA gate — perf tests that can fail the build

Latency budgets live in slas.yml, per endpoint. A script parses Locust's CSV, prints a verdict table into the GitHub job summary, and exits non-zero on any breach. “A dashboard needs a human — an exit code scales.”

🧠 Memory-leak hunter

Samples container memory under constant load, discards warm-up, fits a least-squares trend — and fails only when both growth rate and total growth blow their budgets. Demonstrated against a simulated ~50 KB/request leak:

⚡ Load shapes as ~15 lines of code

Stress, spike and soak profiles are LoadTestShape classes selected by one env var — one reviewed workload model serves every scenario.

class SpikeShape(LoadTestShape):
    """20-user baseline, sudden 10× spike."""
    def tick(self):
        t = self.get_run_time()
        if t < 120: return (20, 5)
        if t < 180: return (200, 50)  # the spike
        if t < 360: return (20, 50)   # recovery
        return None

📉 Regression detection, run over run

One run tells you where you are; comparing runs tells you where you're heading. Nightly CI diffs endpoint-by-endpoint and fails on p95 growth, throughput drops, or worsening error rate:

🐳 Distributed by default

make up WORKERS=8 — Locust master/worker split in plain Docker Compose, FastHttpUser for ~10× RPS per generator. Same images scale across hosts or Kubernetes.

📊 Live observability

Pre-provisioned Grafana dashboard: RPS, p50/p95 overlaid with the user ramp, failures/s, and the leak-hunting memory panel — problems visible the moment they start, not in a PDF afterwards.

👥 Realistic workload model

75% browsers, 25% buyers running the full funnel as a SequentialTaskSet; catch_response marks a 200-without-order_id as a failure — wrong answers delivered quickly are still wrong.

🩹 Self-healing locator engine

Every element is an ElementDefinition with ordered fallback candidates. When the primary selector dies mid-day (booking.com A/B tests constantly), candidates are polled round-robin, the winner is logged as a healing event, and non-volatile heals are persisted to a git-committed store so future runs try them first.

destinationInput: {
  key: 'stays.searchbox.destinationInput',
  candidates: [
    'input[name="ss"]',                            // primary
    '[data-testid="destination-container"] input', // fallback 1
    'input[placeholder*="Where are you going"]',   // fallback 2
  ],
}

📡 A real heal, captured in CI

Worker processes append events to their own files; a custom reporter consolidates them after the run. The engine is itself covered by E2E tests.

{
  "key": "flights.results.flightCards",
  "failed": ["[data-testid=…_card]"],
  "healed": "[aria-label^='Result item']",
  "persistPreferred": true
}

🩹 healed → logged → persisted → suite stays green

🌍 Live-site quirks, engineered around

• Flights served as Kayak white-label in some regions — variant auto-detected, stable deep-link scheme used
• Sign-in popup at random moments — addLocatorHandler auto-dismisses whenever it blocks
• /flights/ redirect trap — navigation enters via the header tab, like a real user
• A/B DOM swaps — absorbed by the healer, variants kept as candidates

🧱 Layered architecture

Plus a data layer with fluent builders — dates always generated relative to “now”, so the suite never rots from hardcoded test data.

♿ Beyond the happy path

axe-core WCAG 2.0 A/AA scan gating on critical violations, toMatchAriaSnapshot structural assertions, and APIRequestContext canaries at the HTTP level.

⚙️ CI built to scale

Static checks fail fast → sharded test matrix → blob reports merged into one HTML report. PR annotations, nightly cron, manual dispatch with tag filter. Scaling = extending the shard matrix.

🏷 14 tests, 9 suites, 3 browsers

Tag-driven: @smoke @stays @flights @cars @attractions @a11y @api @healer compose with --grep regexes. Verified green against the live site, Chromium / Firefox / WebKit.

🔍 Proven to catch real bugs

A screenshot test is only convincing if it catches something. The same suite runs against two deploys of the Toolshop app — a clean build and an intentionally broken fork — backed by identical data, so any pixel difference is a planted defect the suite must flag. On the with-bugs build the affected pages light up red — a shifted layout and typos like Contakt and Massage all caught. The trick: there a passing run would be the real bug.

🧬 Data-driven registry — add a row, get a test

Coverage lives in one array; a single generated spec turns each entry into a test, multiplied across every project. Adding a screenshot is one object, not a new file — the design that keeps the jump to 1000+ snapshots linear.

// pageRegistry.ts — one entry = one test
{
  category: 'home',
  name: 'home-grid',
  tags: ['@smoke', '@visual'],
  run: async ({ homePage }) => {
    await homePage.open();
  },
}

🧊 Flake frozen from one place

Every visual assertion inherits one tuned config: animations and caret killed, a shared stylesheet that freezes transitions and hides the polling chat widget, and a resolution-independent tolerance that absorbs anti-aliasing noise without hiding real change.

toHaveScreenshot: {
  animations: 'disabled',
  caret: 'hide',
  scale: 'css',
  stylePath: './tests/support/visual-stabilize.css',
  threshold: 0.2,
  maxDiffPixelRatio: 0.01,
}

🤖 The CI proves the suite still bites

A 4-way sharded matrix runs in the pinned Playwright container. Each shard records baselines from the clean build, sanity-checks the clean build against them (no false positives), then runs the with-bugs build and asserts diffs were found — a meta-check that fails CI if zero regressions are flagged, so an over-tolerant threshold can never let the visual suite go silently blind. Blob reports merge into one HTML report with every side-by-side diff.

🖥 Cross-browser & responsive

Six flows run across five projects: Chromium, Firefox and WebKit at one 1366×768 desktop viewport, plus Chromium-based Galaxy Tab S4 and Pixel 7. Selectors target data-test via getByTestId — immune to CSS/text refactors.

🐳 Deterministic pixels in Docker

Fonts and anti-aliasing differ across macOS, Windows and Linux, so baselines drift between machines. The pinned playwright:v1.61.1-noble image renders identically within tolerance on Linux locally and in CI — container baselines match CI exactly. No Percy or Applitools SaaS needed.

🔒 Baselines under control

updateSnapshots: 'none' in CI fails on any drift; baseline:changed rewrites only what genuinely differs for clean diffs. At thousands of PNGs the snapshot tree can move to Git LFS to keep clones fast.