The art of moving fast but with control.
Progressive Delivery is a new software development lifecycle that builds upon the core tenets of Continuous Integration and Continuous Delivery (CI/CD). Organizations that employ Progressive Delivery ship code faster, reduce risk, and continuously improve the customer experience.
Some may understandably read this and say, “but wait, we’re not even doing CI/CD; now we have to adopt yet another methodology?”
It’s a fair question.
The short answer is that Progressive Delivery can give you CI/CD at the same time. It offers control levers and safeguards that greatly mitigate the risks of continuously pushing code to production. Progressive Delivery thus enables you to pursue CI/CD safely.
But how did Progressive Delivery come to be? What are its core tenets? What does it look like in practice? We set out to answer these questions in a recent webinar featuring Dr. Claire Knight of Github, Adam Zimman of LaunchDarkly, and Sam Guckenheimer of Microsoft.
Below are highlights from the discussion. (View the full webinar here.)
Knight, Zimman, and Guckenheimer traced the evolution of development lifecycles, starting with Waterfall and ending with Progressive Delivery. They recalled how in the days of Waterfall, developers would spend an entire year working on a software release. And despite all the painstaking effort poured into these major launches, in many cases, the quality of the software still ended up being poor.
Eventually, some organizations began embracing Agile principles and CI/CD. No doubt, these models have allowed teams to move faster, and they mark a big improvement over Waterfall. (At LaunchDarkly, we’re big proponents of Continuous Delivery.)
Nevertheless, the idea of shipping code to production multiple times a day—in some cases, unfinished code—exceeds many companies’ risk tolerance. Software organizations, particularly in highly regulated industries, want to be assured that if they start shipping changes all the time, they will have a way to shield customers from the failures that occur at those high velocities. Better yet, they want mechanisms for delivering the right software changes to the right customers at the right time.
Ultimately, what they want is speed with control. And that is precisely what Progressive Delivery enables.
Control is the bedrock of Progressive Delivery. This includes control over which users see which features; control over the timing of when engineers deploy changes to production versus when such changes get released to customers; and, lastly, control over who in an organization is allowed to release features.
The panelists discussed this notion of control in the context of two core tenets of Progressive Delivery.
1. Release progressions
This refers to adjusting the number of users exposed to (and impacted by) new features at a pace appropriate to your business. You can perform release progressions in a variety of ways—via targeted rollouts, canary launches, ring deployments, percentage rollouts, and so on.
By creating more checkpoints for testing, experimenting, and gathering user feedback, release progressions improve the quality of each new feature. This, of course, elevates the quality of your product as a whole. (Note, LaunchDarkly’s feature management platform enables teams to perform release progressions in an easy, safe, and scalable way.)
2. Progressive delegation
This refers to progressively delegating the control of a feature to the owner who is most closely responsible for the outcome. A simple way to think about this is, initially, engineers control a feature. And that makes sense, as they are responsible for building it, testing it, making sure it does what it’s supposed to do, etc.
But once the feature has been tested, it makes more sense for a product manager (PM), for example, to control the process of launching that feature. After all, compared to developers, PMs are closer to the end-users for whom the new functionality is designed. In this scenario, progressive delegation entails giving PMs the ability to control the release experience. This, in turn, frees up engineers to go work on other high-priority projects. (Again, LaunchDarkly provides a simple user interface for facilitating progressive delegation.)
The panelists not only discussed Progressive Delivery in conceptual terms but also in practical ones.
Deployment rings at Microsoft
Guckenheimer explained that one of the ways Microsoft controls their releases is through deployment rings (or ring deployments). They intentionally divide users into groups, or rings, with each ring representing a different stage of a rollout.
Microsoft gradually rolls new features out to each ring, starting with ring zero (the canary group). Once they’ve tested the new functionality in production with the canary group and ensured that all the performance requirements have been met, they deploy the features to the next ring. The subsequent ring may include a sampling of data centers with a small user count, with the ring after that containing a sampling of data centers with a large user count, and so on. Generally, the stakes rise with each successive ring.
By requiring features to meet various performance criteria before moving onto the next ring, Microsoft dramatically reduces the risks of a launch. They limit the blast radius of any bugs that arise. Ring deployments, a technique of Progressive Delivery, thus gives Microsoft confidence to move fast.
“Staff ships” at Github
One way that Github progressively delivers software is through something called “staff ships.” Dr. Knight explained that Github employees use their own platform (Github) extensively. As such, they make a good canary group.
Using feature flags, Github will execute a “staff ship” in which they unveil new functionality to internal users while hiding it from the outside world. In this way, they can safely measure the feature’s effect on system performance as well as gather feedback on the user experience. And they can do this without disrupting customers.
Once the “staff ship” has run its course, Github releases the changes to external users. Progressive Delivery, and the tools and processes therein, takes the worry and stress out of releases. It empowers Github to ship as quickly as they please.
A final point worth making is that Progressive Delivery allows both Microsoft and Github to collect valuable data and user feedback on new features. Each leverages these insights to iterate on features, such that, after several iterations, the features perform much better than they would have otherwise. All of this tends to result in happier customers.
Stay in control
The beauty of Progressive Delivery is that it has something for everyone. Risk-averse enterprises can use it to deploy as frequently or infrequently as they need to. The same goes for hard-driving startups and everyone in between. Progressive Delivery enables speed, to be sure. But it also gives you something perhaps even more transformative: it lets you release whenever and to whomever.
Ship fast, stay safe, and, at the very least, stay in control. That is the way of Progressive Delivery.