The power of DevOps self-service platforms: How standard tools and tech increase developer velocity

By now, most organisations in the business of delivering software will likely have a DevOps strategy. Even if adoption is only partial, the maturity of DevOps enables firms to improve delivery by implementing the tools and practices across their organisation that best suit their needs. 

Once the benefits of DevOps are realised, the business case for scaling DevOps across the enterprise inevitably grows. However, there is a key problem when it comes to scaling DevOps, which is outlined by Gartner’s 2019 prediction that “by 2023, 90% of enterprises will fail to scale DevOps initiatives if shared self-service platform approaches are not adopted.” Providing self-service capabilities allows product development teams to quickly provide new features and push changes to customers while also allowing the self-service platform owners to focus on providing new infrastructure automation capabilities to further support the increased product velocity.

Orchestrating such a platform is a real challenge for DevOps engineers. In such an environment, a shared platform must be purposely designed to deliver an agile infrastructure that allows multiple teams to consume resources on a self-service basis. This is in stark contrast to a legacy approach to application development in which siloed teams add functionality to applications in their own environments, using the tools and technologies in which they specialise, which proliferates a loss of responsibility from the application when it comes to delivery.

Giving Ownership

For cloud-native applications to be delivered at pace, they must meet specific requirements, such as regulatory and security standards. Under the traditional isolated models, teams are at liberty to use their preferred tools and technologies to meet these requirements in their own environments, adding layers of complexity before passing on the application to a new team and development environment. 

By the time an application is ready to be deployed, this network of complexity will have gone through a lengthy integration process. Essentially, this model proliferates a loss of responsibility adoption, resulting in “snowflake applications” for which support, systems infrastructure, and application teams must specialise in the technologies used to build each application, with the number of personnel growing with each new capability added with bespoke technology.

To overcome this problem, DevOps engineers and Systems Architects must sit down with product teams at the design stage to understand the requirements for a service or solution. Following this consultation, technical teams can determine the standard tools and technologies that meet the service requirements, with teams shaping their applications accordingly.

The key question to answer at this stage is, “What business problem will this technology solve?” with the gold standard of technology adoption solving a ubiquitous need.

Under this model, service teams sing from the same hymnal. As long as the infrastructure provides guardrails, with tools that manage infrastructure automation and provide pipeline integration and GitOps capabilities, product owners can be confident that applications will meet the required standards in any context. The only exception to this is a unique and compelling technology that may demand dedicated specialists, which must first be established through a proof of concept. While such an implementation may not necessarily seem DevOps-friendly, it is in accordance with agile principles.

Prioritising best-of-breed, interoperable tools reduces the costs associated with hiring dedicated engineers for implementation and maintenance of bespoke technologies. When systems, networks, application architectures, operations tools, and technology stacks are built using standards, integration is close to seamless. The opposite of this would see systems and networking teams building applications on top of their own technology stacks, leading to applications being married to infrastructure in increasingly complex ways, causing bottlenecks, rising costs associated with IT ownership, and potential skills shortages should specialists tied to a specific product leave the business.

Architecting Guardrails

A well-architected self-service platform solves the problem of skills deficiencies in certain areas by providing an environment that can guide developers through the adoption during their application development lifecycle. In keeping with the essential principles of DevOps, this lifecycle includes every aspect of application development, from product inception at the design thinking stage, to post-release maintenance and fine-tuning.

From a systems perspective, an effective self-service platform will eliminate the need for downstream intervention from systems architects, as the guardrails baked into the platform will ensure the total confidence of developers and product owners. By consuming resources via standardised APIs, naming conventions, and agreed-upon KPIs and SLOs/SLAs, developers can build out the capabilities of their applications, from robust security and testing features to disaster recovery, without needing to interact with dedicated specialists in each of these areas. 

Standard infrastructure patterns, provided by the likes of Azure Kubernetes Service (AKS), for example, allow developers to build their services, regardless of the infrastructure or code language requirement, without requiring infrastructure knowledge and operational expertise.

Further to protecting consistency of delivery, the self-service model empowers service teams to not only learn and develop as they work through prescribed development and delivery pipelines, but it also allows them to focus on writing code and improving the performance of their applications.

Through orchestrating delivery in this way, service teams can deploy applications on a continuous basis without wasting time consulting with other teams, i.e. NoOps delivery. Standardised routes also enable service teams to consistently automate functional, security, and performance verifications with quality gates for rapid feedback, providing further assurance for product owners that applications meet quality standards.

Whether adoption takes the form of bespoke, self-built platforms, or readily available DevOps platforms, will depend on the specific requirements of an organisation. The inescapable fact, however, is that self-service platforms are quickly becoming the standard for DevOps success.