The episode explores Selenium, testing best practices, and the importance of technical proficiency for testers, emphasizing mindset overlaps between developers and testers. It compares Selenium and Playwright, highlights common automation pitfalls, and advocates for continuous learning, AI integration, and collaboration in software testing.

How To Test This?

interview episodes where Mamadou N’diaye talks with with software testing experts

• https://podcasters.spotify.com/pod/show/spidey1944
• https://www.youtube.com/@HowToTestThis
• https://www.linkedin.com/in/mamadou-ndiaye-consultant/

Episode Details

• Show Notes: https://podcasters.spotify.com/pod/show/spidey1944/episodes/How-to-Test-with-Selenium---Alan-Richardson-e3eh6ut
• Published: 2026-02-02T12:37:08Z
• Duration: 01:05:41
• Author: Mamadou N’diaye

Overview

The podcast covers the development and application of Selenium and WebDriver in software testing, focusing on their role in improving test coverage and identifying potential failures through strong technical knowledge. It compares Selenium with more modern tools such as Playwright, noting that while Selenium is praised for its simplicity and consistency, Playwright offers additional features and a higher level of abstraction. The discussion also highlights frequent pitfalls in test automation, including attributing problems to the tools themselves, excessive automation beyond necessity, and insufficient communication between developers and testers. Practical advice includes implementing abstraction layers, prioritizing high-risk test cases, and avoiding overly technical, low-level APIs in test scripts.

The podcast further explores the importance of understanding application architecture, along with design patterns such as Page Object Model and Screenplay Pattern, which help in organizing and maintaining test code effectively. It encourages test automation professionals to learn programming languages like Java, JavaScript, or Python, practice in controlled environments, and develop a strong portfolio with clean and well-documented code. The role of AI in testing is also addressed, with the suggestion that it should be used as an aid for learning and support rather than a substitute for technical understanding. Ultimately, the episode promotes a balance between technical expertise and soft skills, advocating for close collaboration with developers and a commitment to continuous learning to keep up with the fast-changing landscape of software testing.

What If

• What if you adopted Playwright with AI-assisted test generation for your next automation project?
  Concrete move: Start by using AI tools (e.g., Open Code or IDE integrations) to generate Playwright test scripts for a small feature in your application, focusing on auto-locators and minimal setup.
  Why now: Playwrights permissive nature reduces manual configuration, and AI-powered code generation accelerates learning curves for new testers.
  Expected upside: Faster test creation, easier maintenance via auto-locators, and reduced friction for future AI-driven expansion (e.g., integrating with LLMs for test updates).

• What if you implemented the Page Object Model (POM) with domain-driven design principles for your automation suite?
  Concrete move: Refactor one or two test modules in your project to abstract UI components into reusable page objects, aligning them with business logic rather than just HTML elements.
  Why now: POM with DDD improves test maintainability and scales better for complex applications, reducing duplication and divergence when UI elements change.
  Expected upside: Tests become more resilient to UI changes, easier to collaborate with developers, and reusable across projects or environments.

• What if you focused on mastering a JVM-based language (e.g., Java or Kotlin) to deepen your Selenium integration skills?
  Concrete move: Dedicate 23 weeks to building a test automation framework in Java using Selenium, focusing on WebDrivers modern API (e.g., Duration for waits) and incorporating static analysis tools for code quality.
  Why now: JVM languages are foundational for many testing frameworks, and understanding their nuances (e.g., synchronization, abstraction layers) aligns with Seleniums evolution.
  Expected upside: Stronger control over automation logic, better alignment with enterprise tools (e.g., JUnit, TestNG), and improved ability to troubleshoot brittle tests.

Takeaway

• Invest in Technical Proficiency: Deepen your understanding of web technologies like HTML, JavaScript, and HTTP to better identify potential failures and expand test coverage, enabling more effective automation and risk assessment.

• Prioritize Tool Mastery Over Hasty Switches: Learn WebDriver thoroughly before switching to frameworks like Playwright. Understand its limitations and use it for precise control in unit testing, while reserving Playwright for scenarios requiring flexibility and AI integration.

• Implement Page Object Model (POM) with Abstractions: Structure your automation using POM to abstract application components, reducing test fragility. Pair this with domain-driven design principles to create maintainable and reusable test logic.

• Avoid Over-Automation and Focus on Prioritization: Collaborate with developers to avoid redundant test coverage. Prioritize automation based on project risk and maintainability, using data factories and boundary classes to manage test data efficiently.

• Leverage AI for Code Generation, But Validate Output: Use AI tools to generate initial test scripts or scaffolding, but critically review and understand the generated code. Integrate AI for learning and experimentation, but ensure you maintain control over abstraction layers and test structure.