Slow delivery, rare releases. Why it's takes so long?
If you have been developing an application, you have certainly encountered a situation in which the time of releasing next versions of the application does not clip with the initial estimation and schedule.
There are at least a few lag-related reasons. Today I would like to tell you why it is so, that in your product, in your application, the release of subsequent versions of the application is rare. Why the so-called Delivery, is slow, and what does it come from?
You will learn, among other things:
What are the main causes of delays in the delivery of subsequent product versions?
What are the best practices and what to do to minimize the risk of delays?
At the end of the post, I will share with you a checklist, thanks to which you will verify the process of developing and managing your app and diagnose the area where the bugs appear. The checklist will show you the places where delays are generated.
Ready? Let’s get started!
Why do these problems arise?
Of course, if we talk about problems, challenges then they can be about process, tools, or people, or all of them together. You should remember and understand that the team that works on your solution is not only people but also tools and processes. Why is this important? Because sometimes it may be that you have a super team that uses bad tools, or your team has badly implemented processes and the quality of that work, the speed of that work will not be what you expect.
That is why it is important to look at problems, challenges from the perspective of these three levels: process, tools, and people
Delays in this area are usually related to the fact that your application, your 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 occurs, some bug, 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 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 prevent this?
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 the bug does not affect what is currently happening in development.
This is directly related to the keyword: Continous Delivery. This term refers to how long it takes 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 sometimes minutes, sometimes hours if it is, managed in a bad way it can be weeks, it can be months. Is your team doing this appropriately? 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.
Lack of planning tools
For this area, the challenges are usually that the team is not using tools to plan the next versions, to plan what will be in those versions, which bugs will be fixed, 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 into your process, and just use it. I guarantee you that using such tools will allow you and your team to better plan the next project scopes, keep track of time, estimations, everyone will know exactly what needs 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 point of your application development.
Lack of proper code management
Another reason in the area of tools that may affect the occurrence of 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 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 what are called branches, which are these separate paths where you keep, for example, specific features. Note that it is not so, that the code is kept linear.
How to do it right?
Imagine a situation where one developer makes a change and saves it to a repository that is not split into branches. The second developer makes a change, saves it, third, fourth, fifth. And now what is important 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, because all the changes that were made for the version that is on the market have long been saved. 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 pay attention to it. This should be the standard these days, but in many companies, if you use a code repository such as Git Hab. bit Bucket it is not necessarily done properly.
The last area where issues can arise that affect 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, successive features. And suddenly during a sprint someone from customer support comes and says here is a bug this needs to be corrected 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. There has to be 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 bear 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. They always concern 3 areas: PROCESS, TOOLS, and PEOPLE.
lack of proper application versioning
lack of planning tools
lack of proper code management
lack of person responsible for planning work in sprints
And finally as promised I am sharing with you a checklist, thanks to which you will verify the process of developing and managing your app and diagnose the area where the bugs appear. The checklist will show you the places where delays are generated.
I hope it will be very helpful for you!