Developers and the SQA team create a development plan before they build an application. The developers write following the SDLC plan while the SQA team writes the Software Quality Assurance Plan to ensure that the SDLC plan was executed. If these documents by the developers and the SQA is well written and organized, the application that is about to be developed is already half-way done.
Even though the documents are well written, these are all nothing when those written are not followed. That is why equally important to the SQA Planning is SQA Implementation. If you are familiar with the most of the SDLC models, implementation means the integration of the developed application to the operations. The preparation and the coding culminate with the implementation of the application to the operations department.
However, SQA treats implementation in an entirely different manner. In every stage of software development, SQA team develops their plan and with it a specific plan of implementation. Every stage of software development is very important to the SQA team. Because of its importance, every stage should be scrutinized and an action plan is very important.
If one of the stages is not checked properly, there is a very good chance the application may not perform as planned. Every stage of the application development process is considered an independent program that planning for each stage is very important.
Although each stage is related and would eventually compliment the next, SQA will treat them as independent entity, each of them having their own implementation plan. We take a look at each of the development stage and see how each stage is implemented.
In the User Requirements phase (UR) the SQA team has to ensure that the users or the management list all the possible functionality they are looking for the application. The SQA team should be able to gauge these functions whether they are realistic or not. A document should be made detailing the need of functionality so that it could be easily presented to the developers.
Once the UR document is complement, the developers receive the document and use it as a basis for the SR stage. The developers have to propose the appropriate software configuration to cater to the user’s need. The SQA team’s function in this stage is to ensure that each proposed user function will be dealt with.
The SQA team has to ensure that the User Requirements will be addressed and should be traced. When traceable, the SQA should be able to logically gauge if the User Requirements has been address or not. Aside from being logical, the software requirement proposed should be verifiable.
In this phase, testing the proposed SR is encouraged. The SQA team could even use CASE tools so that it could easily prove the functionality’s worthiness in answering the User Requirements. CASE tools could quicken the verification of the functionality although monetary concerns should be considered.
Design and Implementation Phase
Simply put, the SQA team’s responsibility in this phase is to ensure the implementation of the proposed functions of the intended application. Along with the implementation, the process of developing the application will also be monitored by the application. There are a couple of design methods that could be used such as the language or framework and the SQA team should aid the development team in selecting the proper language and/or framework.
One of the most important tasks of the SQA team in this stage is to implement simplicity of the coding. Developers could easily write the code of the application but there is a tendency to overdo the coding. The SQA team should emphasize the organization of the coding should be understood easily. Aside from the coding, the comments within the language should also be checked thoroughly. The comments should clearly define each function.
The software’s documentation is also checked by the SQA. This documentation should be thorough, clearly stating the function of the application. Samples of the functions should also be there so that the documentation should be able to aid training.
Software Testing Phase
The developers will now test their application. Using cases, the development team should be able to show how the application will tackle certain commands and functions. On the other hand, the SQA team should be able to use some of their tools to ensure the metrics in terms of processing speed is achieved. Using popular tools, the developers should also test the software’s ability to handle stress efficiently.
In this phase of the software development, the developers of the application are given enough time to redevelop the application. Most of the time, the SQA team will also receive feedback from the developers if they want to defend the efficiency of the application.
Integration and Maintenance Phase
At this stage, the software is ready to be integrated to the operations. The SQA team will review all the documents connected to the application for the last time. At this stage, the SQA team should ensure that proper training should be done not only for the users but for the in house IT department as well. Since every required document has been created, the training program should be easier than expected.
All of these implementation actions should be found in the SQA plan. The SQA manager should ensure that each stage in software development will receive specific actions from the SQA team. As we have previously mentioned, each stage of software development will have their own set of plans and eventually, own set of actions that should be implemented as soon as the stage is completed by the application team.
The challenge of consistency is always there for the SQA team. It is only through consistency that the SQA team could show their effect to the application. SQA can definitely guide the development of the application as long as they stick to the plan and execute them without hesitation.