Skip to main

Why QA is a Necessity at Every Stage of Your Project

by Kasia Gorochowik

Why QA is a Necessity at Every Stage of Your Project

For many, a QA Engineer's role only brings to mind the development phase, when testers verify all aspects of the software, such as the system’s functionalities. Involving QA earlier on in the project is often seen as an unnecessary, additional expense.

This approach couldn’t be more wrong.

Every Development Team member has unique skills and experiences that bring diversified and valuable perspectives to business requirements, hence all of them should be included from the very beginning. QA Engineers bring value at every stage of the project and can in fact save time and money by pointing out deficiencies from the start.

In order to fully understand this, we need to take a closer look at all the phases of the Software Development Life Cycle (SDLC) and the role that QA plays in each of them. Let's get started!

Copy link
Quality Assurance in the SDLC

1. Requirements Analysis

During the requirements analysis phase, a QA engineer can identify any irregularities and/or deficiencies in the requirements and therefore pinpoint defects before their implementation. 

At this stage, QA engineers:

  • analyze whether the requirements can be integrated within a single system,

  • advise which solutions will or will not work,

  • plan the required testing stages and techniques.

Involving QA engineers in the requirements analysis phase ensures that the documentation can be consulted with the client at an early stage. 

This is also the time when QA engineers create a test plan – a document that describes the project’s overview, roles, and contact points and defines the testing and execution strategies.

The testing strategy includes:

  • test objectives

  • risks

  • the scope

  • types of tests to be executed

  • bugs classification

  • test deliverables

The test plan also should also define the execution strategy, including entry and exit criteria, test cycles, test environment, and testing tools. 

2. UX/UI Design

It’s essential for QA engineers to work closely with the system designers as it increases their understanding of each part of the design. 

At this stage, QA engineers can verify the design details, such as the functional logic, data structure, and dependency issues. This reduces the risk of fundamental design flaws and allows us to identify errors at an early stage. During this stage, QA engineers also set up a test environment and create test cases.

3. Implementation

Testing during the implementation phase gives an opportunity to evaluate every task and module right after its creation.

This enables introducing corrections without having to wait for the entire application to be ready. Such a step-by-step (or task-by-task) approach is beneficial as separate modules are relatively easy to fix and early fixes pose no threat to the rest of the application.

4. Testing

Verifying and validating the software before its release helps to detect errors that could have gone unnoticed otherwise, and support the process of eliminating the defects.

Testing should ensure that each function works correctly and that different parts of the application work seamlessly together.

The system should also be tested for unexpected conditions to make sure that it can handle these situations well. The testing phase helps reduce the number of bugs and glitches that users encounter which leads to higher user satisfaction and a better usage rate.

5. Deployment

Once the product is tested, it is either deployed in the production environment, or the first UAT (User Acceptance Testing) is done, depending on the customer's requirements.

In the case of UAT, a replica of the production environment is created and the customer (or selected users) tests the application.

QA engineers help to plan UAT, provide tools and methodologies, and give all necessary assistance needed by the client to execute the tests. Once UAT is finished, QA engineers verify whether the reported issues are correctly described and reproducible, and then the defects are fixed based on priority. If the customer finds the application as expected, then sign-off is provided to go live.

6. Maintenance

This phase occurs when the product is in full operation, i.e., after it is deployed in the production environment. Maintenance can include software upgrades, enhancements and/or bug fixes.

When any changes are made, it is necessary to provide additional testing both to verify whether the modifications were implemented successfully and also to make sure that they have not caused any issues in the previously-existing functionalities (regression tests).

Other issues to keep in mind in the maintenance phase include keeping the test cases up to date, fixing automation tests so that they are compatible with the implemented code changes, and updating the automation framework infrastructure.

Copy link
The cost of fixing software bugs

Now that the role QA engineers play in a project is clear, let’s move to the thing that makes the world go round: money.

Involving a QA engineer from the very start of the project may generate additional costs, however, not doing so may result in even more expenses in the long run.

The diagram below clearly shows the correlation between the life cycle stages and the costs of fixing software bugs. It’s more expensive to fix a bug than to prevent it. Fixing one bug may create another one, so problems can escalate quickly.

The involvement of the QA Engineer from the project start allows for the early detection of bugs, reducing the costs needed for repairing them. Finding inconsistencies in the requirements is far preferable since any changes to the design are far less costly than those made to the application code.

Fully integrating QA into your SDLC will improve the quality of what you produce. Tests are an integral part of it and help developers find malfunctions as early as possible. Elimination of bugs can be directly translated into quality improvement. Thanks to that, the final product is as close to the initial blueprints as possible.

Another thing to consider is the cost of detecting and fixing defects which increases exponentially with time in the software development workflow (source: NIST).

A study measuring the time it takes to resolve defects at different stages of the development lifecycle (“The Journal of Defense Software Engineering” by CrossTalk) established that it can take up to 150x longer to resolve a defect found in production vs. one found at the requirements stage; and 30x longer than one found in design. Another study determined that:

  • 50-60% of software defects originate during the requirements phase of a project,

  • 15-30% originate in the design stage,

  • only 10-20% originate during the development phase.

(SOURCE: Suma V and Gopalakrishnan Nair T.R. (2009). Defect Management Strategies in Software Development, Recent Advances in Technologies.)

Involving a QA engineer in the development team at the ‘coding’ stage of the project means that up to 90% of the bugs have already been introduced to the system. The impact of this, both in terms of resolution time and cost, cannot be overlooked.

Copy link

QA Engineers play a crucial role at every stage of the Software Development Life Cycle, their role is very complex and is by no means limited to just checking the code for bugs.

Various studies prove that the earlier you spot an issue and the sooner you resolve it, the more money you will save. Hence, even though it may seem like involving QA early on may is just an additional expense, it quickly proves to be a necessary part of the development process that can actually save money in the long run.


Related Articles