Why a Good Developer Experience Matters
Tags: kubernetes, vcluster, devspace, loft
Published: 2022-06-16 15:23:15

By Tanaka Mutakwa

Applying the notion of user experience (UX) to software engineering, developer experience takes place on the other side of the product. The concept of developer experience describes how developers feel about working with or within a system. A good developer experience means providing developers with everything they need to fully focus on doing their work the best way possible.

DevOps and platform engineering teams are responsible for the design of products or systems that are selected and used by developers and, as a result, have a significant influence on developer experience. However, sometimes, DevOps engineers don’t understand the struggles that developers have, which can lead to friction between the two groups.

In this article, you will learn what can lead to a bad developer experience and why a good developer experience matters.

## What Can Lead to a Bad Developer Experience?

There are several ways that platform teams, whether unintentionally or otherwise, can complicate developer experience. Here are a few examples.

### Forcing Developers to Use Specific Tools

Deciding on all the specific tools developers must use can take away their autonomy and creativity. While it is important for platform teams to set standards and guidelines for important approaches, such as how services are deployed and monitored, developers should be given the freedom to choose the most appropriate tools for their job.

Additionally, developers’ interests can be overlooked by platform teams in their attempts to build tools that work well only for platform engineers. These tools may work well for the platform engineers but may be frustrating for developers to use. When this happens consistently and developer concerns are not taken into account, it will eventually harm productivity. It is important for platform teams to always consider the developer experience when building and enforcing tools to be used by developers.

Allowing developers to make decisions for their team and select their own tools empowers them and promotes a positive developer experience.

### Using Old Technologies

Technology progresses very quickly. Tools, stacks, and frameworks get deprecated and become obsolete over time as new and better ones get released. By failing to adapt to new technology, developers’ day-to-day work becomes undermined by manual processes and legacy code. Being stuck using old technologies can be a major point of frustration for developers, so platform teams should aim to provide them with the latest tools and frameworks wherever possible. This will allow developers to focus on their day-to-day work and spend less time on easily solvable tasks, such as managing environments or automating code production.

### Not Having Consistency or Guidelines

When there is a lack of consistency or guidelines on how to do things, developers will likely come up with different approaches based on their specific team or project. It can be very frustrating for a new developer trying to onboard or transition in this environment. Platform teams should aim to achieve a common approach to how services are deployed and monitored. This is especially important in a distributed, microservice environment, as it brings about consistency for the developers to rely upon. Platform teams should also provide easily accessible guidelines on how to use their services. This makes it easy for new developers to onboard and existing developers to have an understanding of what services are available and how to use them.

### Not Having Psychological Safety

In a toxic environment, developers may not be given the freedom to make decisions, their ideas may not be taken seriously, and they may not receive useful feedback. Developers in these environments can be scared to take risks and are often unproductive, frustrated, or looking for better opportunities at other companies. Platform teams should aim to help create a psychologically safe environment that is collaborative and provides an open channel for feedback with mutual respect. Platform teams should also aim to create tools—such as feature toggles or automated rollback systems—that enable developers to experiment, fail, and learn in a safe environment and see consistently better results.

### Having Poor Communication

A lack of good communication between platform teams and developers also creates a negative developer experience. Poor communication, whether written or verbal, creates confusion surrounding when and how to use the tools put in place by platform teams and can lead to incorrect implementations or long, unnecessary delays. Platform teams should strive for proactive and clear communication with developers to curtail frustration and ensure that developer efforts are spent on the right tasks.

### Setting Unrealistic Deadlines

Finally, when platform teams set unrealistic deadlines for developers, this can often lead to burnout and poor-quality software. While companies want their software built as fast as possible, it is important to provide a sustainable pace for developers to perform in the long term. Platform teams should set developers up for productivity success by ensuring that they set realistic, if challenging, deadlines.

## Why Does Developer Experience Matter?

On the other hand, companies that place emphasis on promoting a positive developer experience reap a variety of benefits. Here are just a few.

### Better Cooperation between Departments

A good developer experience means there is good communication and trust between the developers and other departments across the company. This helps address one of the biggest challenges in modern companies: collaboration and alignment between departments. Having improved cooperation between departments leads a company to function well as a unit and, ultimately, to make better and quicker decisions at large.

### Increased Productivity

One of the highest priorities for software companies is to increase developer productivity. Companies attempt to use many different approaches to achieve this; however, one of the best ways to increase developer productivity is by providing a good developer experience. Allowing developers to focus on their day-to-day work of building the products without the distractions of a poor developer experience leads to better productivity.

### Quicker Go-to-Market

Along similar lines, increased productivity means that developers can do their work more efficiently. In turn, this speed at which a company can get its products or new features to its users can lead to a massive competitive advantage.

### Longer Developer Tenures

Developers know that they are a valuable asset in high demand, making it easier than ever for them to change jobs. Having a good developer experience at your company will lead to more fulfilled developers and increased retention, thus helping your company ensure business continuity in the long term.

## Conclusion

It is important for DevOps and platform engineering teams to consider ways to create a positive developer experience. Poor developer experience leads to frustration, protracted development, and unhappy developers.

In contrast, a good developer experience leads to developers who are happier and more satisfied with their jobs. Satisfied developers will work more efficiently and productively, ultimately producing better quality products and success for your company.

*Photo by [Mimi Thian](https://unsplash.com/@mimithian?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) on [Unsplash](https://unsplash.com/s/photos/developers?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)*