bigstock-Blue-Tornado-104877716 (1).jpg

3 Keys to Master the Pace and Intensity of Software Release Cycles

You lead a software organization. Business stakeholders rely on you for a lot. Software releases are intense. It feels like you never have enough time, and schedules always seem to slip. Then, when your team does deliver on time, you find more defects than you’d like. You’d love to master and step above this fast-paced, high-pressure cycle of software releases. Here are three keys to doing just that.

Key #1: Have a complete strategy

Your software work environment is like a factory floor. If it is not operating well, you should see materials out of place, work stations not manned or work-in-process piling up in one area causing a bottleneck. Unfortunately, in the software world, much of the factory floor is virtual and invisible. As a leader, you must make it visible. And it starts with a complete strategy.

A complete strategy is more than a methodology like Agile or Scrum. You might have adopted DevOps, and you might have even moved to the cloud. But all of these are just parts of what it takes to master the pace that software must sustain.

In today’s DevOps world, the foundation of a sound strategy is having an automated DevOps pipeline. This includes key technologies like your Version Control System, build server, and release/deployment automation. But these are just the start of what you need. In addition, your strategy should encompass and provide for:

  • Your chosen practices
  • Defect prevention, detection, and removal methods
  • Team workflow
  • Architectural blueprints
  • Cloud operations

In each of these areas, you need to have an underlying strategy. It aligns and equips your team. Without it, team members must fill in the blanks as they go. Each type of software application warrants a unique set of practices and techniques best for that situation. You should:

  • Define what practices you’ve chosen for each class of software application. For example, test-driven development is a good practice, but how it’s applied depends on the application.
  • Model the flow of your software factory, and align your team workflow accordingly. Otherwise, your team will be figuring out on the fly how software needs to move through from idea to working bits.

In all of these areas, it is up to you to determine the strategy. You likely have smart software developers, and they are paid to be creative. But, chances are that they won’t say, “Boss, we are missing a strategy in the area of ____.” They’ll come up with ideas and implement them quickly, but until you lay out a clear strategy, roadmap and model, their efforts will never be well-aligned. And, it will be a continual struggle to get the team to move at the pace you need them to move.

Key #2: Execute with discipline

This second key is a springboard from the first. Establish a clear process for implementing and executing each of the methods that you have chosen as a part of your strategy, for each area of your teams’ work environments. To know if you are executing well, you must:

  • Create a routine. Reinforce the habits of your team so that it’s easier to follow your strategy than to ignore it.
  • Inspect on an ongoing basis. Design controls and establish reporting so that your team sees that you are serious about the strategy.
  • Establish and enforce policies. For example, if part of defect prevention is to limit the amount of custom code in the software, you might choose to only reuse proven defect-free components. This is likely a series of Nuget packages, and for new software features, look for packages you can “buy” vs “build” in order to limit custom code. Why? Because the average defect density for custom C# code is known from research. And you know that for every 5 defects in software, 1.75 come from the code (.4 come from bad fixes). In weekly execution, you would bake into your pull request inspection checklist a question asking whether the chosen Nuget packages were implemented and if any code exists that could be replaced with a package.

Key #3: Measure what you expect

Finally, if you are executing your strategy, you must have metrics and reports you can pull and monitor in order to see that your strategy is producing results. This visibility is critical to validate or invalidate your strategy and its effectiveness. Continue adjusting your strategy according to what you measure. You’ll want to measure defects delivered to production as well as lead time and in-process time for different stages of work in your workflow. You’ll see bottlenecks. These are just a few examples. Each of your strategies needs measured – and thresholds to let you know if you are happy with the results.

The key to the keys

It’s entirely possible to master the pace and the intensity of your software release cycles. But, it takes a clear strategy and roadmap to get there. And, it goes beyond a team that is good at coding. Think of it as a well-run software factory, with quality controls, automation, processes, measures and feedback loops. I’ve touched on the key principles involved and given you a model to work from. We’re here to help when the time is right.

About Clear Measure

At Clear Measure, we believe great software development is the lifeblood of a great business. We’re a DevOps-Centered Software Engineering company that specializes in Microsoft technologies and cloud-based platforms. Our focus is to help you and your team move fast, build smart and run with confidence by taking full advantage of DevOps automation, processes and skillsets.