How To Improve The Manual Testing Process?

Your main task in the project as a developer is to deliver new functionalities planned in the sprint. Sometimes you'll pay off technical debt. Other times, you'll fix a bug.

What about QA team routine work improvements? Today, we'll talk about how you can help your QA team become more efficient.

What’s the problem?

Every task that a tester has to perform manually takes valuable time—time that we won’t get back.

And what if the testers can't keep up? What is the result then?

• The queue of tasks waiting for testing grows, increasing the risk of not completing the planned tasks in the sprint.
• Developers wait for their tasks to be reviewed, which raises the risk of conflicts in pending PRs (assuming the feature branch must be tested first).
• An increasing PR queue (same assumption as above).
• Slower product increments.
• Decreased team productivity.
• Testers will perpetually lack time to pay off their technical debt.

And the list could go on and on. To minimize these risks, it would be wise to make the best use of the testers' time.

So how can you help them?

Review the project backlog.

The quickest way to assist is by reviewing the backlog for tasks that could improve the testing process. Look for tasks that a developer can handle (not every tester can code), such as those related to scripts or changes in the CI/CD process. It's possible that such suggestions have already been made at some point in the project.

Prepare a list and check with the QA team for their relevance. Close out any tasks that are no longer necessary. Discuss the relevant ones with your lead and suggest increasing their priority. Be ready with arguments to help convince them to take action.

Just talk to the QA team.

The next step should be consulting with the QA team. Their knowledge and experience in the project are crucial. They are aware of the pain points in their daily work. There's a good chance they have plenty of suggestions but haven't communicated them for various reasons.

And it's important to guide this conversation well. Keep in mind that there are things we don’t know that we don’t know. Therefore, you need to spark their imagination and offer some initial thoughts.

Asking these questions can help:

• If you could improve anything in your work from a technical standpoint, without worrying about budget or time, what would it be?
• What tasks do you repeat with every test?
• Where do you lose the most time during testing?
• Which functionality is the hardest to test during regression testing?
• What doesn’t work as it should when releasing new versions?
• Was there anything in a previous project that worked better than it does here?

Identify repetitive tasks.

Anything that is repeated frequently is a good candidate for optimization. There are processes that you can automate, to varying degrees. As a developer, you do this every day while working on the project. Think of all the automated actions already in place...

Now, bring this approach to the project and the QA team.

Turn the insights from your meeting with the testers into actionable tasks, and inform the project lead about the initiative. Don’t stop there. Monitor whether the improvements are progressing as planned, and intervene if necessary.

Focus on what’s important. There’s no point in automating something that is done infrequently, is of low importance, and would take days to automate. However, for tasks that are rarely performed but are critical, where mistakes are not an option, it’s worth implementing some form of automation.

Testing Process

If your team has a summary or diagram of the testing process, that's great. It's worth ensuring that it’s optimized. Maybe some changes are needed? Pay special attention to areas requiring a developer's work or those that depend on them. This could be a good topic to bring up with other developers. A dev meeting would be ideal for this.

If there’s no solid process in place, suggest creating one. This will allow everyone to see how it really looks. Practical ideas for optimizations might arise.

Examples of Features that facilitate testing

Not every example will make sense for your project. The target platform dictates its own rules. What might be an issue in mobile might not be in web (and vice versa).

This suggests that having "dev options" is valuable. In mobile applications, this option can often be activated, for example, by entering specific login credentials.

API Response Preview

In more complex projects and functionalities, it can be helpful to check the base model used from the API within the application. This is especially true when complex calculations are performed on the frontend. It's beneficial to see in a live environment what the "base" data was used for these calculations.

Overwriting user data

Sometimes, the state of the application, available functionalities, or how they operate are controlled by what the user has set in their profile or settings. When testing scenarios, it might be useful to have the ability to overwrite specific key values. This is a handy feature.A special screen listing all keys would be great. Selecting a specific key should allow entering the desired value. The new value would be used to overwrite the one received from the API.

Quick login data entry

When an application supports many types of users, it requires a lot of testing. Manually entering login data can be time-consuming. Even if you have a list of accounts with specific characteristics, entering them takes time.After enabling developer options in the application, an additional button can appear on the login screen. Clicking it would bring up a screen with a list of accounts. Each entry includes information about the login, password, environment (e.g., preprod, prod), and a brief description of the account (if it has certain important settings). Clicking an entry automatically fills in the login and password fields. Quick, easy, and convenient.

Saving network traffic to a file or sending it to a server

Saving what goes in and out of the application can be useful when analyzing some problems.

Building a new test version

Certain improvements can easily be introduced during the build process of the test version. The tool you use to build can allow, among other things:

• Selecting the default environment to which the application will connect.
• Changing the contents of configuration files (identifiers, URLs, etc.).
• Enabling experimental features.

Implementing improvements is great!

As I often repeat, every sign of team activity you show adds up to better visibility within the team. Even if it’s not immediately noticeable, you’ll gain a lot over time. It’s like a snowball. You start with a small snowball, ending up with a huge one.

Setting aside the immediate rewards, helping make the team’s work easier will pay off in the form of gratitude from those you help. That’s a wonderful reward.

Thanks for your time!
~KB