The main stages of testing

 There are 7 stages of testing:

1. Working with requirements. Familiarization with customer requirements, discussing what the final product should look like.
2. Developing a testing strategy. Estimating testing time, identifying the testing environment, and consolidating all information obtained from working with requirements.
3. Creating test documentation. Writing scenarios that will allow you to check functionality.
4. Prototype testing. Testing the main functionality of the product, adjusting goals, adding features.
5. Main testing. Conducting a general check of the product.
6. Stabilization. At this stage, work is being done to eliminate bugs.
7. Exploitation. Regression testing is carried out, errors found by the end-user are eliminated. 

Before moving on to describing each testing cycle, it is important to remember the important rule: moving to the next stage is only allowed after completing work on the previous one. 

Stage 1. Working with requirements 

The testing team familiarizes themselves with customer requirements and product functionality. At this stage, continuous communication between teams is important, and questions should be asked of developers. 

Thoroughly studying requirements should: 

• Identify contradictions in requirements; 
  help identify potential defects in functionality.

Communication is a key aspect in product development, and a well-thought-out roadmap will allow illogical future changes to the product to be eliminated. 

Stage 2. Developing a testing strategy and planning quality control procedures 

This stage is important for leads or managers, as the quality of testing depends on understanding the information obtained in the previous stage. 

The test lead should: 

• Summarize the information obtained; 
• Estimate testing time; 
• Develop a testing strategy: identify the types of testing that can be applied to the project, analyze available environments and resources for testing, describe priorities for unforeseen situations, how and where testing documentation will be conducted; 
• Determine the testing environment: what equipment is needed for testing; 
• Create a plan that describes what testing starts with and ends with, and what will be tested. 

Stage 3. Creating test documentation 

The goal of this stage is to create documentation that covers details, progress, and clarity for the customer. Communication with other teams and understanding customer desires directly affect the quality of test documentation. After testing is conducted, its success can be analyzed.

Test documentation may consist of: 

• Test scenarios: what and how will be tested during regression, smoke, and acceptance testing; 
• Reporting: testing results, list of bugs and their severity;
• Testing methodologies. 

The level of detail in test documentation depends on the project and may differ in scope, format, and volume. It is important for a tester to maintain up-to-date documentation and make any changes related to the final product. 

Stage 4. Prototype testing 

When creating and testing a product prototype, it is necessary to identify major deviations from the expected result and compliance with the business strategy. Errors in the logic of the main functionality are also detected and vulnerabilities and defects that were made during the development stage are eliminated. The client can participate in the prototype testing process to assess the progress of product development.  

After testing, client feedback is collected. New requests must be documented, assessed for timing, implemented into the project, and presented to the client for review. The most suitable method for prototype testing is closed beta testing, where a small number of people who will eventually use the product after release test it. This helps to take into account the wishes of end-users.  

Stage 5. Main testing 

Software testing is the most time-consuming and voluminous process. Reports are generated on defects found, a set of test scenarios is executed, a test environment is created, and testing is performed, the types of which were documented during the creation of test documentation. Smoke and regression testing are carried out at this stage.  

It is important to understand that it is impossible to find all errors in the product. However, not finding errors during testing can be considered a failure. The main goal is not to create a perfect product without errors, but to find the maximum number of defects that could potentially break the system. 

Stage 6. Stabilization 

The most unclear stage in terms of formulation. It marks the end of work with client requests and the fixing of bugs found. It serves as a link between the testing team and the development team. During the creation of an online resource, the development team was busy implementing client requests, while testers reported new defects. During the stabilization stage, developers begin to listen to testers and fix what already works but is incorrect.  

If the product exists in some larger system, integration testing is also carried out at this stage, which checks the communication between the system and the product.

Stage 7. Operation and Maintenance 

Perhaps the most nerve-wracking period. After fixing defects, the development team moves on to the stage of testing the product in a production environment. Since many people end their involvement in a project after the release, it is important to note that this stage involves not only the release of the product, but also post-release support.  Despite all efforts, it is impossible to take into account all nuances of use and recreate the environment in which the product will be used. Therefore, at this stage, it is important to focus on what users are saying. They are now your main testers. Your product becomes part of people's lives, so defect elimination and detection are done quickly but thoroughly. The end user may not always provide information about what they did to get the error, so the QA team is responsible for reproducing the defect. 

Conclusion 

Software testing is a long and painstaking process, with each identified system error being the result. Testing begins at the design stage and continues even after product release. The tester must clearly articulate why the identified error is indeed a defect; they must listen to the position of the end user after release and remember that nothing in this world is perfect.