QA Testing Mistakes You Should Avoid Making

Branimir Hrzenjak
11 minutes
Reading time

Quality assurance (QA) testing is a crucial step in ensuring that an app functions and performs well—helping find and fix defects before releasing the product to end users.

However, despite the importance of QA testing, many teams struggle with identifying and avoiding some common mistakes that can negatively affect this process.

This article aims to shed light on five QA testing mistakes that developers, QA specialists, and testers often make and give you helpful tips on preventing them.

Read on if you wish to learn more about these mistakes and how to avoid them.

Saving QA testing for last

A common mistake that many businesses make is postponing the QA testing phase to the very end of development.

Waiting until the end of the software development life cycle (SDLC) to do the QA testing can be a critical oversight, as by the time the app gets tested, it may already be filled with bugs and defects that are costly and time-consuming to fix.

As the founder and CEO of Functionize, Tamas Cser, writes:

As time passes and the code moves to later stages of development, it becomes more challenging for developers to remember all the details and locate issues before they can be fixed.

Instead, QA specialists need to unite their efforts with developers to prevent bugs from appearing in the first place.

To facilitate this process, you might want to use a shift-left approach to QA testing.

Shift-left testing is a highly popular approach that ensures QA testing is done from the very beginning of the SDLC, preventing bugs from appearing or catching them early and quickly and having developers resolve them.

To implement this approach, QA specialists need to work on the project from the start.

shift-left approach to QA testing
Source: OurHints

The shift-left model begins testing from the requirement-gathering and design phases of development, while the traditional waterfall approach leaves these activities for the very end.

As illustrated in the above graph, the result of shifting left is that QA testers can spend less time testing at the end of the project’s life cycle, since by that point most bugs and other issues will have already been prevented or fixed.

Bug and crash reporting tool for your mobile app.

In comparison, the typical model has the testers start working on the project at later stages of the project.

If many bugs are found at this point, it can cause numerous problems and significant production delays as testers and developers scurry to resolve the issues before release.

Overall, using the QA team early on and having them test the app from the start can be a great way to prevent problems and defects and maintain the app’s quality during the entire software development process.

Neglecting QA documentation

Another crucial mistake that many make in the QA testing phase is not paying enough attention to the documentation.

The QA testing process should be properly organized and managed, and focusing on writing useful and clear QA documentation is a crucial way to achieve this.

As one Quora user writes about the usefulness of QA documentation,

Quora quote
Source: Quora

Neglecting these documents leaves testers and developers without a clear guide to follow to focus their efforts effectively, creating a lack of direction and consistency in the testing process, and making it difficult to identify and fix issues.

To prevent this, QA documentation should be prepared way before the testing phase of development begins and should be frequently updated.

The QA documents that QA professionals and testers need to account for include:

testing process
Source: ScienceSoft

Being familiar with and learning more about the different types of QA documentation can be a useful practice that can help QA teams ensure nothing essential gets missed.

QA documentation can help guide teams throughout the various stages of development by

  • Helping them follow a clear testing strategy in the planning stage
  • Ensuring that effective test cases, checklists, and guidelines are created in the design phase
  • Helping with the execution of tests and ensuring proper reporting of results, with straightforward testing protocols and bug reports

If you want to learn more about these documents and how to help QA teams and testers effectively write them, read our article on how to write great QA documentation.

In summary, proper QA documentation is essential to a smooth testing phase—the documents covered above are a great and helpful blueprint for testers and developers to follow during the entire process.

Failing to review test cases

The test case is a set of actions by which parts of a piece of software are evaluated, and as such it constitutes an important part of QA documentation.

As test cases can be reusable, testers can get into the habit of using the same test cases over and over again, even if they’ve stopped detecting new bugs and defects in the software.

This practice calls upon the pesticide paradox—a concept developed by Boris Beizer in his book Software testing techniques, writing that:

Boris Beizer quote
Source: Shake

Simply put, when testers run a test case, it is effective at detecting a number of bugs and defects in the software—however, running the same tests repeatedly won’t help find any new bugs that weren’t caught in the first place.

This way, a small number of harder-to-find issues can pass unnoticed and stay that way until the software is released to the public.

To remedy this problem, QA teams and testers need to remember to occasionally review the test cases and test suites they’ve made, adding new cases and updating the existing ones to increase the chances of finding the more subtle bugs that might otherwise slip through.

So, how do we ensure that the QA and testing team works with an effective group of test cases?

These teams can follow a couple of general guidelines that can help them ensure they are using useful test cases.

general guidelines for testing
Illustration: Shake / Data: PractiTest

Using old test cases to test an app, even when it’s constantly changing, can cause testers to miss some bugs that were introduced as a result of previous changes, either directly or indirectly.

QA specialists and testers need to keep track of these changes and think of any new cases they need to write and implement, discontinuing any test cases that may have become ineffective and aren’t useful in finding bugs.

