Exploratory testing marks the connection where creativity meets discovery. This method isn’t just about ticking off a list - it's about venturing into the unknown, armed with curiosity and a keen eye for detail. It's a journey that's best embarked upon as a team, where each member's unique perspective and expertise illuminate different facets of the software, uncovering insights that might otherwise remain hidden.
How to organize exploratory testing sessions as a team
"If you want to achieve something, you work alone; if you want to achieve excellence, you work as a team."
The above principle lies at the heart of exploratory testing. The true essence of this approach unfolds when team members collaborate, using their collective knowledge to uncover software bugs and improvements.Team Exploratory Testing is helping everyone involved in the sessions improve their testing skills and gain confidence when facing testing tasks. These newly acquired abilities are helpful when new tasks arise. This activity is a valuable resource for Shift-left testing.
1. Organizing the virtual meeting
In our journey of implementing team exploratory testing, we set up a virtual meeting space, inviting multiple team members —developers, designers, and even customer support—to bring diverse insights to the table. Before diving into the session, we prepare a dashboard outlining the key focus areas, known bugs, and testing boundaries. This is all about setting the stage for what we're diving into.
2. Starting the exploratory testing session
Our exploratory testing sessions are meticulously planned to balance depth and efficiency, typically involving around 12 participants and lasting about 60 minutes. Each session starts with a 10-minute introduction that guides everyone through a quick dashboard, laying out the session's scope, highlighting known issues, and pinpointing specific areas we aim to explore.
This initial segment is crucial for aligning the team's focus and ensuring a productive session. Following this, we dive into the core of our exploratory testing for 30 minutes, with each team member independently testing the application. The participants have complete freedom to test the most interesting flows according to their knowledge and with their information. This freedom means that each participant’s unique knowledge and vision are used to contribute to quality.
We stay connected through the call, ready to bounce ideas and findings off each other. This way, it's not just about testing in silos but creating a live, collaborative environment where insights can be shared freely and instantaneously.
3. Debriefing the session
The concluding 20 minutes are reserved for a comprehensive debriefing, as we uncover issues, we discuss them then and there, categorizing each finding to determine its impact. We categorize them based on their severity and discuss the next steps.
This structured approach not only optimizes our testing efforts within a limited timeframe but also fosters a culture of collaboration and continuous learning among team members.This process is not just about identifying bugs; it's a shared learning experience that tightens our team bond and deepens our collective understanding of our project.
It’s truly a collaborative effort that not only broadens our testing scope but also enriches our team dynamics and, ultimately, leads to crafting a more solid product for our users.
Collaboration between developers and testers
Integrating developers and testers into a cohesive unit has been a transformative journey. Initially, getting developers to engage with testers was hard because their work was separate. Through continuous effort and structured collaborative sessions, we've seen a shift in mentality.
Exploratory testing can be effective and I try to have fun during the session; developers usually don't enjoy testing as much, so it's important to have testing and also some fun. Leading these sessions, I often choose the developer who usually hates testing, and the rest of the team pitches in and asks what to test, turning reluctance into active participation.
There was a shift in mentality from “test it all together” to “testing collaboration”. This evolution has led to a more integrated approach, where working with two different teams can be challenging; it's not only about the testing; collaboration needs to be there because when we collaborate, we identify new scenarios.
This newfound collaboration between developers and testers changed how we see our roles in the development process. Before, there was a clear line: developers built, and testers, well, we tested. Nowadays, working together shows its importance as we discover issues collectively that we might have missed working alone.
It’s like we’ve opened up a new level of communication where everyone is more involved and invested in not just doing their bit but in understanding and contributing to the entire cycle.
The walls have come down, and in their place, we’ve built bridges, making our project not just a collection of tasks to be completed but a shared mission where everyone’s input is vital. This shift hasn't been overnight, and it hasn’t been easy, but the results speak for themselves: a more cohesive team, a better product, and a work environment where learning from each other is just part of what we do.
Exploratory Testing and remote work
Addressing the logistical challenges of collaboration, especially performing exploratory testing in a remote setting, requires thoughtful organization. We are all working remotely. I create the dashboard that will be used during the session, and I share my screen to explain the dashboard and all the data, possible tests, and issues. This preparation ensures that everyone has that link - there's info they can check before the session like user story mapping and issues, making every session as efficient and informative as possible.
Adapting to remote work has introduced new dynamics into our exploratory testing processes. The way our sessions are organized has helped with remote work. We need to connect and take full value from our stand-up meetings. This adaptation has been crucial in maintaining the momentum and effectiveness of our sessions, despite the physical distance between team members.
Achieving effective collaboration in Exploratory Testing
When we wrap up our exploratory testing sessions, it's like we've just finished a group adventure. We look at what we've discovered together, and it's clear how much we've achieved. The session's outcomes - improvements go into the backlog - and critical defects go to development. This isn't just about fixing bugs; it's about building something better together.
My team gathers every three weeks—Product Managers, Designers, Team Leads, and all, totaling 12 people. This mix makes sure we're looking at our software from every angle, catching stuff we might miss if we were going at it alone. But it's not just about spotting what's wrong. These sessions are about growing and learning as we go. We're not just a team; we're like a classroom where everyone is a student and a teacher. We've got this rhythm going, meeting every three weeks, and it's turned into something we all look forward to. It's our chance to dive in, explore together, and return with our findings. And every time, we're not just fixing issues; we're making our software—and ourselves—better.
This way of working together has made a real difference, especially working remotely. We've had to be creative, finding new ways to connect, share our screens, go through the dashboard together, and really make sure everyone's on the same page. It's made our meetings invaluable and truly improved our team bond and our work.
The best part? We're seeing the impact. The quality of our work is up, the team's morale is high, and there's this sense of pride in what we're doing. It's not just about the bugs we catch or the issues we fix. It's about how we're doing it together, learning from each other, and strengthening our software and team.
Looking ahead, the path of exploratory testing is one of endless discovery and improvement. If I can leave you with something to help improve your collaboration in exploratory testing it's this: just try. Learn during the session. Don't obsess over the final result of the session. Observe, share your knowledge, and continue to try different things. This philosophy reflects our approach to exploratory testing — a journey not just of finding bugs but of fostering growth, collaboration, and excellence within your team.
