In this post, we will discuss the various stages and process involved in doing web development in a controlled way. It explains the process specific to web development, but the same stages and process can be followed for any software specific development with minor differences. It also assumes that the project is mid-scale and need consistent input from all the stakeholders involved in development including Client, Development Team and Testing Team. In most of the cases, both development and testing team remains same or located within the same premise.
The stages listed in this post can be either followed for the whole project or smaller parts of the project following Agile methodologies. A mixed approach can also be followed based on project need, where starting stages are done for the whole project, but the development, testing, and deployment stages are done for smaller and fully functional parts of the project.
Stage 1 - Requirements Gathering
In this stage, we must discuss with the client about their idea in case the client is non-technical or not fully prepared with the requirements. We can also make an understanding of the client needs and clarify all the queries to have a common understanding between the client and the development team.
Client Meetings - It's the most crucial part of the success of any project. Within this process, we make an understanding specific to project requirements.
BRD - We can also generate Business Requirments Document or simply called a BRD document. This document can be even a simple document having the list of the high-level features to be developed in the project. This document can be considered as the high-level scope of the project and must be approved by the client. It's the very first asset of this process.
Research - We must research the subject and gain domain knowledge related to the initial requirements provided by the client and give suggestions to build a better product. The suggestions will only work out in case the client is not very sure about the requirements else never suggest if the client is fully prepared for the end results.
Stage 2 - Designing
In this stage, we actually realize and picture the project covering all the aspect of either whole project or the feature to be developed. Accordingly, the UI components and pages will be designed to have end results building common understanding.
Prepare Features List
Identify the features on high level following the requirements gathered in the previous stage and prepare a feature document called as SRS of Software Requirements Specification. An SRS can be as simple as a list of feature and explanation.
Design UI Components
Identify the Form elements and UI components considering their re-usability where applicable according to the features covered in this phase. Ex: Address manager component can be re-used for multiple usages. Also, design these components and make a set of components used to develop the requirements.
Prepare a list of all the screens covering the features listed in SRS and design them using the Form elements and UI components identified during this Stage. All the screens must be signed off by the client to limit the scope of the project. Nowadays requirements often change since Agile practices are more common, hence designs might need updates based on each iteration and new designs might also be added.
Stage 3 - Development
The actual development will be done in this stage following the assets generated in previous stages.
Design a Feature
To rectify the common errors, we can design the components to be developed. The assets to be considered as the output of this process are State Chart Diagrams, Sequence Diagrams, and Class Diagrams. Even a simple diagram to picture the logic to be developed can be considered as feature design and do the heavy lifting.
Develop the Feature
Now relax and develop the code following the design is done in this phase. To follow best practices and keep the code manageable, we must develop a feature at a time.
Test the Feature
In order to cover the feature aspects, we must also write appropriate Unit and Functional tests to assure code coverage and functionality as planned. We can also follow TDD or Test Driven Development where we write the test cases before developing the feature.
Integrate the Feature
The features might be dependent on other features developed within the same phase or as part of previous phases, hence we must also make sure that the related features integrate well with the feature currently being developed.
Stage 4 - Testing
We must also test all the features developed as a whole system. In most of the cases, development and test team remains the same and revealing defects could be a bit difficult. In the project, if the budget allows, a separate testing team either in the same premise or a different agency will be much more effective.
Plan the testing before starting the actual testing. In bigger applications, test planning is crucial when testing is handled by a different team since the testing team will prepare their own test cases based on the assets generated as part of the development process.
Execute Test Cases
Execute test cases planned as part of test planning and raise bugs. The bugs can be tracked on a separate document. In the bigger scenario, using software to manage the bugs is more ideal and manageable.
Fix the Bugs
The developer must fix all the bugs identified during this Phase.
As a result of testing the development team can also automate these bugs by writing regression suits having test cases set based on the test cycle.
Test automation will be cost effective if the project is bigger and allows additional budget. The resources involved in automation testing must be a skilled one. In the long run, automation will be fruitful in case the application does not change a lot after automating the test cases.
Stage 5 - Deployment
The deployment team must be experienced and aware of common performance issues related to the web development and the underlying tech stack used to do the actual development to keep up the performance aspect of the application.
Deploy to Server
Map the domain to the web directory and upload the code to the live server. Also, create the database and do the necessary configuration based on the type of development. Most of these activities are one time and then code deployment and backups will be repetitive tasks.
We can also automate the live deployment process using Continuous Integration or CI. The usage of CI is more important in the case of Agile development where deliveries are more frequent.