Explore every episode of the podcast Software Testing Unleashed - QA, DevEx & Quality Engineering

How do you bring AI into a medical lab when the regulatory landscape is still taking shape? With Alexis Savkin I talk about exactly that tension, and the answer turns out to be less about technology than about focus and strategy. We get into why starting with a very specific, measurable problem makes the regulatory side manageable, and how a single-page risk diagram convinced compliance stakeholders faster than any technical pitch. I keep coming back to his point that regulators are not enemies but partners trying to make things safer, and that the real mistake is trying to solve "AI" as one giant problem instead of one concrete thing at a time.

What happens when 40 years of custom decisions stack so high that even the standard testing tools from your own vendor stop working? With Bartosz Filipek and Szymon Wałachowski I talk about exactly that situation: a mainframe environment so deep in its own customization that the only way forward was to build one final bridge to the outside world. We dig into how they created a Java-based unit testing tool for COBOL developers, and what surprised me most is that COBOL programmers find it easier to write assertions in Java than in their own first language. We also get into code coverage, integration with tools like SonarQube and X-ray, and the long road of getting something as basic as a service account approved.

This time I talk with Dušanka Lečić about why testing chatbots breaks everything we know about traditional QA. She explains how chatbot bugs are invisible – they hide in prompts, retrieval logic, and chunks, not in code – and why the same input can produce dozens of valid outputs. Dušanka shares her framework for testing context retention, hallucination control, and accuracy, and reveals why stress testing a chatbot means checking for typos and user frustration, not system load.

This time I talk to Mitko Mitev, about how AI is reshaping our work as testers, without replacing us. Mitko shows exactly where AI tools save real time across test planning, test case generation, and exploratory testing, and why human expertise remains non-negotiable for context, business logic, and validation. We go into the shift from writing scripts to instructing agents in plain language, how ISTQB's new AI syllabi prepare testers for what's coming, and why waiting another year to explore AI might already be too late.

In this episode, I talk with Filip Barszcz about what most companies get wrong when they claim to have a quality culture. Filip reveals why stakeholders, developers, and product owners all speak different languages when they say "quality" and how he translates between them to build actual buy-in for testing strategy. He walks through his playbook for introducing change without burning out the team: small wins first, honesty about short-term productivity drops, and color-coded tables that make executives eager to invest in QA. If you've ever struggled to get testing taken seriously beyond "just click through it before release," this conversation gives you the roadmap.

In this episode, I talk with Marta Firlej about a topic most testers avoid: money. Marta explains why understanding how your company actually makes money is crucial for QA professionals, and walks through the real costs behind salaries, automation projects, and test activities that stakeholders care about. She shares a practical calculation method to assess whether test automation is worth the investment, and challenges us to translate testing value into business numbers.

In this episode, I talk with Henri Terho, senior consultant and AI enthusiast, about why building trust in AI systems requires the same rigor we've always applied to software—just now at a whole new level. Henri explains how AI agents multiply both our successes and our mistakes, why prompting is harder than it looks, and why testers are uniquely positioned to thrive in this shift. We dig into the oracle problem, the communication trap, and why your test suite might soon matter more than your codebase.

In this episode, I talk with Simon Stewart, professional software developer and former lead of the Selenium project for over 10 years, about one of the most frustrating problems in software testing: flaky tests. Simon reveals why a flaky test isn't always a bad test – sometimes it's actually exposing real production risks that your team needs to address. We dive into practical strategies for handling flakiness in CI pipelines, from gatekeeping techniques used at Meta to knowing when it's actually okay to delete tests. You'll learn why assigning ownership to individuals (not teams) is crucial, and how to use test flakiness as valuable signal rather than just noise.

In this episode, I talk with Bartosz Czernic-Goławski, a penetration testing and cybersecurity expert, about how mobile security has evolved from Nokia's indestructible brick phones to today's pocket-sized computers. We trace the journey from analog networks that anyone could eavesdrop on to modern smartphones that demand excessive permissions and collect sensor data every second. Bartosz reveals how attackers use overlay attacks to steal banking credentials, why iOS users aren't as secure as they think, and what phone freaks in the 1980s can teach us about today's vulnerabilities.

In this episode, I talk with Line Ebdrup Thomsen, quality engineering manager, about why software testing attracts more women than other tech roles – and why that's still not enough. Line shares how she coaches testers to be assertive but kind, especially when they're the only woman or the only tester in a team of developers. We discuss what prevents women from speaking up, how curiosity and communication skills matter more than your degree, and why the next generation of leaders might still need a wake-up call.

