Improve onboarding with Exploratory testing

Onboarding might not be as easy as we want it to be, not only for the person joining the company, but also for the members who will support their new colleague.  

Onboarding is a complete process that includes integration into the company structure, processes, values, vision, and of course, learning about a developing product. While operational routine is usually settled and stays stable, learning the ins and outs of an actual constantly-developing application—or any other digital product—is like trying to jump onto a running train.  

How can we make sure onboarding is not only the reading of countless Confluence pages and going through Jira, code repositories, etc., but also an interactive learning process that allows us to pick up the development mindset and user journey in a shorter time? 

Application programming itself became more and less complex simultaneously. We now have more technologies on our collective plates, more Quality Assurance and Business Analysis approaches that we can apply to different product development stages. In a way, it is challenging to find what would be a match to satisfy both development and business needs.  

The upside of this is that we have the opportunity to use those approaches and best practices to serve different purposes, including improvements for internal processes. While introducing colleagues to the techniques used by other departments, or to roles, we learn from each other and expand our product development mindset. 

One of the Quality Assurance testing techniques, Exploratory testing, might be a good match to use for onboarding. ‘Why Exploratory testing?’ you may ask. The idea of Exploratory testing is to learn and explore software at the same time. This entirely corresponds with the general onboarding goal, which is understanding built software. 

A briefly explanation of Exploratory testing 

Exploratory testing is an approach where you focus on test execution without creating test scripts in advance. It might seem this approach doesn’t have any kind of structure, but this perception is not necessarily true.  

There are some basic questions we can ask ourselves before performing exploratory testing:  

• What do we want to test, learn, or challenge? It can be a small piece of the application or some larger functionality. Maybe it’s the UI or the end-to-end user journey. That answer should be based on both the team’s and product’s needs. An even better question is ‘What would be the best to test?’.  
• How long should a testing session take? It depends on how much time we have available. There are no specifically accepted time boundaries. The only thing we should remember while planning is that the session needs to be time-boxed. 
• Do we know how we want to test? There should always be an idea of how we will do our testing, what tools will used, and how we will log the results. All of these need to be decided beforehand. 

Answering the above questions brings clarity and helps us plan the first steps for Exploratory testing sessions. Of course, there is more information to be found on the internet to help guide you through this topic. 

How to explore while onboarding  

Undoubtedly, a newcomer in a team has that fresh, non-poisoned-by-requirements perspective of the developed application. It would be a shame to waste this brief potential. Whether this person is a Product Owner, a Business Analyst, or a developer, junior or senior, anyone can perform Exploratory testing.  

The first couple of weeks are usually the most challenging for a new teammate, especially in terms of learning and setting up relationships with new colleagues. As a person who is involved in the onboarding of a ‘newbie’, you can create a set of Exploratory testing tasks. Each task covers a piece of functionality or a particular product characteristic. To create such an onboarding task, the questions mentioned above would be a good source of inspiration. 

Let us take a closer look at an example below. 

Task: perform exploratory testing for Checkout page. 

Context: the product is an eCommerce website that sells manufactured goods. 

Perform exploratory testing for the Checkout page functionality on our Acceptance/UAT environment.
Testing session is time boxed to 30 minutes.
In case of any questions about functionality itself and the testing environment, you can ask George, our Python developer, and Krissy, our QA Engineer.
While performing exploratory testing, you may look at user experience and UI behavior. Are there any potential areas for improvement?
Results can be logged in a free format and discussed afterwards with James, the team’s Product Owner.  

Within this small task, there is an opportunity to analyze a piece of the application from different perspectives, and to find out if a Checkout page is understandable and intuitive to use. 

So, a new team member can form an opinion about it and share it with others. But it’s not only about getting to know a Checkout page, it is also about becoming familiar with development environments, getting to know future colleagues, and building work relationships. Team members, by sharing knowledge and answering questions, embrace an open mindset and show, in this way, that the team is a safe environment to learn and work.  

Exploratory testing is one of the examples of how Quality Assurance methods and activities can be used for multiple organizational and software development pursuits, including the very beginning of a new position journey – onboarding.