For modern developers, software delivery speed tends to be the name of the game. To delight users, meet business goals, and so on, developers are told they need to deliver software releases very rapidly — as often as multiple times per day, if possible.
There are indeed good reasons to deliver software quickly. However, it's important not to allow software delivery speed to compromise software quality. If you do, you undercut most of the benefits of a fast and continuous software delivery pipeline. If you roll out releases quickly but they are buggy, they're unlikely to support business goals or please your users.
That's why it's critical to find the right balance between software delivery speed and software quality. Here are five ways to do that.
1. Avoid Arbitrary Release Schedules
Faced with pressure to maximize software delivery velocity, developers can fall into the trap of committing to release schedules that are not tied to specific features or development roadmaps. Instead, they release according to arbitrary schedules — like once a day — by pushing out whichever code happens to be minimally viable at those increments.
The risks of this approach should be obvious: It totally subordinates software quality to software delivery speed, and it leaves developers in a poor position to ensure they are only releasing stable, well-tested software. Software quality should determine software delivery speed, not vice versa.
2. Don't Place Too Much Confidence in Application Rollbacks
If you release a buggy version of an application because you were moving too fast, you can always perform a rollback. A rollback lets you revert the production release of your app to an earlier, more stable version.
Developers can and certainly should take advantage of rollbacks in cases where they are necessary. They should not, however, turn rollbacks into an excuse for releasing buggy code. Rollbacks are disruptive to users and developers, and they should be a solution of last resort, not an antidote for software delivery pipelines that are too fast. If you find yourself performing rollbacks regularly, it's probably a sign that your delivery process needs to slow down.
3. Don't Skimp on Software Tests
The more software tests you run, the more confidence you can have in your software releases, no matter how fast your delivery pipeline moves. This is one reason why developers who want to release rapidly may embrace tests.
On the other hand, running more software tests tends to slow down delivery pipelines. Test automation can help, but only to a certain degree. For this reason, some developers may be inclined to forgo certain tests in the interests of keeping their delivery pipelines flowing rapidly.
Don't do that. Unless you are certain that a given test has no value whatsoever, do not skip tests in the name of increasing delivery speed. It's better to slow down your release velocity a bit due to thorough testing than to push out buggy code because you didn't run enough tests.
4. Embrace Small Developer Teams
The larger your development team, the harder it is to keep software development processes moving efficiently and quickly. Or, if you do stick to a fast release schedule with a large team, it's likely that you'll compromise on software quality in the process.
This principle goes back to the 1970s, when Fred Brooks argued as much in The Mythical Man-Month. It has been reiterated more recently by people like Jeff Bezos, who likes to speak about "two-pizza teams" — meaning software development teams that are small enough that two pizzas would serve them as a meal.
The point: By sticking to teams that are smaller and more manageable, you're more likely to be able to strike the right balance between software quality and delivery speed.
5. Embrace Everything-as-Code
There are many reasons for developers to embrace everything-as-code — which, in the context of software development, means tools and techniques like GitOps and infrastructure-as-code. Chief among them is the fact that everything-as-code both improves quality and speeds software delivery.
On the quality front, an everything-as-code approach leads to better outcomes by improving consistency. Your developers are less likely to make mistakes when testing or deploying software, for example, when the processes are codified.
At the same time, managing everything through code also increases software delivery velocity because it allows processes to be as automated as possible.
So, if you're still managing parts of your software delivery pipeline manually, stop doing so and move to a code-based approach wherever possible.
Conclusion: The Modern Software Delivery Pipeline
Modern software delivery pipelines should be fast, but they should also result in high-quality software. As a developer, pay attention to factors such as team size, release scheduling, and code-based process automation in order to square the circle between velocity and quality in software delivery.