In this episode, I talk with Maciej Kusz, program chair of the Testwarez conference in Poland, about why Playwright doesn't have to mean TypeScript. Maciej has been using Playwright with Python for years and shows that Python testers can leverage the framework just as effectively—if they know which PyTest plugins to use and where the documentation actually lives. We dig into the practical trade-offs: what TypeScript does better out of the box, where Python offers more flexibility for QA work beyond the browser, and why stable tests are surprisingly easier to achieve in Python's synchronous world.

In this episode, I talk with Natalia Romanska about why our biggest professional disasters often teach us more than our polished success stories. She shares how a 70,000 złoty accounting mistake early in her career forced her to develop the self-awareness that now guides her QA work—and why that painful learning stuck harder than any training ever could. We dig into the uncomfortable truth that testers rarely talk about: the gap between knowing we should learn from failures and actually sitting down to extract those lessons. Natalia offers concrete practices for turning blame into growth, from the "magic five whys" to building feedback loops that don't just stroke our egos.

In this episode, I talk with Žaklina Polak Matanović, an experienced QA manager who discovered that raising three daughters taught her more about software testing than most training courses ever could. She shares concrete stories about how skills like clear ownership assignment, prioritization under pressure, and proactive thinking emerged naturally from parenting chaos – from navigating playgrounds with toddler twins to managing ambiguous requests at home. What makes this conversation powerful is Žaklina's honest reflection on returning to tech after maternity leave, initially doubting her career trajectory while others seemed to advance, only to realize the soft skills in software testing she'd been building at home became her greatest professional assets for achieving work life balance in tech.

In this episode, I talk with Callum Akehurst-Ryan, a quality coach with nearly 20 years of experience, about why exploratory testing is far more than random button-pushing—and how teams waste it by using it in all the wrong places. Callum walks us through practical exploratory testing techniques that help uncover risks in non-functional requirements like performance and security, especially when no one has bothered to document what "good" should look like. We discuss how to structure exploration with timeboxes and risk-based scopes, when to turn findings into automated tests, and why retrofitting quality into existing systems demands a different software testing strategy than most teams realize.

In this episode, I talk with Vitaly Sharovatov about the economics of testing. We ask how testers can sell quality to managers who think in money, risk, and time. Vitaly frames testing like insurance. You pay now to lower the chance or impact of pain later. He shows where to find numbers that speak. Churn, support hours, rework in Jira, failed handoffs, and regulatory risk. Start small. Pair with developers, cut waste, count saved hours, and share clear wins. Then aim bigger. Shorter time to market, better UX, fewer angry users.

In this episode, I talk with Maryia Tuleika about stepping on stage in tech and testing. We explore why people speak: joy of sharing, stage energy, and community. The hard part is fear and stress. If you fear the stage, you will hear simple moves that help. Maryia shows how to switch stress to excitement: prep well, record dry runs, collect feedback, use box breathing, slow down, and stand tall.

In this episode, I talk with Kostiantyn Teltov about design patterns in test automation. Kosta shows why test code needs the same care as product code. Page Object to cut duplication. Builder to shape data like choosing a burger. Facade as a reception that guides you to the right service. We touch creational patterns and even pools for drivers. DRY, KISS, and YAGNI keep us honest and stop overdesign.

In this episode, I talk with Linda Van De Vooren about impostor syndrome, mental health, and growth in testing. Linda shares stories, from eating disorders to the inner critic she named Hannibal Lecter. We look at how doubt hits our work, like writing a test plan that feels too easy. Her tactics: Share openly. Check basic needs. Treat your comfort zone like a rainbow and pick a color you can handle today. Build an honest feedback circle.

In this episode, I talk with Steve Watson about critical thinking in the age of AI in testing. Steve says treat AI like a smart teammate. Useful, but you still check its work. We talk bias, missing context, and why lazy shortcuts tempt us. He shares where AI helped, like clustering survey responses, and where it missed ambiguities in requirements. We look at our craft: Ask better questions. Focus on the user. Let tools draft, but you decide. Train the next generation in skepticism and analysis. Same mission. New habits.

