Over the past 10 years, enterprise technology has experienced an enormous amount of upheaval. Developers started self-servicing, leading to “shadow IT.” The DevOps movement and alignment with Agile methods started gaining popularity, and thought leaders started making statements about how DevOps is the future and ITIL/ITSM and other traditional practices are the past.
With all these changes, it’s no wonder that the words “digital transformation” have become highly charged and central IT teams feel—not entirely without justification—that their budgets and influence are on the wane. As a result (and partly due to misplaced self-preservation and wanting to stay relevant), these IT teams push back against any kind of cooperation with more developer-centric teams, leading to low levels of digital sophistication and decreased productivity.
This is where HybridOps comes in. We at PagerDuty coined the term HybridOps following feedback from customers to describe the reality of digital transformation in large enterprises—which is one in which technology teams will have a variety of operating models, velocities, tools and practices.
Rather than a dogmatic focus on velocity and stack-ranking teams according to how “mature” they are, HybridOps focuses on three principles:
- Learning culture: It doesn’t matter what operating model (DevOps, ITIL or something in between) teams are using, as long as they can meet the needs of the business and have a culture of continuous learning and improvement.
- Communication and empathy: Open communication, constant sharing of operational data between teams and empathy for colleagues are much bigger drivers of digital operations productivity than rigorous adherence to a methodology handed down from executive management.
- Autonomy: Teams should have the autonomy to choose and use the tools they prefer—as long as those tools allow for open data exchange with other teams. Instead of forcing teams to use tools they don’t need or want, a better approach is to implement technologies that can bridge data and written communication gaps between teams that need to collaborate.
HybridOps is ultimately a pragmatic, incremental, big-tent approach to digital transformation. Our most successful enterprise customers use this approach to roll out their digital transformation efforts, as opposed to the top-down, “Send everyone to Agile training,” enforced-compliance approach. In our experience, using the forced approach typically means teams end up using the language and processes of Agile development practices but actually fail to collaborate with others or make a meaningful impact on becoming more customer-centric.
Measuring HybridOps Success
All this talk about HybridOps is well and good, but how can organizations measure success in a HybridOps world? It’s actually very similar to other areas of a mature business: Leaders need to establish behavioral norms and measure outcomes (instead of outputs) relative to business needs.
For example, it’s unnecessary to benchmark the mainframe team against the web team with metrics such as the number of deploys per day, tickets resolved per month or even system throughput. After all, a mainframe batch process that runs twice a week isn’t necessarily less operationally mature than a serverless function that can return an instant response.
In short, when it comes to measuring performance, it all depends on the operational context and needs of the business—and it’s best to establish some common metrics that prevent overwork and burnout and use them across all teams.
Culture, Culture, Culture
Finally, one last word on culture. HybridOps can only succeed when senior leadership creates a high-trust culture. Blamelessness and fostering a learning culture are key here. Open communication and empathy for colleagues are important cultural values underpinning HybridOps that leaders need to establish and reinforce continuously. If leaders use ownership and control of data as a way to name and shame others when something goes wrong, a HybridOps approach won’t work.
Ultimately, HybridOps is fundamentally a kinder, gentler route to digital transformation—one that’s focused on meeting people where they are and how they’re used to work. It encourages data-driven process improvements free of blame, avoids shaming people who aren’t “DevOps enough,” and creates high levels of empathy between technical professionals within an organization. It puts the focus on outcomes instead of outputs and favors collaboration and productivity over arguments about tools.