Test automation succeeds through strategic, maintainable design with a focused set of high-impact test cases, emphasizing stability, modularity, and clean architecture. Key practices include improving UI testability, avoiding fragile locators, and using isolation and application-busy detectors for reliability.

Software Testing Unleashed

Software Testing Unleashed - hosted by Richard Seidl. Different guest per episode. The official Show notes contain a comprehensive overview of the episode. Released as audio and video.

• https://www.richard-seidl.com/en/testing-unleashed
• https://www.youtube.com/playlist?list=PL48Mbm-L0hjB1OdwYi9h7jrq9t352-Zk_

Episode Details

• Show Notes: https://www.richard-seidl.com/en/podcast/testable-html-stable-e2e
• Published: 2026-08-20T04:00:00Z
• Duration: 00:33:41
• Author: Richard Seidl | Software Development & Testing Expert

Overview

Test automation is fundamentally a software development effort that requires strategic planning, maintainability, and long-term sustainability. Rather than focusing on quantity, effective test automation emphasizes a small set of well-designed test cases - such as 15 key scenarios - that can cover up to 80% of critical functionality. Success depends less on tools and more on strategy, testability, and clean design. A modular, layered architecture is recommended, with reusable libraries, clear separation between business logic and test scripts, and consistent naming conventions that reflect business actions rather than technical details.

Key practices for robust automation include improving UI testability through dedicated attributes like data-rule or aria-label, using centralized mappers for easier maintenance, and targeting elements with precise, stable locators such as labels instead of fragile XPaths or concatenated IDs. To ensure stability, teams should avoid arbitrary sleep times by using application-busy detectors, manage test environments carefully, and run tests in isolation to prevent interference. For scalability, modular design allows tests to be reused across different technologies (e.g., web and Electron) and adapted quickly to changing conditions. When modernizing flaky test suites, it’s advised to start fresh with a clean structure, selectively migrate valuable components, and apply software engineering best practices to gradually build a reliable, low-maintenance automation framework.

What If

• What if you redesigned your flaky test suite using a parallel clean-slate repository?

  • Move: Create a new Git repository with strict naming conventions, modular structure, and centralized mappers for data-rule or test-id attributes. Migrate only the most stable, high-value test procedures from the legacy suite - rebuilding them with clean code.
  • Why Now?: Legacy test suites accumulate technical debt; delaying restructuring prolongs 40%+ time spent on debugging flakiness instead of delivering value. Starting now prevents further decay.
  • Expected Upside: Reduce maintenance effort by 50 - 70% over 6 months, enable faster onboarding, and establish a scalable foundation that supports future projects without regression.

• What if you standardized element identification using business-readable labels and data-rule attributes across your app?

  • Move: Audit your UI to add data-rule="submit-order" or aria-label="Search products" to key elements. Update your test framework to target these exclusively - ban XPath and concatenated IDs. Build a central mapping file (e.g., JSON) linking business actions to selectors.
  • Why Now?: Every day without stable selectors multiplies flakiness and debugging time. With rising test volume, inconsistent targeting becomes unmanageable.
  • Expected Upside: Achieve 80%+ stability improvement in test runs, cut selector-related failures by 90%, and make tests readable even to non-developers - accelerating debugging and collaboration.

• What if you reduced your test automation backlog to just 15 high-impact scenarios covering core user journeys?

  • Move: Audit your current test cases. Keep only those that validate critical business functionality (e.g., login, checkout, data export). Eliminate redundant or low-value tests. Implement each as a modular, reusable script using action-based naming (e.g., enter payment details, check order confirmation).
  • Why Now?: Expanding test coverage without pruning leads to bloated, unmaintainable suites. Focusing now ensures resources go toward reliability, not quantity.
  • Expected Upside: Cut execution time by 60%, increase confidence in CI/CD pipelines, and free up 10+ hours/month for innovation - while still protecting 80% of critical risk surface.

Takeaway

• Implement and enforce the use of data-test or data-rule attributes in UI elements to ensure reliable, maintainable test automation targeting.
• Build a centralized mapping layer that links test identifiers (like data-rule) to automation code, reducing duplication and enabling single-point updates.
• Design test cases around 15 high-impact scenarios covering 80% of critical functionality, evaluating each for maintainability, readability, and stability before automation.
• Replace hardcoded locators and complex XPath expressions with label-based element identification, using external files (e.g., Excel) for multi-language support and long-term stability.
• Migrate flaky test suites incrementally by setting up a new repository with clean architecture, selectively porting reusable components, and applying consistent naming and modular design.