Developer Self-Service: The Benefits for DevOps & How Platform Engineering Makes It Happen
Developer self-service can sound like a dream: A platform that developers can use to freely develop — unburdened by sprawling IT, tools they shouldn’t need to know how to use, and tickets that take forever to complete. But in DevOps, self-service is becoming a differentiator for organizations with growth goals, widening skill gaps, a need for visibility, or just an appetite for better DevOps efficiency.
Let’s take a look at the concept of developer self-service and how DevOps self-service is already benefiting organizations.
What is DevOps Self-Service?
Back to topDevOps self-service is the use of automation to let development teams work independently while working with operations. DevOps self-service breaks down siloes to make dev and ops teams more efficient and productive.
What is Developer Self-Service?
Developer self-service describes automated tools and processes to empower developers to workwithout help. Developer self-service tools include tools for coding, building, testing, and releasing software.
Self-service is the idea of giving workers the tools they need to do work on their own. In the DevOps world, a developer self-service platform is called an internal developer platform. The process of creating an internal developer platform is called platform engineering.
Back to topDevOps Self-Service Examples: With vs. Without Self-Service
With self-service, developers can focus on doing their best work and driving value for the company they work for and its customers. Without it, developers can quickly run into bottlenecks, wasted time, and unnecessary overhead management.
Check out more examples of the value of self-service with our blog about self-service automation >>
Example: Spinning Up a New VM With and Without Developer Self-Service
Here’s an example of a common scenario in which a self-service DevOps platform can make a difference:
With Developer Self-Service… ✅ | Without Developer Self-Service… ❌ |
A developer can request a new VM from one portal and have it in minutes, no tool expertise required. | Provisioning, configuring and reporting takes many different tools, which a single developer may not know how to use. |
They can act alone without burdening other teams to get what they need with minimal human intervention. | Using those tools can take many different teams, who may or may not have time to help. |
Baseline configuration, security, compliance, and reporting are all baked in and available at their fingertips. | The end-to-end process can take many steps to make sure everything is set up properly, which will probably get bottlenecked along the way. Configuration drift often occurs here, too. |
More Examples of DevOps Tasks With and Without Self-Service
To better understand why self-service is important, compare a few more common DevOps processes with and without self-service below:
With Developer Self-Service… ✅ | Without Developer Self-Service… ❌ |
Developers don’t have to generate a ticket or wait for support to take action.* | Developers have to generate a ticket and wait for reps to interpret, confirm, plan, and enact the change. |
Developers can be given tools to make the change and authorization appropriate to the work they’re doing with role-based access control. | Only a person with authorized access to the system can complete a dev’s change requests. |
Consistency and repeatability are built into the DevOps self-service platform. | Things get lost in translation, which can lead to rework or duplication of work. |
Measures like zero-trust security and RBAC can be built into the platform. (No more password-sharing!) | Authorized individuals are incentivized to share passwords through email and Slack to bypass the whole process and just make changes quickly. |
*A tracking ticket can be logged automatically when needed using a tool like ServiceNow with Puppet.
Back to topThe Benefits of Developer Self-Service for DevOps Teams
When they’re not beholden to other departments for support, developers have more time for the work they get paid to do. Self-service gives devs more time for coding, building, testing, QA, and everything else they need to make great software.
Why 9/10 Teams are Democratizing AutomationSelf-service automation is on the rise. Download our free explainer to learn how to make happier, more productive teams with self-service automation. |  |
Developer satisfaction is the primary goal of a DevOps self-service platform, but the benefits of developer self-service as part of a platform engineering initiative go far beyond making developers’ lives easier. When it comes to adopting self-service, it turns out the rising tide actually can raise all ships.
In response to our 2023 survey, a majority of individuals doing platform engineering reported seeing benefits of self-service across the entire organization.
Puppet’s survey results show that the benefits of DevOps self-service in platform engineering include:
- Improved development velocity (68%) (42% say it’s improved “a great deal”)
- Improved productivity (59%)
- Improved system reliability (60%)
- Better workflows and process standards (57%)
- Improved security (55%)
- Standardization that reduces duplication of work (53%)
Additionally, the same survey showed that DevOps self-service can help an entire organization evolve its DevOps practices. 65% of highly developed DevOps organizations are using self-service, while organizations with less-mature DevOps initiatives have adopted self-service at far lower rates (only 40%).
Back to topHow to Start Offering Self-Service to DevOps Teams
Of course, no DevOps team can go from zero to fully self-service with a snap of their fingers. There's a reason self-service has been the last stage of DevOps maturity in the 10+ year history of our DevOps reports: Implementing self-service requires careful assessment of your team's needs, a strong automation framework, and the right tooling.
Now that we've covered the benefits of self-service for DevOps, here are some considerations for starting to offer self-service to your teams:
Step 1: Find Out What Should Be Made Self-Service
We've found that self-service for DevOps teams is usually a product of two key factors: Demand and repeatability. What does that mean? It means the tasks that are both common enough to be a bother and repetitive enough to be standardized are the best candidates for self-service.
For example, tasks like provisioning new servers, tweaking configurations, and restarting services are great candidates for self-service. Most DevOps teams do those things quite often, and it's done largely the same way almost every time.
And here's a contrasting example to better illustrate the point: Migrating legacy applications to the cloud is a task that probably doesn't need to be considered when planning self-service capabilities for your DevOps team.
- You're probably not doing that very often as a DevOps organization, so it's not like there's massive demand from dev and ops to make it self-service. And when you do have to move legacy apps, it's an incredibly in-depth process that requires refactoring code, reconfiguring services, and other things that can't be easily automated or standardized.
Step 2: Create an Automation Framework for Standardization and Security
All self-service relies on automation. In a literal sense, that can be automation scripts that repeat simple tasks, but practically, scripts aren't really good for real self-service (they're not scalable, they need constant maintenance, etc.). So for most DevOps teams, especially in large and enterprise organizations, an automation framework usually relies on infrastructure as code tools like Ansible, Terraform, and Puppet.
A robust automation framework lets you define standard configs, guardrails, and policies that make sure each self-service DevOps task is performed the same way every time. That ensures consistency, predictability, and efficiency without compromising your IT security and compliance posture.
Step 3: Build or Integrate a Self-Service Portal
After you've hashed out what will be self-service and how it'll be automated, you'll need to figure out how those tasks will be offered to your DevOps teams. Self-service is usually offered in a way almost anyone can use, like a graphical catalog or menu of options.
- If you've got the time and investment, you can build a self-service portal for DevOps tasks. In fact, DBS Bank in Singapore did exactly that with Puppet as the automation framework.
- Building a self-service platform for developers is the whole point of platform engineering. Go behind the trend with our annual report on the state of platform engineering >>
- You can also integrate your DevOps tools with pre-built self-service and ITSM (IT service management) platforms. Most integrate with common DevOps tools and feature built-in access control. ServiceNow is the best-known provider of self-service capabilities — including for self-service Puppet automation.
How Automation Powers DevOps Self-Service
Under the hood of any developer self-service platform, IT automation streamlines infrastructure provisioning, configuration, management, and all other aspects of DevOps self-service. It automates the common functions that developers spend too much time on and packages them in one central DevOps self-service platform. In other words, automation is what makes a self-service platform truly self-service.
Before using Puppet, many enterprises find themselves struggling with a lack of self-service provisioning. But defining infrastructure as code with Puppet makes sure the infrastructure that developers need is set up the right way every time, including provisioning, configuration, security, compliance, and desired state management. Puppet also enables DevOps scaling, so your DevOps self-service platform can add tech and stay consistent as your company — and your goals — grow.
Find out more about enabling DevOps self-service with Puppet and ServiceNow, or see it for yourself by scheduling a demo with a member of the Puppet team.
PUPPET + SERVICENOW DEMO PUPPET
Back to top
