See the target, hit the target: why visibility is the first step in the DevOps value chain

344 Views

Modern software development is more complex than ever — a single enterprise project can have dozens of stakeholders and hundreds of APIs. Even when its clear teams are feeling DevOps pain, the source of that pain can be far from obvious. Hence, visibility is the first consideration in a DevOps environment, because without visibility, businesses are left looking for an improvement needle in a haystack of day-to-day operations.

But what is DevOps visibility? A complete answer must include the combination of a variety of aspects. These can be as specific as a proper version control mechanism, and pipeline management tools to something as large as a transparent organizational culture. But without all these elements contributing to visibility, an enterprise simply won’t have the information it needs to improve quality or accelerate releases.

Fading vision – signs of poor DevOps visibility

About 83% of IT decision-makers report their organisations have adopted DevOps practices to improve software, but not all of them have reported success. When an organization experiences DevOps pain, the first step is to check for where it lacks visibility.

There are three key indications:

1)  An over-reliance on manual processes or interventions: Tracking changes manually creates problems later and it is very easy to make a small change and fail to log it. Manual methods can also keep critical information siloed, so different teams might have incomplete or conflicting information. All of which frustrate visibility.

2)  Unclear goals: Good DevOps is iterative and leverages circular feedback loops to work towards the ultimate end goal of a strong user experience. However, during development, teams can lose sight of the bigger picture. Unclear feedback mechanisms can make it challenging to prioritize the right things and set the best goals.

3)  Trouble with complex merges: Continuous integration was supposed to be a solution to “merge hell”. However, even CI can create bottlenecks when joining multiple complex branches. Full pipeline visibility provides tools to simplify branches so even complex merges are manageable.

As these three areas indicate, tackling visibility demands a co-ordinated effort – and it can be tempting to think that it is too much of an undertaking. However, people waste an enormous amount of time and energy when they don’t have what they need to do their jobs, so the time spent improving visibility is worthwhile because it provides the insights necessary to get work done.

The field of vision – improving visibility across all DevOps aspects

The key to ensuring a visibility project is successful is to get it right first time and encompass everything from situational awareness to version control, planning tools, traceability, auditability, and compliance.

To balance all that, a business needs to look at seven different areas:

1)  Plans – what exactly are you aiming to do with your DevOps: Without insight into required use cases and planned work, you could face redundancies, missed benchmarks, solutions overlap, scope creep and more.

2)  Environments: Businesses need a clear view of the environment to follow their software development life cycle (SDLC). Otherwise, there will be uncertainty over work in progress, versus work ready for deployment, and how to prioritize the two. It will also lead to challenges managing multi-cloud development.

3)  System changes: System changes require tracking to ensure version consistency. Visibility also helps to avoid overwrites, metadata conflicts and the frequent introduction (or recurrence) of bugs.

4)  Architecture: Visibility here can be a challenge because architecture is hidden inside intricate relationships across metadata. Without clear governance, it can be difficult to decipher.

5)  Value Streams: Value streams centre on flow. A team needs to understand the benefit of every project, as well as the risk. Without value stream visibility, they can’t recognize the flow of work and where those benefits and risks appear.

6)  Dependencies: Dependencies occur at every level of the software supply chain: teams, systems, packages and within a codebase. If project leaders understand how these connect, they also see the potential impact of changes.

7)  Performance: This is arguably the most important aspect of visibility, identifying bottleneck sources, work distribution and opportunities for improvement. Two broad approaches to tracking performance are either team-focused that looks the four key DevOps metrics of lead time, deployment frequency, change fail rate and time to restore to give a good indication of how the overall team works together, combined with an assessment of throughput from the development team to help understand work capacity. Alternatively, performance visibility can be individual-focused.  Whilst granular metrics applied to individuals may seem appealing, this can do more harm than good when it comes to changing behaviours. To quote Goodhart’s law: “When a measure becomes a target, it ceases to be a good measure.” Ideally, performance visibility is based on the team. Then, if needed, the business can trace back individual level problems.

Clear lenses – How to enable DevOps visibility

To support visibility, a business needs tools to increase transparency and reproducibility throughout the software development lifecycle.

There are a few visibility best practices to increase DevOps ROI:

  • Adopt Version Control: Version control is an automated method of tracking changes to code. Updates are kept in an immutable log that developers and stakeholders can reference and roll back to if problems arise. This becomes the single source of truth that coders can turn to as they manage their updates.
  • Connect User Stories and Metadata: When a business ties changes in version control to user stories, it gets a narrative that explains the who, what, where when and why of changes. Specifically, it connects the exact change, when it was made, who did it, why they did it, if anything else was changed and the goal of the change. This develops a story of historical changes to the same material.
  • Organise the Architecture: Noisy metadata can obscure architecture visibility. Often, one of the fastest ways to shine a light on architecture issues is to simply organise it into folders and packages.
  • Streamline the Full Stack: Salesforce probably isn’t the only SaaS in a given cloud stack. The DevOps platform that a business chooses should support multiple cloud hosted applications and help tie them all together.
  • Enable Value Stream Management: Value stream management starts with mapping. In this, the team visualizes workflow to understand where bottlenecks lie. Once these spots are found, the team can look for causes. This means they can make improvements, eliminate waste, and focus on the strongest value drivers. The key is connections and integration. The team needs the full picture of all the tools, applications, SaaS solutions and other components in one single place. VSM platforms make it possible to tie these disparate systems together.
  • Leverage DORA metrics: DORA metrics will test an overall process to see where it compares to others. These metrics are the same needed for performance visibility: lead time, deployment frequency, change fail rate and time to restore. DORA rates organisations into four categories: elite, high, medium, and low. These can be applied across a wide range of questions to quantify results.

Incorporating all these components will improve DevOps visibility, shining a light on the places in process where value is stuck.

Once an organisation understands the bottlenecks that it faces, it can start resolving them. Visibility gives teams and leaders alike the information they need to turn their attention further down the pipeline. This will begin to increase quality, improve speed to deployment, increase and accelerate innovation and finally achieve resilient development processes.