You had estimations, you had everything scheduled. And now you face the situation when the time of releasing the next version of your application has nothing in common with the initial plan. Why? Where you can find a source of problems with your app development?
There are at least a few lag-related reasons. Today I would like to tell you why the releases of subsequent versions of the application can be rare and why the so-called delivery is slow. We’ll go through the main causes of delays and get to know the best practices to minimize the risk of having them.
Why do problems with software development arise?
Difficulties and challenges with your software development may occur in one of these three areas: process, tools, people (or in all of them). You should understand that the team that works on your solution contains not only people but also tools and processes. Why is it important to know that? Because sometimes you may have a great team that uses bad tools, or your team has badly implemented processes, and the quality of their work and the speed of that work will not be like you expect. Looking at problems, and challenges, always have in mind the perspective of these three areas: process, tools, and people.
Delays in this area are usually related to the fact that your digital product is not properly versioned.
Lack of proper application versioning
What does it mean? It is a situation in which at the time when some problem or bug occurs, it turns out that developers at that time are working on other features and do not have time to fix the bug. You have to wait for some time before the reported bug is fixed and released to production. After finishing work on the new features, it is time to test them, which also takes a lot of time. In the meantime, the reported bug is still not fixed.
How to avoid it?
You must have a defined and well-functioning versioning process for your application. Your team must know how to do it well. A good versioning process allows your developers to quickly fix bugs that appear during the development of the next version of your product, and most importantly: fixing bugs does not affect things currently happening in your software development.
This is directly related to the keyword: continuous delivery. This term refers to how long does it take from the moment when you have to change something in the code (fix a bug) to the moment when the application is visible to the customers. How fast are developers able to make the needed changes? If it is done well, it is a matter of minutes or hours, but if it’s managed in a bad way, it can be weeks, it can be months. Is your team doing it properly? Does the company you work with know how to do it?
Another area that can cause delays in delivering future versions of your application is tools. You should choose the right to plan your development process properly. It is also essential to manage the code in the right way.
Lack of planning tools
Does your team use tools to plan the next versions of the app, to plan what will be in those versions, which bugs will be fixed, and which user stories will be performed in those versions?
How to do it right?
You can do it with a tool like JIRA or AHA. There are plenty of these tools on the market, but the most important thing is to find the right tool, choose it, integrate it with your process, and just use it well. I can guarantee that using such tools will allow you and your team to better plan the next project scopes, and keep track of time, and estimations. Everyone will know exactly what is needed to be done and understand it in the same way. Everyone, both stakeholders, business people, and technical people will know better what to focus on and what is crucial at this stage of your application development.
Lack of proper code management
Another reason in the area of tools that may cause delays in delivering subsequent versions of your application is the lack of proper code management. This may be an area that you have not paid enough attention to before. You must remember that the code that is created while writing the application is stored in the so-called code repository. The code repository should be divided into branches, which are these separate paths where you keep, for example, specific features. Note that the code is not kept linear.
How to do it right?
Imagine a situation where one developer makes a change and saves to a repository a code that is not split into branches. The second developer makes another change and saves it, then the third, fourth, and fifth. And now if we want to release a new version of the application, we must synchronize the work of all developers.
If we want to improve something in the version that is already available for users – we have a problem. That is why we use branches to manage it properly so that at any time it could be identified that, for example, version 1.2, which is currently on the market is this and that branch. So if we have a bug and want to fix something, we are not interested in all the changes that took place later, only in this particular branch. We fix the bug in this branch, release it to production as another version, and then what we have fixed we merge with what we have in other branches.
Organizing the repository and dividing it into branches is extremely important and you should pay attention to it. This should be the standard these days, but in many companies, if you use a code repository such as Github or Bitbucket it is not necessarily done properly.
The last area where problems can arise affecting delays in delivering future versions of your application is people.
Lack of a person responsible for planning work in sprints
Many times I’ve seen a team working in sprints on successive iterations and successive features. And suddenly during a sprint, someone from customer support comes and says here is a bug this needs to be corrected or that needs to be done differently. And suddenly the scope of tasks that were planned for the next version of the application increases and increases uncontrollably. Nobody watches over it, developers say: Someone decided so. – So we do it. And suddenly it turns out that instead of releasing the next version in a week, we release it in two months and it becomes a big problem.
How to deal with it?
It can’t be allowed to happen. You need to have someone who takes responsibility for it, who watches over it. You have to educate the customer about it, and if you’re a customer, if you’re not a technical person, you have to keep in mind that such changes, introducing new things into a fixed scope in the so-called feature set may cause many problems and generate significant delays.
The problems discussed above are the key things that can cause delays in delivering future versions of your application. Look again for areas and issues they contain:
lack of proper application versioning
lack of planning tools
lack of proper code management
lack of a person responsible for planning work in sprints
In the end, I am sharing with you a free checklist that can help you verify the process of developing and managing your app and diagnose areas where bugs may appear and delays may be generated.