In this episode, I talk with Jani Grönman about KPIs for quality. We ask what to measure, and why. Jani shares pairs that keep teams honest. Test pass rate with escaped defects or flaky tests. Mean time to recovery with reopen rate. Lead time to production with customer impact. One team, one number. Keep it to three or four KPIs, own them, and act. We talk about agency at work and product sense. Your tests are not a scoreboard. They are a feedback loop. Bring product and engineering together, do root cause analysis. I left inspired to pick fewer numbers, tell stories, and ship with care.

In this episode, I talk with Laveena Ramchandani about thought leadership in testing and the changing role of testers. Laveena sees testers as engineers who lead by example, ask smart questions, and break silos. She coaches teams to share knowledge, speak up, and aim for team goals, not vanity KPIs. We touch hard calls too, like stepping in or reshaping a team when delivery slips. On AI, we agree to use the tools, then add human sense and the feel of quality, like accessibility and emotion. Testing stays very human.

In this episode, I talk with Pekka Klärck about Robot Framework. We start with 2004, his thesis roots, and Nokia Networks turning a prototype into an open source project in 2008. He explains the core idea: a generic engine with reusable libraries, human readable tests, and one set of reports. Best fit in mixed tech stacks. We revisit milestones like the move to plain text, a new parser, and a thriving ecosystem. Pekka previews secret variables in 7.4, a modern user guide, markdown docs, and a cleaner namespace with backward compatibility. He even tests Robot Framework with Robot Framework.

In this episode, I talk with Martijn Goossens about DevEx, DORA, and how we put the Q into developer experience. We walk through the four DORA metrics and where testers make real impact with CI, smart coverage, and fast feedback. Martijn shares a simple fix that unlocked speed: give each team a test environment. We explore coaching with small experiments, clear metrics, and regular check ins. Start with the State of DevOps report. Map your QA work to these metrics. Speak value, stay visible, and grow with your team and community.

In this episode, I talk with Florian Fieber about what 2025 taught testers and how to get ready for 2026. AI boosts productivity, it does not replace us. The sweet spot is generation of artifacts like test ideas, cases, scripts, and data. Accessibility grew due to the EU AI act, yet many underestimate the work. A plugin is not enough. You need manual checks and early design. For 2026 we expect agentic AI and a pilot role for testers. AI literacy becomes company wide.

In this episode, I talk with Yuliia Pieskova about informal networks in software teams. We explore how spontaneous ties lift trust, speed, and quality in remote and hybrid setups. Formal charts set limits, people move work through friends. Yuliia shares stories from startups, hackathons, and product discovery where cross team groups watch users, swap ideas, then return with shared context. Remote work exposes old cracks yet levels locations and opens doors for new links.

In this episode, I talk with Tibor Csöndes about how testing grew up and where it goes next. We recorded live at HUSTEF in Budapest, a conference he helped shape. Tibor shares telco roots where automation was normal. Tools change, thinking stays. He sees AI as a third wave after CATG and model based testing. Helpful, not a job thief. Use it, or the testers who do will take your seat. ISTQB gave us a common language across industries. Learn the basics, automation, AI, and the human stuff like clear messages and critical thinking.

In this episode, I talk with Michał Buczko about leading remote teams, trust, and AI. We spoke about clear calendars for open help sessions, regular updates to management by email, and the art of celebrating wins without bragging. We also spoke about sharing failures. That builds trust and can unlock help. Treat AI like a tool on your belt. Use it to amplify testers and developers, not to replace them. Stay critical and ask tech people first.

In this episode, I talk with Péter Földházi about test automation that solves real problems, not shiny tools. Péter brings two decades in quality and helped write the ISTQB automation syllabi. We ask why to automate, where it fits, and how the test pyramid guides choices across unit, API, and UI. I like how the simple pyramid makes choices visible. He shares a gaming case with 5,000 defects and a velocity drop. Strategy first, then tools, six month steps, and clear value.

In this episode, I talk with Leandro Melendez about how performance testing changed in the last 20 years. Live at HUSTEF, we swap stories from bare metal and heavy browser scripts to APIs, cloud, and Kubernetes. Leandro draws a clear line between performance and load testing. Do not run Black Friday tests every sprint. Watch production, use canaries, and learn from real users. He pushes observability first. Build dashboards, instrument early, and think about cost.

