As a software company, your primary goal is to deliver the tools that help your customers. In this light, it makes sense to get new features and improvements into their hands as quickly as possible and fix problems the moment they occur.
However, the reality is usually very different. As applications become more complex, engineering teams end up paralyzed, reducing the speed of delivering features and fixing critical bug.
The value of frequent deploys
At first glance, the only downside of postponing a deployment is the fact that customers get their hands on new features a bit later. The opportunity for upselling may be delayed, and you also miss out on some revenue.
In truth, there are many downsides of a slow release cycle.
The benefits of frequent deployments are myriad, especially regarding managing risk. Instead of collecting changes and then deploying all of them at once, you can isolate them in separate deployments. Since you can control the changes you introduce at a low level, deployments are less scary and can help your team overcome the "don't deploy on Fridays" mentality.
Deploying more often also makes it easier to pinpoint the root cause of any potential bug. As each deployment now involves fewer code changes, finding the change that introduced the bug will often be much faster.
It helps when the bug is related to code that developers worked on only hours or days ago instead of weeks or months. Moreover, deploying the fix for this bug will also become quick as the team has mastered deployments and the process itself is low-risk.
Bugs make bugs
Over time, deployments will become a habit rather than a chore. The team will grow more confident in its ability to move forward and will become better at containing changes. At this stage, other problems usually surface.
Some teams see that bugs are introduced more frequently. Management might also see the percentage of time spent on the deployment procedure increase. The reality is that these are not new problems introduced by more frequent deployments but rather problems that were always there but did not surface until now.
When creating new functionalities, it's challenging to make things work if the underlying systems have faults. By regularly fixing bugs and deploying those changes, your developers will create fewer bugs in future releases.
Finally, deploying often and quickly enables you to move fast, experiment, validate assumptions, and correct course. When the time-to-market can be a make-or-break factor, the ability to deploy quickly can be a decisive competitive advantage.