Delivering software is like preparing a big meal with many different dishes for a group of friends. You have to plan the event, buy the ingredients, prepare individual dishes or even parts of the dishes in isolation, and finally, compose the meal as a whole. Everything has to come together at the same time so you can enjoy the taste of the food, the companionship of friends, and the satisfaction of the long road from preparation to the climax. If you’ve ever cooked for a group of people, you understand the feeling of success that comes at the end.
Really, isn’t software delivery the same? Like enjoying a great meal, you enjoy the excitement when everything finally comes together and your teams successfully deliver the next iteration to production. At XebiaLabs, we help hundreds of companies achieve that excitement faster and safer—despite the complexity of software delivery.
The difficulty of coming together and finding the rhythm
If your application landscape is not yet transformed to isolated units of product capabilities, you’re still tied to dependencies when bringing new iterations of software to production. Or, if you want to make a big splash of new functionality and you’re not yet at the level where you can use feature toggles, pushing all of your application components to production at the same time is key.
It’s important for teams to start working in the same rhythm. Just like dinner preparation, careful planning and visibility for everyone involved in the process are key to getting the job done. Most importantly, it all starts from a planning perspective. What is the epic you want to deliver? Which application and features are involved in this particular delivery?
As soon as you understand the rhythm, connections, and dependencies, it’s time to start building your automation framework around that rhythm. This is crucial to start building hands-free software delivery and focusing on what really matters: the content that is delivered.
From managing complexity to striving for simplicity
Managing complexity is vital to take control of software delivery. Eliminating chaos helps increase speed and predictability. The first step is always to start by bringing different elements into rhythm. The second step is to optimize them and grow more and more toward fast, independent releases.
To reduce chaos and release faster, take a look at your pipelines from a lean point of view. See them as little factories that produce subcomponents for the greater whole—like the kitchen of a large restaurant.
These four points are worth considering if you want to improve:
- Simplify underlying pipelines. The first step is probably the easiest one: take an individual release pipeline and simplify it where possible. To simplify, you can run tests in parallel, get rid of useless approvals, put release activities where they belong, and shift work left so that it’s in the hands of the experts.
- Get rid of waiting times and focus on speed. The second step is to remove waiting time. Do you often spend time waiting on acceptance testing from the business? Focus on clear communication and notify people as soon as a release starts to happen so they can take action when the work comes in. In addition, it’s important to adopt an Acceptance Test Driven Development (ATDD) approach and specify acceptance criteria upfront. In the case of automated testing, build acceptance test cases early and run them during your Continuous Integration (CI) cycles. This approach will increase your delivery speed because waiting periods during release execution will disappear.
- Get rid of inventory and release more often. Teams often have hundreds of CI cycles and many moments when a feature is actually complete from a development point of view, but not yet pushed to production. Instead of waiting until the end of the quarter or the end of the month, you should strive to push finished features to production more often. Go for a release in between and determine what is holding you back—and once you know the problem, solve it and cut the time in half again to release every week. If it’s a matter of approvals, see if they are really required. If the issue is dealing with operations processes such as ITSM or monitoring, strive for integration with your CI/CD tool stack.
- The ultimate challenge: go independent. Dependencies between business applications or application components are often the biggest barrier to releasing software more frequently. To push applications or components to production independently of one another, you should simplify the application tool stack. There are three ways to look at it. All three would give you the benefits of getting more independent. First of all, simplify the application itself-how many dependencies are there in the application between the different components? Can you reduce, refactor, or rewrite them? Second are the dependencies or interfaces between applications. Is it possible to reduce the number in the first place, and make them more robust or backward compatible to deal with change? Third, get rid of applications altogether! This is easier said than done, but will ultimately lighten your burden of going production overall.
Back to dinnertime with friends: sometimes, your favorite recipe is the best choice. Repetition leads to process optimization and results in a stable outcome, which is beneficial if you want to you play it safe. But choosing a different recipe, or changing the ingredients, or introducing a new instrument such as an oven will have a huge impact. It’s exactly the same if you transform your application from monolith to microservices, from on-prem to public cloud, from slow cycles to fast lanes. Accept a little disturbance, and sometimes a failure. Keep in mind that practice and repetition are important in the kitchen as well as in software delivery orchestration.
PS: My wife is the great chef at home! Lessons learned as described above are purely based on observations and conversations. #SimplyDeliver