The motto of Fullstack is “Be smart, get stuff done.” This phrase reflects how the company values turning software ideas into reality. The whole business model is centred around providing software solutions to clients to help them solve problems. This is the core of bringing a vision to life. When a client has a problem that needs solving, Fullstack provides the solution in the form of software. Developing a product is a complex journey that demands dedication, planning, and collaboration. It involves ideation, prototyping, testing, iteration, and refinement. The journey is full of challenges that require perseverance, patience, and a willingness to learn and adapt.
The actual building of the software and assuring the quality of said software is only a small portion of the larger structure. To incorporate all the moving parts involved in bringing software to life, there have been many suggestions and processes proposed by people around the world. One such methodology is the Software Development Lifecycle
The Software Development Lifecycle (SDLC henceforth) is a methodology that is used to develop software and ensures that there is a structure to the development process of designing, developing, and testing the software. It is an iterative process and has 7 stages:
- Planning and Ideation
- Requirements Elicitation
- Design
- Engineering
- Testing and Quality Assurance
- Deployment and Launch
- Maintenance and Evolution
This process provides a framework for companies across the globe to structure their practices around. However, it is important to note that the practice is not a hard rule, but a framework or a guideline. Since Fullstack does bespoke software development, we do not follow the SDLC fully as our business model does not align fully with the “ideal” lifecycle. For instance, the handing over of software to clients when the work is complete does not lend itself to the Maintenance and Evolution stage. Thus, we use and adapt the process to suit our needs.
During the Planning and Ideation step, the first thing that happens is Fullstack usually arranges meetings with potential clients who have a specific problem to be solved or business needs to satisfy. In these meetings, potential solutions will be discussed, and a plan will be agreed upon.
Next is the Requirements Elicitation step, which is where the product owners and software architects specify the requirements of the system to be built. At Fullstack, this stage merges with part of the Design phase in that the architects will design the system architecture. This step provides more detail about the solution to the client and will produce the requirements that the product owners and the product managers use to produce the backlog. The backlog is a vital resource to the developers as it defines the work that we will do and how the product will function on completion. The backlog is presented to the client, and they get an opportunity to inspect and validate the proposed stories.
This backlog is then passed to the developer team, where we will read through the stories in planning sessions and further design our implementation of the solutions. We discuss what needs to be built to meet the acceptance criteria of the stories. After we have a good idea of what is required, we will move on to a second planning session where we will detail our plan of action and specify implementation details. We write up further steps in the form of tasks that need to be completed. When these tasks are all complete, we will have the piece of work that satisfies the acceptance criteria mentioned in the story.
Each of the above stages serves to add granularity to the requirements and specify the finer details. Depending on the project, this is usually where we will begin the iteration, from here onwards, we will build and test according to the stories in an iterative fashion. We have 2-week sprints where we will tackle separate pieces of work in each sprint, repeating the next two steps until all the requirements are met.
The Engineering stage is where the developers finally begin to code. This is where to main work of a junior developer is done; writing code to meet specifications. We follow the steps laid out during the design process and execute the plan to produce code. This process often involves significantly more reading of documentation. Understanding the software we are working with and the solution we are building is crucial. Coding with understanding and knowledge of the technologies you are working with saves a lot of time and can avoid a myriad of problems and bugs. Once we have finished writing the code for a given task, the code goes through a thorough process of testing, reviewing, and quality assurance. Each piece of code is subject to review by members of the team before it can be pulled into a long-lived branch.
The next stage is Testing and Quality Assurance, where our QA team does amazing work of validating the software that the developers produce. They test according to the acceptance criteria of the stories and will often ensure that all edge cases and minor issues are picked up before the work goes up to the production environment.
It is worth noting that each project will handle this process of review and push to production slightly differently. Some clients require us to do our QA Testing on the development branch and have a separate team of internal QA Testers.
We deviate from the framework for the following stage. Instead of going on to the Maintenance and Evolution stage, we have External Technical Handovers. We hand over all the external documentation, which includes the descriptions, attachments, acceptance criteria, and history. All the artefacts will also be handed over, including the source code, the open file designs, and any other supporting work.
The comparison drawn between Fullstack’s practices and the theoretical software development lifecycle highlights the importance of selecting and adopting the most effective procedures that suit our needs. We should utilize the parts that work best for us and discard the ones that are not suitable. To conclude, while we follow certain components of the software development lifecycle, our software journey is tailored to fit our business model. We have chosen the most relevant practices and principles from the framework and applied them where they add value. We have used the software development lifecycle as a framework and created our own unique software development journey. This journey is constantly evolving as our company leaders discover what works and what doesn’t. Our focus is not solely on adhering to the rules, but rather on delivering quality, functional software, and we will follow practices that serve this objective. Ultimately, the end result of the software is what matters the most.