Moreover, test case data should be modified when necessary, with actions such as:

  • Using valid and invalid data as inputs
  • Adding an unexpected amount of data as an input
  • Using non-standard data such as special characters and symbols
  • Adding some random data in the mix

Finally, not all test cases need to be rigidly made, as some informal test cases can allow for more flexibility in the testing process—requiring testers to have a more analytical and varied approach during testing.

Test cases need to be reviewed and updated constantly, as no suite of cases can be made perfect and detect all software bugs no matter how the product changes over time.

Failing to communicate properly

The QA testing process, especially when implemented early on, is a collaborative practice that requires effective communication between different professionals within an organization.

This process can get disorganized and frustrating very fast when QA and testing teams fail to communicate with other departments—particularly when they don’t interact well with developers.

Why is the interaction between QA testers and developers so important?

To help you understand, let’s look at some issues you can encounter when these two teams struggle to communicate.

interaction between QA testers and developers issues
Illustration: Shake / Data: Plutora

As you can see, these four behaviors can negatively affect the workplace—impacting the well-being of employees and lowering the productivity of both QA testers and developers.

An adversarial work environment without effective communication can be stressful and make individuals feel burnt out, be less productive, and do redundant work as they are not updated on each other’s work status.

One of the practices that can improve the communication and collaboration between testers and developers is to create open communication channels between the two.

Your organization can do so by focusing on the three communication channels separately.

three communication channels
Illustration: Shake / Data: KnowledgeHut

The easiest of the three to affect are the formal channels.

Through these, testers and developers communicate things like project status updates, test results, bug reports, and testing strategies.

To facilitate this type of communication, your organization can:

  • Schedule regular meetings between these two teams so they can discuss their progress and any roadblocks they’ve encountered.
  • Establish clear documentation practices—ensuring everyone is on the same page.

To improve informal communication, your organization can try creating a pleasant work environment with open-door policies that encourage more casual interactions.

This will make individuals more comfortable interacting with each other and asking questions about work and non-work related issues.

As the unofficial channels go, there’s little you can do here, as this communication happens outside work.

Another thing your human resources team can try is planning team-building activities to help create and maintain friendly bonds between colleagues.

Inefficient communication between developers and testers can result in a slow, frustrating, and mistake-ridden QA testing process, so focusing on improving the way your testers and developers interact with each other is extremely important.

Not standardizing bug reports

One way testers and developers often communicate is through bug reports.

As the primary purpose of the QA testing process is to find and resolve bugs effectively, testers need to write clear, standardized bug reports to aid developers in their bug-fixing efforts.

Not having a predetermined structure for bug reports and leaving it up to testers to decide how they will write the document for each bug can lead to incomplete reports that don’t include all the necessary details to be of any use.

Through standardization, this problem is alleviated.

Standardization enables testers to develop the report while providing a uniform format to developers so they can easily find what they are looking for consistently.

To write bug reports in this manner, testers can use well-made bug reporting templates—for example, here’s a template for the popular bug tracking and project management tool, Asana.

Asana template
Source: Asana

By using templates that include all the essential information a comprehensive bug report needs to contain, testers don’t need to think every time they write a new report and just fill out the fields with the appropriate information.

While this is an excellent way to write standardized bug reports, using a template still requires testers to switch between looking at the app and entering data into the template, which adds unnecessary steps to the process, reducing overall efficiency.

Using a third-party bug reporting tool can be a better solution to this problem.

A tool such as Shake allows testers to submit bug reports to developers directly within the app by shaking their devices when a bug or crash occurs.

Shake also reduces the amount of manual data entry, as it automatically collects and attaches over 70 data metrics to reports, including:

Shake screenshot
Source: Shake

For example, one valuable piece of information that is automatically collected is the set of actions or steps the tester took before the bug or crash occurred.

This allows developers to see the tester’s specific taps on the app’s user interface and recreate them when necessary.

In summary, bug reports are important documents that provide beneficial information to developers and, as such, need to be made uniformly—using templates and tools such as Shake as valuable assets.


As you can see, QA testing is a complex activity with many different components, and many preventable errors can be made if not careful.

Making these mistakes early in the QA testing phase may have a negative impact and interfere with the entire testing process, reducing the quality of your application as a consequence.

Therefore, you’ll be wise to keep the tips we’ve discussed in mind and try to help teams and individuals from making these oversights.

There are many more mistakes to talk about, but we believe that addressing the ones we covered is an adequate starting point to improve the QA testing process and make it more efficient and effective.

About Shake

Shake is a bug and crash reporting tool for mobile apps. It was founded in 2019 with the mission to help app developers spend less time on debugging and manual overhead — and growing daily since thanks to a small and dedicated team of geeks based in the EU.

Meet your favorite bug and crash reporting tool.

Add to app in minutes

Doesn’t affect app speed

GDPR & CCPA compliant