In this episode, I talk with Attila Fekete about HUSTEF 2025 in Budapest. He runs the program and the backstage work. We look at how a small local meet up from 2011 turned into 700 people from many countries. Care for people, high quality talks, and a fun vibe. We discuss new formats like longer talks, a master class track, and a career clinic with coaching and CV tips - and that first time speakers get mentoring too.

In this episode, I talk with Cassandra H. Leung about why testers still feel unseen and what we can do about it. We unpack impostor syndrome, the shy voice that says keep quiet, and how it holds many of us back. Cassandra shares a simple frame: show, share, shine. Put testing work on the board, share notes and dashboards, and keep a brag board for wins. We explore the wider role of testers across product talks, pipelines, and coaching the team.

In this episode, I talk with Maryse Meinen about stoic thinking for product development and life. We ask what happens if you stop judging success by outcomes and start judging by decision quality. Maryse shares tools you can use today: scenario planning, the 10 10 10 rule, and a simple decision journal. Prepare for failure, accept what you cannot control, and act with courage, justice, and temperance. This fits agile work and the mess we face in tech and society.

In this episode, I talk with Barış Sarıalioğlu about testing as art and science, through the lens of Leonardo da Vinci. We ask what a tester can learn from curiosity, observation, and experiments. Mona Lisa's smile shows how uncertainty beats 100 pages of metrics. We should aim for understanding, not bug counts. We talk about storytelling, simple reports that people can read, and mixing engineering with empathy. Testers work across disciplines, explore, and make sense of messy projects. Perfection is a trap. Good enough can be great. Balance logic and imagination, and you get impact that reaches beyond tools.

In this episode, I talk with Clara Ramos González about how self-care can raise quality and agility. We look at why communication failure still breaks projects and how breath can fix more than tools. Clara blends QA leadership with yoga and brings simple rituals to teams. Three deep breaths to open meetings. One word to set intention. Weekly coffee talks without work. A feedback rule to sleep on it. The message is clear. Bring your whole self. Lead by example. Small steps cut stress and help us build better software and healthier teams.

In this episode, I talk with Mesut Durukal about picking the right end to end test automation framework. Mesut shares why tool choice must serve real needs, not trends. It is a mindset shift from hype to needs. In his case users were on Safari, the team tool did not run there. He mapped needs, compared Cypress, Playwright, Selenium, TestCafe, and Nightwatch, and chose Playwright for speed and broad browser support. We talk about reporting, debugging, and docs. We touch on architecture, like keeping login and helpers outside specs, so migration stays clean. For me, this is tech with agility. Know your goals, grow your system, and review choices often.

In this episode, I talk with Chris Armstrong about context in testing. We talked about why "it depends" is an honest answer in complex work. Chris shows how decisive humility helps. Say what you do not know. Find the people and data to learn fast. We talk about fear, optimism, and why winners collect more failures. I ask how testers grow influence. We land on trust, social skills, and asking better questions. Challenge tools and processes with respect. Start small with clear hypotheses and visible outcomes. Remove unnecessary friction. AI comes up as a fresh field for testing. Join early, shape it. Stay curious. Context moves, and so should we.

In this episode, I talk with Gáspár Nagy about behavior driven development. We look at why a simple example can beat a specification. You do not learn soccer from a rulebook. You learn by playing and watching plays. BDD uses the same trick to build understanding early. We discuss example mapping, writing readable scenarios, and turning them into executable specs with Cucumber, SpecFlow, and Reqnroll. Done well, this guides vertical slices, shows progress, and stops the mini waterfall at the end of a sprint.

In this episode, I talk with Daniel Knott about the real pains in testing and what comes next. Why do managers cut quality when money gets tight. We look at AI and low code that spit out apps fast, often without clear architecture. We warn about skipping performance and security. We also reflect on how testers can sell value in business terms. Speak revenue, KPIs, and user happiness, not code coverage. Daniel says domain knowledge may beat deep coding as AI writes more code. We explore prompt reviews as a new shift left habit.

In this episode, I talk with Kat Obring about the tester as an influencer. We explore how to stop saying everything is broken and start speaking the language of stakeholders. Bring evidence, not opinions. Say "the Safari sign up button fails and 20 percent of users are blocked". We share a 15 second check before stand up, and pairing early so testing is part of development, not a mini waterfall at the end. Pick small battles and run one or two week experiments. If it works, keep it. If not, drop it. Influence without authority grows from trust and habits.

