Exploratory Testing with the Team: The Sequel!

As luck would have it, one of the developers I worked with during the time I was doing experiments with getting my whole team hooked on exploratory testing is now also working at my current client. He came to my desk and asked if I was interested in teaching his team about exploratory testing, because he felt it would be very useful. Great to hear, of course! I was faced with a new challenge though. How do you set up an exploratory test session without any domain knowledge? Would it even be an issue? In this blogpost, I’ll walk you through what I did to make the session a successful event.


First of all, what really helped was the enthusiasm this particular developer displayed for exploratory testing. He knew what strings to pull and with which people we needed to have a chat to get this thing off the ground. We started by getting some people together and explain to them why we wanted to do a test session that was more structured than they are used to (they are used to doing ‘break the app-sessions’, which translates mostly to ad-hoc testing). I made the case for giving people a mission (a focus area) during testing (the mission/charter), so they would end up doing a targeted deeper coverage test session instead of superficial coverage on a broad area. After the people who had a say about how the team spends its time were convinced, we planned the location, time and duration of the session.

Next, we looked up a domain expert. I knew next to nothing about the application under test this time, which made me slightly uncomfortable. I needed the domain expert to tell me where she thinks we should focus our test efforts. This conversation was kind of hard. It was clear the domain expert knew a lot about the application, but she was definitely no tester. We had communication problems, basically. The way she tests the application seemed quite random to me, she described it as she ‘just knew where the problems would be’. Intuition based on experience, I guess? But for other people to get value out the session we would need to help them. I needed to get her tacit knowledge into the explicit domain (the trickiest part of testing! How to communicate effectively about it). I started asking her questions, like “what are the risky parts of the application in your opinion?”, “are there any returning bugs on production”, “where do you go first when you start testing the app”. After half an hour, we had quite a lot of test missions written down.

More conversations with developers gave me some ideas about where technical risks might be, so we wrote a couple of charters on that too. And finally, my own expertise in certain areas also helped. We wrote a couple of generic charters that focus more on quality attributes and general areas I always focus on: UX, error flows, looking for time-outs etcetera.

The session

The room and lunch were all arranged by the developers. We also made sure there were plenty of devices prepared with the right build of the application. People literally just had to show up and test. I started the session by giving an introduction to Exploratory Testing again, that took about 10 minutes.

developers testing

After that, it was testing time! In about an hour, we found sixty bugs. Of course, some developers fell into the pitfall of not documenting their steps enough and weren’t able to reproduce some bugs. Other developers got a bit into despair mode when they saw how many bugs were found. Jokes like ‘Toss this app in the bin’, ‘Who the f wrote this crappy app?!’, ‘After the test session I am going to change my rating for this app!’ could be heard. I walked around and gave hints and tips wherever possible. Mostly I said “have you documented anything??”.

It was all good fun. The atmosphere was relaxed, people were into it and we got value out of it. They want to do a session like this again. I think it is better if they would incorporate exploratory testing in their everyday work, instead of waiting to do a big session before a release. Another developer suggested that they could do it during code reviews and it makes sense to me. A code review is a form of exploratory testing in my eyes, so why not add a little bit of extra testing to that?

Next steps

This session was only with Android developers. I’m probably going to do another session with the iOS developers. I’m also curious to the reception of the event. Right now, all the bugs have been logged, but no decision has been made yet which ones are going to be solved. Since six teams are involved, I am foreseeing some difficulties in that regard (defect ping-pong, anyone?). I’m especially curious as to how the enthusiasm of the developers will fluctuate over time. I will keep you posted!

5 thoughts on “Exploratory Testing with the Team: The Sequel!

  1. Hey Maaike,

    interesting read on a subject I know way too little about. Two questions that popped up:

    * Sixty bugs in an hour is either a lot or not that much. Were those sixty bugs genuine bugs or sixty occurrences of ‘hey, that’s not how I interpreted the specs’? Did you do any classification or evaluation of the bugs that were raised in the session?

    * How would exploratory testing during code review work? I literally have no idea. Code review is static, and to my knowledge the testing activities you described in your post would require you to run the application?

    Thanks for clarifying!

    1. Hey Bas!

      Sixyt bugs indeed doesn’t mean much yet, before analysis. Unfortunately, I will not be present during that. Since I’m not in the team, the ‘aftermath’ will be done by the developers + PO. I would have tried to get myself involved, but the Agile Testing Days are around the corner, so yeah…

      And about the code review thing. I don’t think testing is an active activity only. Static testing can be valuable as well, as code reviews prove time after time. To me, testing is about uncovering information and then doing something with that information. In a code review you try to uncover information about how code can be problematic (bug prone maybe), should be cleaner, isn’t correct etcetera (you probably have more experience with this than I do, anyway). This information is then used to change the code. Seems like a testing activity to me! So, if the developers could take this a little further and actually run the code and do some testing that way as well it will take a code review to the next level.

      1. That makes perfect sense.. Again, thanks for clarifying. I sometimes feel like I’m slowly drifting away from the testing world, and reading blog posts like this helps me in keeping (sort of) up to date 🙂

Leave a Reply

Your email address will not be published. Required fields are marked *