Tag: MTTD

  • Three Strategies for Reducing MTTD and MTTR as Outage Costs Spiral

    Three Strategies for Reducing MTTD and MTTR as Outage Costs Spiral

    According to a New Relic survey of IT professionals, the median annual cost of IT outages has reached an astronomical $7.75 million. Over one-third of the 1,700 respondents said critical business application outages now cost more than $500,000 per hour. In a business environment where most interactions with customers, suppliers and business partners are conducted digitally, downtime has become a problem and an existential threat.

    Most IT organizations carefully monitor two key metrics — mean time to detection (MTTD) and mean time to resolution (MTTR) — to track their success in identifying and remediating critical systems issues. The figures represent, respectively, the average time it takes administrators to identify that a problem has occurred and to remediate the underlying issues. They serve as a benchmark for understanding the organization’s level of awareness of the status of its systems and the speed with which problems can be diagnosed and acted upon.

    There are many ways to improve performance against these metrics, but three stand out as the most effective, as evidenced by New Relic and the survey results.

    Monitor Everything

    The less you know about a problem, the longer it takes to diagnose and fix. The New Relic survey measured 17 different observability categories, such as network monitoring, alerts, log management, browser monitoring and distributed tracing. Across the board, about two-thirds of the companies that used even one of those monitoring tools reported reduced MTTR, with many saying resolution times had fallen by more than 25%.

    One-third of respondents whose organizations implemented full-stack observability—which is the ability to see everything in the tech stack that could affect the customer experience—reported the fewest outages, fastest MTTD and MTTR, lowest outage costs and highest median annual return on investment compared to all respondents. For example, those who have full-stack observability experience a median outage cost that is 37% less than those without.

    As the complexity of enterprise technology stacks increases, so does the difficulty of pinpointing the root cause of an outage. Any monitoring is better than no monitoring at all, and the more visibility you have into applications and infrastructure the faster you can identify and resolve incidents. Strive for full-stack observability around integrated observability data and a comprehensive dashboard.

    Have an Incident Management Action Plan

    The worst time to figure out how to resolve a problem is when you’re in the midst of a crisis. Organizations with mature observability practices also have extensive and documented response plans.

    Your incident plan will be unique to your organization. Small companies and startups tend to have ad hoc response strategies based on the skills within the organization. Large enterprises may use a more formal methodology like IT service management that defines strict procedures and protocols. Companies that have embraced modern DevOps and Lean principles often use a hybrid approach that depends heavily on teamwork and collaborative problem-solving. All of these approaches can work if the team fully understands the chosen strategy.

    Document your IT architecture, identifying known vulnerabilities and outlining procedures for responding to the most common types of incidents. Plans should cover obvious disruptions like fires and power outages, but you should also think about “unicorn” scenarios such as a rogue query that ties up a database server or a communication outage at a key supplier. Mature observability teams devote a portion of their resources to constantly testing new and unpredictable scenarios and use chaos engineering to randomly inject problems in a controlled manner to see if systems respond as expected.

    As you develop incident response procedures, document the processes in runbooks, which tell responders exactly what to do when a specific problem occurs. This not only creates a database of organizational knowledge about response strategies but also helps with onboarding new employees and covers for skills gaps that occur when team members are unavailable or leave the company.

    Fix for the Future

    Technical debt is a long-term obligation that is created when a short-term – and incomplete – solution is applied. You should aim to minimize it in your observability operation.

    When a problem occurs, the temptation is to fix it as quickly as possible. Human nature is to move on to the next task without taking the time to go back and understand why a problem occurred. “Quick and dirty” fixes are an invitation to larger problems in the future. Your observability plan should include a forensics stage that documents root causes and the fixes that were applied. Even if it isn’t convenient to implement a long-term solution immediately, the documentation serves as a guide for implementing a permanent fix down the road.

    Building a resilient IT architecture is a marathon, not a sprint. The more rigor you apply to identifying and resolving problems when they happen, the better prepared you will be to prevent their reoccurrence and the more informed your team will be about the resources they manage. Reducing your MTTD and MTTR will not only improve the bottom line of your business, it will ensure that your customers have an amazing digital experience.

  • Increasing Software Velocity While Maintaining Quality and Efficiency

    Increasing Software Velocity While Maintaining Quality and Efficiency

    At Compuware, we have been exploring the need for continuous improvement across three key dimensions of software development: velocity, quality and efficiency. Given today’s current market demands and the importance of digital services, this discussion couldn’t be timelier.

    On my previous piece, I focused on quality — how to maintain and improve it as (supposedly) competing demands for velocity and efficiency increase simultaneously. This article will focus on increasing velocity and how it is possible to do so without compromising quality or efficiency. As I discussed in my earlier piece on quality — automation, integration and measurement are once again the key.

    Compuware recently conducted a survey finding the overwhelming majority (97%) of application development managers said IT is under more pressure than ever to deliver software innovation faster. Higher demands for innovation are being imposed universally across platforms, from the cloud all the way back to the mainframe.

    Mainframe software delivery is a particular area of focus, with 95% of respondents noting their IT teams are under pressure to adopt modern development practices on the mainframe in order to accelerate overall software delivery and innovation. Adding to this pressure, organizations reported they expect to increase the frequency of new mainframe application feature deployments by an average of 41% over the next year, compared to 38% for non-mainframe applications. This shouldn’t come as a shock, given the proliferation of modern web-based applications placing unprecedented demands on back-end mainframes.

    Let’s take a closer look at how automation, integration and measurement are equally applicable to the goal of advancing velocity.

    Automation

    Throughout the software lifecycle there are many opportunities for automation — from software design, to development, to build, test, deploy and, ultimately, the production state. The more of these steps that can be automated, the faster developers can work.

    Perhaps the biggest area for potential time savings is testing, because of all the phases of the software lifecycle, testing assumes the most manual labor. The Vanson Bourne survey found test automation to be the single most important factor in accelerating innovation, according to 90% of IT leaders.

    On the mainframe specifically, development teams spend more than half their time on testing during the release of a new mainframe application, feature or functionality. If you can automate more testing, you can roll out applications faster while maintaining (or even enhancing) quality combined with an extremely high level of developer efficiency.

    Integration

    Integration helps software development technologies interoperate with each other. An integrated pipeline leverages existing investments and enables developers to build, test and deploy faster while providing the additional benefit of reducing errors resulting from human intervention (furthering quality). Integration also decreases the manual labor needed to execute and manage workflow within software delivery processes. When these technologies integrate out of the box, setup time is saved and productivity gains can be realized significantly faster. 

    For example, the integration of Compuware Strobe application performance solution with Jenkins, makes it easy for developers to take performance measurements early and automatically as part of a Jenkins CI/CD pipeline.

    Ongoing Measurement

    Measuring velocity is critical. Without measuring, it’s impossible to know how changes are impacting the software development process and what areas need to be improved. Measuring is the key to understanding if there are any activities that can be sped up across the phases of build, test and deploy. This enables development teams to find and address bottlenecks with a great level of granularity. Some common metrics for measurement include mean-time-to-build (MTTB), mean-time-to-delivery (MTTD) and mean-time-to-repair (MTTR).

    Conclusion

    Velocity does not need to exist at the expense of quality or efficiency — on the cloud, the mainframe or any other development platform. Like quality, the key to achieving and improving velocity lies in the disciplines of automation, integration and ongoing measurement. The next piece of this series will explore the keys to maximizing developer efficiency amidst near constant demands for exceptionally fast, high-performing rollouts.

  • Why and How to Collect KPIs for Z DevOps

    Why and How to Collect KPIs for Z DevOps

    It can sometimes feel frustrating to try to figure out how to do DevOps. That’s because DevOps is not about tools—there are lots of different tools that can help you succeed at DevOps. Nor is it about any really specific set of practices; although DevOps prioritizes things like automation and communication, it does not prescribe specific processes for enabling them.

    Instead, DevOps is really just about cultural values, which is a rather vague guideline for people who want to do DevOps. In this sense, DevOps can make practitioners feel a little lost, because they’re unsure how to measure whether they are succeeding on their journey toward DevOps.

    The fact that DevOps ultimately boils down to culture does not mean there are not specific points of information you can track and analyze to help assess progress on your DevOps journey. The specific metrics you’ll analyze will vary depending on your circumstances and the systems you use, of course. But to provide an example of how you can evaluate DevOps progress in the real world, let’s take a look at which types of key performance indicators (KPIs) you might focus on when doing Z DevOps.

    What Is Z DevOps?

    Z DevOps refers to a DevOps practice within the IBM Z ecosystem. Although Z is not typically the first technological niche to come to most people’s minds when they think of DevOps, the fact is more than half of enterprise transactions continue to run on IBM mainframes. The vast majority of structured business data also resides on these systems.

    Thus, bringing mainframe software delivery up-to-speed with DevOps culture is an important priority for many organizations. That’s what Z DevOps is all about.

    KPIs for Z DevOps

    Whether you’re just starting on your Z DevOps journey, or have been doing DevOps-based software delivery on the mainframe for a long time already, there are a variety of KPIs you can track to help assess how effectively your DevOps strategy is working, and find ways to make it even better. Remember, DevOps is all about continuous improvement and never settling for the current state of affairs.

    Deployment Speed: DevOps prioritizes faster software delivery. For that reason, being able to track how quickly you push out new software releases or updates is critical for measuring your DevOps success. In DevOps circles, this KPI is sometimes called Mean Time to Delivery, or MTTD.

    Keep in mind that truly continuous releases (meaning releases that are literally constant) are an unachievable goal. But by tracking your current deployments per week or month, you can measure how your deployment speed changes over time.

    Deployment Success Rate: Software deployments can fail for a variety of reasons, and achieving 100% success is not practical for most organizations. But you still want to strive to maximize your deployment rate. Anything around 90% is impressive in many cases. So, track how many deployments succeed and fail.

    Deployment Scale: Deployments vary greatly in size. One deployment might contain a few minor performance tweaks. Another might involve major interface or feature overhauls. In order to contextualize other deployment-related KPIs, it’s important to measure deployment scale by collecting information about the scale of your typical deployment.

    Scale in this context can be difficult to measure precisely, but basic metrics to track include information like how much new code is a part of each deployment, or which percentage of a deployment entails new features as opposed to bug fixes for existing features.

    Test Failure Rates: In most DevOps delivery pipelines, you will rely heavily on tests (especially automated tests) to verify that software is ready for delivery before it is deployed. When tests fail more often than expected, it can be a sign that developers are working too quickly or need more feedback about code quality. Tracking test failure rates can help you assess these issues and take action in order to minimize failures and keep deployments running on schedule.

    Team Performance: In addition to tracking overall speed and performance, it’s important to be able to track these KPIs on a per-team basis. Again, DevOps is all about culture, and some teams might need more help than others in embracing DevOps culture. By tracking deployment performance on a per-team basis, you are in a better position to identify teams that need more help, as well as those doing well and can serve as an example for others.

    Inter-Team Communication: Since DevOps is all about transparency and efficient communication across the entire IT organization, communication activity between different teams is another useful KPI to track. The data you collect on this front could include things such as emails or Slack messages exchanged between teams, or even meetings or phone calls. This data is not a perfect reflection of how effectively different teams engage with each other, but it provides some useful insight.

    Collecting DevOps KPIs for Z

    If you are doing Z DevOps, one challenge you’ll face is  many generic DevOps tools weren’t initially designed to work in the Z ecosystem. They were designed for other types of infrastructure and environments.

    That doesn’t mean the tools you need to do Z DevOps don’t exist, however. You just need to look beyond generic DevOps guides to find them.

    When it comes to collecting KPIs for Z DevOps, the go-to tool is UrbanCode Velocity. In addition to helping to automate and standardize the software delivery process for the Z ecosystem by providing release automation templates and tooling, UrbanCode Velocity lets you collect and track the various metrics that are important for taking stock of your Z DevOps operation.

    Because UrbanCode Velocity supports KPIs based on data gathered from Z DevOps pipelines, it can help to standardize your entire DevOps workflow, not just your Z DevOps effort.

    — Chris Tozzi