Getting Developer Self-Service Right
Improving developer experience (DevEx) is a hot topic in the DevOps world. Enabling developer self-service is frequently mentioned as a way to boost both DevEx and developer productivity. When done right, it helps relieve the tension between developers and Ops by enabling:
- Ops to prioritize strategy over tickets.
- Strengthened security and compliance.
- Shorter time from commit to deploy.
- Autonomous deployment without relying on Ops.
In other words, developer self-service is the key to enabling true “you build it, you run it” DevOps. Unfortunately, there are still a lot of misconceptions about what true developer self-service actually looks like and how organizations can best enable it.
In Humanitec’s “2023 DevOps Benchmarking Study,” we set out to understand how top-performing engineering organizations enable developer self-service. We talked to over 1,000 teams of varying sizes and from diverse industries about their DevOps setups. We then assigned teams a score based on their adherence to well-established best practices and their performance on DORA metrics (deployment frequency, change lead time, change failure rate, and mean time to recover).
We found that top-performing teams enable a high degree of developer self-service. They are not reliant on Ops to deploy new features, provision infrastructure or assign resources. Oftentimes, this is accomplished by building an internal developer platform (IDP). IDPs make it easier for developers to build and deliver software without abstracting away the useful and differentiated capabilities of the underlying core services. We found that organizations that prioritize both enabling self-service and reducing cognitive load are the most successful in improving DevEx.
Top-Performing Organizations Enable a High Degree of Developer Self-Service
In theory, a high degree of developer self-service eliminates dependency on a key person, minimizes wait times and diffuses the frustration that often arises from ticket Ops and bottlenecks.
But does this check out with the data? Our research says yes. Whether it’s creating new environments, deploying new features or provisioning infrastructure, top performers consistently enabled a high degree of developer self-service.
Enabling Greater Developer Autonomy
Let’s take, for example, the creation of new feature or preview environments. In 83.6% of top-performing setups, developers can create preview environments on the fly. In contrast, less than half (42.7%) of medium-performing teams have the same degree of autonomy. Nearly 40% need approval from an engineering manager, and 19.5% rely on Ops to provision it for them. Low-performing teams fare even worse, with only 24.8% able to create new environments on their own.
This trend is also reflected in deployment to development and staging. Close to 90% of top-performing teams can deploy features independently and with confidence. On the other hand, 40% of medium performers are fearful of screwing things up or depend on Ops to deploy features for them (19.1%). Only 25.6% of low-performing teams have the ability and confidence to deploy features. Nearly three-quarters of low performers are too scared to do so or have to wait on Ops.
Autonomy to Deploy to Dev and Staging
Key-person dependencies on Ops aren’t relegated to environment creation. They’re a huge problem for infrastructure provisioning, assigning resources and finding information, just to name a few.
Methods of Infrastructure Provisioning
We found that top-performing teams use two main solutions for infrastructure provisioning. The preferred path (by 56.2%) is to use an Infrastructure as Code (IaC) solution like Terraform. The alternative (preferred by 32.9%) is to have infrastructure provisioning baked into the deployment pipeline.
Some organizations allow developers to provision infrastructure themselves via cloud consoles. While this is one way to enable some degree of developer self-service, it has significant downsides. Cloud consoles, portals and a “click-ops” approach are less standardized, compliant, highly risky and error-prone.
The inability to reuse the same configs in multiple environments slows down teams working in click-ops setups. Lack of config versioning hinders audits and rollbacks. Additionally, the risk for key-person dependency is extremely high. Oftentimes, a “god mode” admin is the only team member who can understand and replicate the setup.
Resource Assignment and App Bootstrapping Capabilities
When it comes to assignment of resources, low-performing teams still overwhelmingly rely on Ops. Every service needs a number of resources — databases, DNS, storage or something similar — in order to run. Oftentimes, teams want to connect the same resources to different services across all environments, or vice versa. For example, you would not want to use your real customer database that is also used in production to run your e-commerce app in a testing environment.
Who assigns resources to an app and how varies significantly across respondents. Close to 85% of top performers let developers self-serve resources within golden paths. The presence of golden paths indicates that these organizations also have an IDP, or something similar, that is designed to enable developers to self-serve resources without fear or risk of screwing things up. This minimizes cognitive load and contributes to a great DevEx.
Finding Information
Managing all dependencies between apps and assigned resources is often a challenge, especially in larger organizations with complex setups. It’s helpful to understand where engineers go when they need more information to navigate or use their setup.
Top-performing teams report using a version control system (VCS) (76.7%) or a service portal (17.81%). Similarly, high-performing teams rely on a VCS (65.52%) and service portal (21.5%). Only low-performing teams rely on their Ops or infrastructure team (35.4%), or have to dig around inside the app because of hard-coded connections (22.7%).
The last indicator of developer self-service we asked about is how long it takes a team to bootstrap a new app (and all dependencies) and deploy it. As you might have guessed from the previous results, top-performing teams tend to be faster: 53.4% can achieve this in less than two hours, and 39.8% can do it in one day. In contrast, 36.9% of low-performing teams need up to one week, and 31.1% need even longer than that.
True Developer Self-Service Isn’t Just Shifting Left
True developer self-service requires more than simply shifting DevOps tasks onto developers. Executed poorly, shifting left increases cognitive load on developers and reduces overall productivity.
To improve developer experience, enabling developer self-service and reducing cognitive load must go hand-in-hand. Golden paths are key to enabling self-service without running the risk of individual developers becoming overwhelmed or screwing things up. Successful IDPs help engineering organizations strike the right balance between developer freedom and support by paving golden paths.
McKinsey says that “platforms improve user experience by offering a curated set of tools and services, designed to present users with best-of-breed technical capabilities and highly optimized processes without end users having to create the operating platform for themselves.”
Golden paths enable top-performing teams to self-serve resources like databases, DNS and storage without running the risk of breaking the entire setup. They maintain developers’ access to underlying technologies, preserving their freedom to move quickly and independently of Ops where necessary. Golden paths also provide the right abstractions to minimize complexity and cognitive load by default.
In short, IDPs and their golden paths enable the right kind of developer self-service that allows organizations to implement separation of concerns without shoving developers and Ops back into their silos. That’s what makes IDPs key to enabling developer self-service, improving developer experience and propelling organizations into a higher stage of DevOps evolution.
Want to learn more about how to improve your organization’s DevOps setup? Download Humanitec’s “2023 DevOps Benchmarking Study” for more expert insights.
