Benjamin Bischoff shares his career shift from web development to test automation, emphasizing clean code, Selenium, and challenges like disorganized automation frameworks, while critiquing newer tools for limited real-browser simulation. He highlights the need for foundational software principles, cautious AI integration, and continuous learning to adapt to evolving testing landscapes.

Richard Seidl Software Testing

This is the other podcast on Software Testing by Richard Seidl, the episodes are in spoken German but the show notes and site are written in English. Our summaries are generated from AI transcript translations.

• https://www.richard-seidl.com/en/blog/tag/podcast-software-testing
• https://www.richard-seidl.com/en/

Episode Details

• Show Notes: https://www.richard-seidl.com/de/blog/vom-entwickler-zum-tester
• Published: 2026-04-14T04:00:00Z
• Duration: 00:23:23
• Author: Richard Seidl - Experte fur Software-Entwicklung und Testautomatisierung

Overview

The podcast features a discussion with Benjamin Bischoff, a Test Automation Engineer, focusing on his career transition from a Software Developer to a specialized role in test automation. Benjamin emphasizes his early experiences as a self-employed web developer using ActionScript and his shift toward testing after working at Ubisoft, where he was introduced to QA processes and tools like Selenium. His motivation for testing stems from a focus on delivering high-quality, user-friendly software, with a particular interest in automation tools that enable efficient, autonomous testing. The conversation highlights his continued use of Selenium, alongside exploration of newer tools like Playwright and Cypress, while stressing the importance of clean code principles, design patterns, and rigorous testing practices to avoid poorly structured automation code.

The episode also addresses challenges in the test automation field, such as the prevalence of disorganized code and the need for a mindset shift between exploratory testing and automation-driven approaches. Benjamin discusses the longevity of internal test frameworks, citing an example of a decade-old tool that remains valuable due to its extensibility and adherence to principles. He critiques newer tools like Playwright for limitations in accurately simulating real browsers and mobile testing, though acknowledges their growing community adoption. The dialogue touches on the integration of AI in testing, with examples of AI tools enhancing productivity and code review processes, while cautioning against over-reliance on specific technologies or vendor promises. Benjamin underscores the importance of foundational software development principles and continuous learning for aspiring automation engineers, advising they prioritize conceptual understanding over tool-specific expertise. The discussion concludes with reflections on the evolving role of testers in an AI-driven software landscape, emphasizing the enduring need for human oversight in ensuring quality amid rapid technological changes.

What If

• What if you started a 30-day scripting bootcamp using Bash/Python to build foundational test automation skills?

  • Move: Dedicate 30 minutes daily to writing simple scripts (e.g., file manipulation, API calls) and gradually integrate them into a test framework.
  • Why now: As Benjamin emphasizes, mastering principles (like clean code) trumps tool-specific expertise. Starting small reduces overwhelm and builds confidence.
  • Expected upside: Develops a strong coding foundation, enabling you to adopt or build test automation tools effectively later, while improving problem-solving agility.

• What if you conducted a tool audit to evaluate your current test automation stack against Selenium, Playwright, and internal frameworks?

  • Move: List your current tools, compare their extensibility, maintenance costs, and alignment with your project goals using criteria from Benjamins case studies (e.g., longevity, community support).
  • Why now: The text highlights risks of over-reliance on hyped tools and the value of frameworks with long-term viability (e.g., the 10+ year internal framework). This ensures you avoid costly rewrites.
  • Expected upside: Identifies gaps in your tooling strategy, reduces technical debt, and positions your workflows for sustainable scalability.

• What if you piloted AI-assisted test generation (e.g., Copilot) for repetitive test cases while manually refining edge cases?

  • Move: Use AI to auto-generate basic test scripts for regression scenarios, then audit and enhance them with exploratory testing techniques Benjamin practices (e.g., defect analysis).
  • Why now: The text acknowledges AIs growing role in testing but stresses human oversight. This balances efficiency gains with quality control.
  • Expected upside: Accelerates test coverage for routine tasks, freeing you to focus on complex scenarios and reducing burnout from manual scripting.

Takeaway

• Prioritize learning software development principles (e.g., clean code, design patterns) before diving into test automation tools.
  Build a strong foundation in programming and software craftsmanship to apply rigorously in test automation, as highlighted by Benjamins emphasis on disciplined practices over tool-specific skills.

• Start with simple scripting languages like Bash or Python to develop foundational automation skills.
  Begin with low-complexity tasks to build confidence and avoid getting overwhelmed by advanced test automation frameworks (as advised for aspiring automation engineers).

• Evaluate test automation tools based on long-term value, not just trends (e.g., stick with Selenium for legacy projects if it meets extensibility needs).
  Focus on frameworks that align with your projects goals and avoid over-reliance on newer tools like Playwright unless their limitations (e.g., weaker mobile testing) are explicitly addressed.

• Engage with QA and automation communities through conferences (e.g., QS-Day 2025) and collaborative learning.
  Stay updated on industry practices, share knowledge, and learn from peers who excel in test methodologies or defect analysis to improve your automation strategies.

• Experiment with AI tools (e.g., Copilot, CodeRabbit) to enhance productivity in coding and code reviews, but maintain active oversight.
  Use AI for efficiency gains in test script generation or reviews, but validate outputs to ensure alignment with quality standards, as highlighted in the discussion on AI integration.