Table of Contents
Often under the development of software is understood only the creation of software’s code. This is fundamentally wrong because this stage is preceded and followed by many others. Writing of the code itself occurs at the Development stage, which is part of the Custom IT Solutions service. This is preceded by the Discovery stage, where the analysis of customer requirements and the conclusion of contracts are carried out, as well as the Design & Prototyping stage, where the actual design and prototyping takes place. And as part of this material, we will talk about the Development stage.
What is the Development stage?
The Development stage is a part of the Custom Software Solution service, where we implement the design solution, the architecture with the built-in scalability, and the functionality of the system, which gives value to the customer. The end result is a complete IT product with UI/UX, which we test and deploy. This is accompanied by our expertise, processing of complex situations, and offering our own solutions for improvements. In the end, after the functionality implementation and demonstration, adjustment, training the client’s employees working with the created software are carried out. The documentation for the IT-product is generated and transferred after that.
Custom software development is a complex process that requires a wide range of specialists. However, the backbone of your dream team will consist of the following guys:
System Architect (SA) is a mastermind that creates software architecture, i.e. designs the interaction of all parts of the application. On the project he is responsible for:
- establishment of non-functional requirements, the basic architecture of the application, and control of their compliance on the project
- compliance of the solution with the customer's requirements
- monitoring the performance and quality of the solution in general
- optimization of the solution cost
- setting up and maintaining a continuous delivery pipeline (we will talk about it a little bit later)
Team Lead is an IT specialist who manages their development team, owns the technical side, as well as the development of some particularly complex tasks on the project. They are also responsible for monitoring compliance with the non-functional requirements of the project. Quality control of the code written by the team is their duty as well. The team lead helps to form the architecture during the project implementation (the so-called emergent design, that is, everything that could not be laid down by the system architect in the early stages).
Developer - the functional responsibilities of the developer (both frontend and backend) include the execution of tasks set by the lead developer or project manager. These are analysis, design, development, and testing of software in accordance with the standards adopted by the project.
Project Manager (PM) - their main task is to manage the project as a whole: design and prioritization, scheduling tasks, control, communication, and prompt problem-solving. In addition, the PM is responsible for dealing with resources, risks, team building, and other organizational issues. The main duty of the PM is to bring the customer's idea to realization in due time, using existing resources. Within this task, PM has to build a development plan, organize the team, set up the project work process, provide feedback between the teams and the customer, eliminate interferences for teams, control the quality and delivery of the product on time.
Quality Assurance Engineer (QA) - QA's job is to ensure quality. The specialist must control the quality of the developed products and analyze the issues that may arise from end-users when using the software.
UI/UX Designer is a specialist who deals with the design of user interfaces. UX and UI are 2 different design profiles, but most often tasks in both directions are closely related, and therefore they are performed by one universal specialist. The task of a UI/UX designer is to make the interface coherent, good-looking, and understandable, as well as to design an interface that will allow achieving the desired goal in using the product most simply and conveniently.
Business Analyst (BA) is a specialist who investigates the customer's problem, looks for a solution, and formalizes its concept in the form of requirements, which will be guided by developers in the future when creating a product. The main task of a business analyst is to identify the customer's business problems and find the most effective solution. To do this, they must know the subject area. The business analyst deals with requirements at all stages of the software development lifecycle and constantly acts as an intermediary between the customer and the development team.
Now let’s proceed to the process itself. And although the boundaries of this stage may seem rather arbitrary, the real starting point of the Development stage can be considered the development of architecture.
The task of architecture development is to determine all the permanent requirements for the project affecting support, project expansion, development speed, and others which the team needs to comply with. The resulting requirements for the system architecture need to be recorded in a suitable form (UML diagrams, instructions, code itself). The main task of this sub-process is to have a general technical representation of the project, which will be used when setting specific tasks for developers (intentional design).
The solution architecture can consist of:
- UML database diagrams
- development environment settings
- connections and settings of libraries on which the work will be based
- UML classes related to intentional design
- the written code of the basic functionality (on which most of the features will be built)
- interfaces that need to be implemented during further development
- a feature typical for a project, the implementation of which can be used as an example
When the architecture is ready, the system architect presents it to the team, but this is preceded by the acquaintance of this very team with the project documentation.
Acquaintance with materials about the project
The main purpose of this stage is to familiarize the development team through the PM with all necessary materials for work on the project. Initially, all this documentation is created by BA, PM, the system architect, and other persons involved in the project at the Design & Prototyping stage. It is extremely important that all documentation is executed in the proper form and presented to the team. It is a matter of compliance with the client's vision, deadlines, the logic of the future decision to do everything just in time and fulfill the task of the project owner with precision. The list of materials includes:
- SRS (Software requirements specification);
- WBS (Work breakdown structure);
- description of Continuous Delivery Pipeline;
- description of the project architecture;
- project workflow.
By the way, Continuous Delivery Pipeline. What is this?
In general, as you can see, the amount of documentation for the project is quite large (no, seriously, each of the documents can have lots and lots of pages). It is important to show maximum involvement so that everything goes smoothly without a hitch both for the client and on our side. And there is no way without a thorough analysis. So, team members carefully study the documentation and, if necessary, form questions for discussion at a kick-off meeting with the team. Remember how you kick a motorcycle off your handbrake? Here is something similar. Actually, the kick-off meeting itself implies getting the team members acquainted with each other and familiarizing themselves with the principle of work, the technology stack, etc. After the meeting, PM makes a follow-up with a kick-off script for a meeting with a client and other agreed issues.
This is followed by a rather exciting stage of the meeting with the client. This meeting is intended to dot the i's, namely to introduce the client and the team and to distribute who is responsible for what.
When the client and the team got familiar with each other, and all the necessary materials are in the hands of the developers, you can proceed to the next stage - the direct development of the software. This stage consists of two key sub-processes, development, it is also building up functionality, and deployment. It is worth mentioning here that each of the subprocesses is cyclical. In other words, according to this scheme, one of the software elements can be developed, then the next one, and so on until the product is completely ready.
Creation (Functionality expansion)
Let’s get to the juiciest part. Functionality expansion is the phase of the Development stage, at which the product is developed, accompanied by our expertise and solving possible problems. It starts with the PM checking the backlog of tasks (in fact, this is just a list of them, the note of the translator from the IT language into English) and prioritizing them. This step can be performed in conjunction with the BA to best suit the client's requirements and business logic.
This is followed by sprint planning if the team is working according to Agile. Here the PM informs the team about the date, time, and place of the sprint-planting. Also the team discusses the tasks to be performed during the future iteration.
After that PM, together with TL, assign the executors for the tasks. In this subprocess, BA presents what needs to be done within the task from the point of view of business logic, and TL tells what needs to be done from the technical point of view. The team can also participate in task allocation. For example, if one of the guys involved in the project has more experience and expertise in this or that aspect, he or she may propose their candidacy and if there are no objections, everyone will eventually win. The developer will do what they are good at, and the client will get the software developed by real masters of their craft and potentially save time and money on its software development.
After that, the developers tell their estimate for the tasks. The question "When will it be ready?" holds a special place in the heart of every customer, because it is important to have the most accurate idea of when a product can start to be used for business and make a profit. An estimate can be calculated using the formula volume of work/productivity. When the estimates are given, the PM records it so that everything is on time and the project does not go beyond the budget. Well, then the developers proceed directly to:
- UI/UX design development is the creation of the appearance of the product, the way of communication between the user and the program, and their interaction, performed by UX/UI designer. The interface also affects whether the product will bring money as well as gain the respect and love of the audience.
- The development of algorithms - it is the creation of the software’s logic. Construction of an algorithm for solving problems, including an algorithm for user interaction with the program. And also the implementation of the algorithm in accordance with the chosen architecture in the form of a code in a programming language.
- Writing source code - this one needs no explanation. If the software is a T-bone steak, then architecture is a bone, and here we are building up the meat (chia stalk and these are grains, in case you’re vegan). Here, the developer is required to be accurate and professional to write high-quality source code.
- Unit testing and debugging - writing of unit tests by developers to check their own code for compliance with all standards, including security.
PM monitors progress on completing tasks daily at meetings and in the task tracker. At the end of each sprint along with the demo, the PM generates a sprint closure success report and sends it to the Head of Project Management Office and the client. A demo with a client is a demonstration of the developed functionality. During this stage, the person responsible for its implementation (PM / BA / TL / QA) demonstrates the result. So the client can personally verify the quality of the work performed at the intermediate stages because the transparency of cooperation and high-quality communication is our everything. After that, the PM together with the stakeholders decide to deploy the developed functionality on the secure product server. However, any code, both before the demo and before the deployment, has yet to pass the testing stage.
The purpose of this subprocess is clear - to test the developed functionality. QA tests the functionality developed during each sprint on the development server - a special environment in which you can look at the work of certain features before releasing them.
If the QA finds bugs in the functionality, he signals this to the team. If there are no problems, he informs the PM about the possibility of deploying the code further to the so-called staging.
In general, the software goes through the following stages of testing:
- Integration testing - involves checking the program modules, combined into a group. The main goal of this phase is to ensure that the relationships between the software components meet all functional requirements. The data that will be obtained during this testing phase will be used by testers in the future to conduct system testing.
- System testing - aimed at checking the functional and non-functional requirements of the system as a whole. With its help, you can determine how the system uses its resources, whether it is compatible with other systems, how convenient it is to use, etc. It also checks the compliance with the level of cybersecurity and reliability embedded in the model.
- Acceptance testing - after passing all the phases described above, the software, or part of it, undergo acceptance testing from our side and then is sent to the client along with the documentation. The client himself, or with the help of beta-tester users, once again makes sure that everything works as intended.
- Operational testing - testing carried out by direct users in the course of working with the software. We admit the possibility of any shortcomings during operation and therefore provide our customers with a lifetime and free warranty on the code, which guarantees the correction of all possible errors and shortcomings as soon as possible. In this way, we not only show confidence in the quality of the work but also focus on the optimal user experience.
After the creation of the software’s code, the deployment stage follows.
Delivery (Deployment, commissioning, and training)
At this stage of the Development stage, the product is deployed on the customer's servers or in the cloud. Our specialists also carry out commissioning, hand over the product to the customer, and conduct personnel training, during which they explain all the features of the program and where the ‘any key’ button is.
It all starts with DevOps setting up the ability to deploy to the production server. Then TL launches part of the project on the production server. This point is also very important because deploying code is a very scrupulous and time-consuming process. Even the slightest mistake is unacceptable, because then the functionality will not work correctly, and therefore it is necessary to approach this stage with all responsibility and carefully check every little thing. Typically, setting up a production environment takes up to 3 weeks, to which you can add time to check if all the functionality has been transferred correctly. After PM notifies all stakeholders that the functionality has been deployed and if everything goes according to plan, then the transfer of project documentation follows. In general, the documentation can be divided into the following 3 types:
- Architectural - for example, a design specification. These are documents describing the models, methodologies, and development tools selected for this project. Without describing how anything will be used, it rather answers the question “why exactly”. For example, in a design document, a programmer might describe the rationale for why data structures are organized this way. In some cases, ideas are even given on how improvements can be made in the future. None of this is part of the technical or user documentation, but it is all really important to the project.
- Technical - all documentation accompanying the development. This includes various documents that explain the operation of the system at the level of individual modules. Typically written as a Readme document and source code comments, which are then structured as HTML documents. Such documentation is highly technical and is mainly used to define and describe APIs, data structures, algorithms, and is needed for further work on software in the future.
- User - includes reference and explanatory materials required by the end-user to work with the system. These are, for example, the User Guide and the Help section for the program. Typically, user documentation is a user manual that describes each function of the program, as well as the steps you need to follow to use that function. It is very important that the documentation isn’t misleading and is up to date.
As soon as all the documentation is in the hands of the users, we start training them on working with the product. BA creates a training plan for the client for the developed product, the PM coordinates the training plan with the client, and adds appropriate notes to the communication plan. This stage is of key importance because the client themself could see the functionality during the development process on demo presentations, but they personally did not utilize the functionality to its fullest. Moreover, not all stakeholders might attend the demo, and this stage includes full training of the entire customer's team. The same applies to the client's personnel, who need to be taught to use the functionality of the developed product.
And when the client's team has mastered the new functionality, the most favorite stage of any developer follows - the acceptance of work and the summing up. PM sets up a meeting with the client and the team, summarizes the work done, shows reports, and statistics. In turn, the client makes sure that everything corresponds to his idea and confirms that all work has been completed and the project (block) is considered closed. That’s it, now you can exhale. At least as far as the development of this particular block is concerned, after all, there is still a support stage. It should be understood that in the presence of other blocks, the Discovery and Design & Prototyping stages for these blocks pass in parallel.
So, what do you get at the Development stage with MassMedia Group:
- A ready-to-use IT product that is based on your unique idea and fully meets your goals, needs, and requirements. The software developed by us will be able to automate and adjust business processes thanks to the individual approach of our company to each project.
- An IT product that belongs entirely to you and only you. You can forget about licensing fees.
- An IT product that has a high level of cybersecurity and reliability, due to compliance with all relevant standards and specifics of your industry. The data is stored on secure servers in Europe and the USA.
- An IT product that can be improved and adapted as needed, in the configuration that you need.
- Competitive advantage in the form of a unique IT product that suits you perfectly and fully realizes your goals.
- Development quality from a company with 13 years of experience and hundreds of successful projects.
- Quality communication and reporting. We are always ready for a dialogue with our client and arrange communication and work processes in such a way as to guarantee your confidence throughout the cooperation;
- Warranty on the software we created. We provide a free and lifetime warranty on the code we write to help you deal with unexpected issues as quickly as possible.
- Customer service. We provide transparent cooperation and are maximally involved in the project, treating it as if it were our own.
The Development stage is a real test of the team's strength, but if they pass it, then both the developers and the product owner are rewarded with a sense of the accomplished task and a full-fledged IT product. In fact, this is a practical solution to problems in order to achieve goals, and it is extremely important to do everything correctly and to please the customer's vision, as well as to control the process at all stages, which is quite realistic if specialists get down to business. Ultimately, the client gets fully working software, a team trained by the creators of the application, and a support team to maintain it in the future. And then follows the Evolution stage, at which software maintenance and new functions development take place. Read about it in our next article.