Pitfalls of Developer Self-Service Platforms — and How to Avoid Them

Developer self-service platforms have become one of the hottest trends in the world of software development. By promising to make it easy for developers to obtain the tools and environments they need to be productive, self-service solutions can theoretically speed software development operations, while also reducing friction and frustration for coders.

Often, developer self-service platforms achieve these goals. But as this article explains, self-service strategies sometimes create more problems than they solve. Before jumping on the developer self-service bandwagon, it's critical to make sure that the strategy you're considering actually creates value for your developers and your organization as a whole.

What Is a Developer Self-Service Platform?

Developer self-service platforms (also called internal development platforms) are collections of preconfigured tools and services that developers can launch to help them do their jobs.

For example, if developers need to launch a Kubernetes cluster to test an application they're building, a self-service platform might provide them with access to a ready-made cluster that they can launch on demand. Or, if they need to deploy a CI/CD pipeline where they can work on a new application, they can turn to a self-service platform to obtain a set of CI/CD tools that have already been configured for them.

Related:What Is a Software Developer and What's the Best Way to Become One?

The major goal behind developer self-service platforms is to allow developers to obtain the solutions they need to be productive without having to configure and deploy them on their own, or ask the IT department to do that work for them. For this reason, self-service platforms have become one of the latest, greatest concepts in the world of DevOps, where the ability to deliver software faster and more efficiently is a key focus.

Potential Problems with Developer Self-Service

In theory, developer self-service platforms are a great thing. Acquiring, deploying, and configuring software development tools can take a lot of time, and any solution that helps automate the process for developers can bring real value and efficiency to the software development process.

That said, simply deploying a self-service platform is no guarantee that your developers will be more productive or enjoy their jobs more. On the contrary, self-service solutions can cause problems like the following:

Limiting developer creativity

When developers are expected to obtain the solutions they need via a self-service platform, their tooling options are inherently limited because they can select only from the solutions included in the platform.

Related:Reassessing Agile Software Development: Is It Dead or Can It Be Revived?

That may be fine if your developers are happy using a standardized collection of tools and configurations. But if they have bespoke needs, or if you have a large group of developers with widely varying preferences, they may find self-service platforms frustrating and stifling.

Shadow IT risks

Self-service platforms also create the risk that some developers will implement solutions on their own because they're not satisfied with the offerings built into the platform. If they do, they create a kind of shadow IT because they launch resources that are likely not to be officially sanctioned, or properly monitored and supported, by your IT department.

Wasted spending

When it's very easy for developers to launch tools and resources, it also tends to be easy for them to forget to turn things off when they are no longer using them. And if they leave extraneous resources running, the business is likely to be stuck paying for unnecessary infrastructure and services.

Developer-ITOps disconnect

A major goal of developer self-service platforms is to help developers obtain what they need without having to talk to the IT department. That's good to an extent because IT engineers shouldn't have to spend their days catering to mundane developer requests.

But at a certain point, trying to automate interactions between development and IT can become a bad thing. Having conversations between the two groups is important for keeping them on the same page and ensuring that they are aware of each other's needs. If your developers never talk to your IT engineers because they do everything using a self-service platform that the IT team implemented, it's likely that the self-service platform will do a poor job of aligning with developers' needs due to lack of communication between the two groups.

Doing Developer Self-Service Better

To be clear, my goal isn't to argue that developer self-service platforms are inherently bad and should be avoided. Instead, it is to highlight what can happen when businesses implement self-service solutions that do a poor job of meeting developers' needs.

Fortunately, avoiding this risk is simple enough. The key is to ensure that the self-service solutions you offer to your developers reflect their input about which tools, services, and configurations they actually want to use. In addition, updating offerings on a regular basis is critical so that you can keep up with changing developer preferences and requirements.

When you do those things, you get a self-service platform that will create value — for both developers and the business as a whole.