In this episode, I talk with Maciej Wyrodek about moving from Cypress to Playwright. We talked about why Cypress started to work against the team: opinionated style, plugin churn, iFrames, flaky screenshots, and a pricing wall around parallel runs. Maciej's answer was a hands on hackathon with devs and testers. Playwright won. The migration starts with their top 10 flows and production smoke checks.

In this episode, I talk with Gitte Ottosen about cross functional teams, quality engineering, and how deep skills fit in agile work. We question the Everyone owns quality mantra. If all own it, who does the hard parts. Gitte calls out mechanical agile and the comb shape myth that makes people wide and shallow. We talk about what Scrum expects from a team and why testers still bring sharp value. AI may take easy tasks, yet we need critical thinking and solid test design to judge its output.

In this episode, I talk to Maroš Kutschy, a QA technical lead passionate about automation testing and self-improvement. We go into the topic of nonviolent communication and its impact on tech teams. Maroš explains its four core components: observations, feelings, needs, and requests. We discuss how simple changes in language can greatly improve team dynamics and communication. For example, he illustrates how expressing yourself without blame opens up clearer dialogue.

In this episode, I talk with Dmitrij Nikolajev about teaching software testing to the next generation. Dmitrij, who balances roles at InSoft and Vilnius University, shares his approach to making software testing engaging for students. He focuses on practical, hands-on experience, using tools like Postman and Selenium to teach automation and performance testing. Dmitrij redesigned his course to appeal to both new learners and those already in the industry. He leverages real-world examples to highlight the importance of testing, encouraging students to understand the consequences of failures. We also talk about the role of AI tools like ChatGPT in the learning process and their impact on student progress.

In this episode, I chat with Mary Lynn Manns about the ever-tricky topic of change in tech. Mary Lynn is a consultant, pushing ideas forward despite resistance. We explore why good ideas alone often aren't enough and why change can falter when we rely solely on logic and ignore emotions. We discuss how to effectively engage skeptics and build emotional connections that go beyond simple presentations. Mary Lynn shares practical techniques for leading change from any role, aiming to minimize resistance and maximize impact.

In this episode, I chat with Derk-Jan de Grood. We explore what it means to live agility beyond just following frameworks. Derk-Jan shares insights on scaling skills over frameworks and connecting strategy to team actions. We discuss common pitfalls where quality often falls through the cracks, particularly at the management level. There's a focus on breaking down testing and improvement into small, actionable practices. It's all about making Agile effective and meaningful.

In this episode, I chat with Nikhil Barthwal about property-based testing. We go into how property-based testing can uncover the hidden bugs that often slip past human testers. With its capacity to automatically generate a multitude of test cases, this method helps us see beyond typical limitations. Nikhil also shares when property-based testing may not be ideal, like when it incurs high resource costs. He emphasizes that this approach serves as an assistant to testers rather than a replacement, enhancing productivity and reliability.

In this episode I talk with Eoin Woods about integrating security from the start of software development. Eoin, an expert in software architecture, explains why security often gets overlooked until the last minute. We explore why engineers find security daunting and discuss making it a standard part of development. Eoin shares design principles like defense in depth and cautions against custom security solutions.

In this episode I talk to Gien Verschatse and Kenny Baas-Schwegler about the challenges of collaborative software design, especially the disconnect between development teams and business stakeholders. Both Gien and Kenny shared stories of communication gaps, assumptions in requirements and the constant struggle to build shared understanding. They gave practical tips for breaking down silos and making modeling sessions actually work - not just as visual exercises, but as real opportunities for teams to learn together.

In this episode, I talk to Ben Linders about what really drives team autonomy and effective software development. We get into team culture, the importance of psychological safety, and why diversity matters - not just as a feel-good topic, but as a genuine catalyst for change. Ben shares practical tips from his workshops, discussing how teams can move from being stuck to taking meaningful action. We discuss, how to avoid that sticky notes from retrospectives gather dust and how to make results visible, keeping actions manageable, and introducing a little bit of fun through gamification.

In this episode, I talk to Lisa Crispin about holistic testing and what it really means for teams striving for better software quality. Lisa brings her experience to the conversation, sharing how testing is much more than a stage or a checklist - it’s a mindset that weaves through every part of the development process. We dig into the practical side: how teams can focus on both internal and external quality, the value of strong relationships, and the power of good questions. It’s clear: true quality comes from collaboration and curiosity, not just tools or process. There’s a lot for teams to rethink here.