Best practices for creating a great developer experience (DX)

With happy and productive software developers in your team, you can count on high-quality products and excellent results.

But how do you get software developers who enjoy their work? By ensuring that you create a great developer experience for them.

Behind that term lies the seemingly simple idea of providing your developers with the tools, environment, and a pleasant work experience in which they can fulfill their potential.

We say seemingly simple because it requires thought and using some helpful practices. Luckily, this article is all about the best ones.

Let’s check them out!

Have good internal documentation

Having detailed and easily accessible documentation for your developers can make their day-to-day work more streamlined and their experience better.

First and foremost, a good internal documentation saves time for your developers, and as you already know, time is their most precious resource.

Lei Zhang from Bloomberg explained it clearly—useful documentation saves time for important tasks.

If you keep your documentation up-to-date and comprehensive, developers can find all the information they need about the project, as well as the answers to any questions they might have, and, in short, access the collective knowledge of the whole company.

Documentation can also make developers more productive.

According to The State of the Octoverse Report, having access to updated information on projects, reliable guidelines, READMEs, etc., can boost productivity by 50%.

If we put everything mentioned together, spending less time digging for the information and more time on productive work means better developer experience—and having a good source of internal documentation can ensure that.

But what should you have in your internal documentation so that your developers’ experience is as good as it can be?

Many documents and materials can be considered important for software development. For example, take a look at the classification from Altexsoft below.

That amount can seem overwhelming. However, you don’t need to write an encyclopedia of it to be useful for your developers.

For instance, you should consider having a README file. It’s a simple file that, in essence, introduces a developer to a project.

It can be more or less detailed, but you should include relevant information so it can be used as a guide for the project.

You can see some of that information in the example below—it has a project name, description, contribution guidelines, and instructions.

In addition to that, you can include credits, licensing information, and more—you can check the article from Hillary Nyakundi for more ideas.

Code walkthrough documentation is also very helpful for your developers. It shows code snippets and walks a developer through code practices and interactions.

It’s an effective way to familiarize them with the codebase.

Process documentation can be very valuable for developers as it includes practical information about procedures, resolving issues and incidents, etc.

Having a guide like that, also called a runbook, ensures that every developer knows what to do and how to do it in various situations they might encounter.

For example, GitLab has a detailed process documentation page.

We could go on and on about the materials you can include to improve your developer experience. Those we’ve mentioned are just the fundamentals.

However, the tools you use to build it are also important. You should choose something easy to manage, simple to use, and powerful enough for your needs.

For instance, Read the Docs is an open-source tool in which you can store every document you want.

It’s also easy to import documentation in it, download it and search through it, which is helpful for your developers.

Whatever tools you choose, the important thing is to provide your team with detailed, valuable information that they can use in their work. Without that, their experience won’t be a great one.

Embrace automation

Developing quality software is challenging and complex work. Developers need to complete various tasks every day, not to mention constantly learning and improving their skills.

Their time is valuable, so embracing automation is essential for developer experience.

When we’re talking about automation in a software development context, that doesn’t mean using some advanced AI to replace your developers—it means using technology to help those developers be more efficient and satisfied in their jobs.

And that isn’t just wishful thinking.

Data from The State of the Octoverse Report indicates that software development teams perform 43% better and developers are more fulfilled at work when they can automate repetitive tasks.

Therefore, automation can help developers spend less time manually performing tedious tasks—you’ll be hard-pressed to find a developer whose experience wouldn’t be better that way.

However, even those repetitive tasks are essential to software development. One of them is testing.

Testing is a great example of where automation can fit in.

Testing code is vital for the quality of the product and users’ satisfaction, but it can be time-consuming for developers to do it manually.

Instead, you can use tools like Postman to make that process faster and more accurate.

It’s a platform for building and using Application programming interfaces (APIs), but it also has a feature for automated testing.

Developers from Gear4music experienced the benefits embracing automation of testing can bring.

According to them, they write, run and automate tests with Postman.

Before that, testing happened near the end of the project and discovered errors sometimes delayed the shipping of the project.

Thanks to automation, that process is now more efficient as they can do API testing throughout the project.

Automation is increasingly recognized as a real value for developers, so it’s not surprising that GitHub, one of the most popular code repositories, has its own automation features.

They’re called GitHub Actions and can be used in a number of ways.

One of the most useful ones for improving developer experience is checking code for security issues and vulnerabilities.

That’s a task that requires a lot of focus and time from developers, but GitHub’s CodeQL, a semantic code analysis engine, can take a lot of that work from their plate.

Automating processes related to CodeQL helped even GitHub’s developers to report vulnerabilities.

They can use an automatically generated report template with filled-in details and a unique ID attached to the report.

That way, a developer can report an issue quickly and go on to do other productive work.

Dealing with errors and bugs can be detrimental to the developer experience, but not when there’s a solution for making that task hassle-free.

Our own product, Shake, is built precisely for that purpose.

With Shake, your developers receive a detailed bug report from users with every information they need to know to fix it quickly.

It takes seconds for users to generate that report—they just shake the phone when they encounter an issue.

Shake automatically attaches all the information about the app, user history, screenshot, or video—in short, a developer gets everything needed in one report.

Automation can make tasks that tend to require a lot of patience and time from developers much more manageable, which is part of creating a great developer experience.

Give devs the tools they need

Tools developers use in their work can significantly impact their productivity, satisfaction, and results.

Giving them what they need should be among your priorities when creating a great developer experience.

Tools that are ineffective, complicated, or simply just bad can cause frustration among your developers.

Nobody gets anything from that—developers are unhappy, users don’t get quality products, and your business isn’t as successful as it could be.

After all, technology and tools are the second most important factor for developers when looking for a job. According to a 2020 survey by Stack Overflow, it’s right behind money.

Notice that they don’t mention just the technologies in the survey; it’s the new technologies part that you should consider.

That isn’t surprising. Software development is a dynamic field that rapidly changes, so developers know that they need to keep up if they want to stay on top of their game.

Using outdated technologies isn’t a part of a great developer experience.

You can take different approaches to provide your developers with the tools they need. For instance, Bloomberg uses primarily open-source tools.

Here’s Lei Zhang again, this time on technologies used at his company.

“We strive to use open source tools for both our own and our developers’ use wherever it makes sense to do so. This includes Git repository hosting (in the form of GitHub Enterprise) for source control, build systems like CMake, Kubernetes to automate the deployment and scaling of containerized applications, Docker to run applications in containers, Google Test and Google Mock for testing, Clang Tools for static analysis, Jenkins for Continuous Integration/Continuous Delivery, and Grafana for system-wide telemetry.”

Open source or not, the point is that you provide your developers with efficient tools if you want to make their experience great.

For example, they certainly need a code editor on a daily basis. For that, you can’t go wrong with Visual Studio Code.

It’s one of the most popular code editors, packed with helpful features like integrated debugging, built-in Git commands, and various extensions.

One of the most interesting features is IntelliSense, a smart autocomplete function that considers programming language, keywords, variable types, interfaces, etc.

Many developers like to combine a code editor with a code formatter, making their code consistent.

Overall, that also improves the developer experience because everyone’s code is clean and easy to read.

For that purpose, Prettier can be a great solution.

According to one developer, using a code formatter improves developer experience by letting them focus more on the business part of development and code reviews instead of code formatting problems.

Of course, your developers most likely use one of the code repositories.

GitHub, GitLab, and Bitbucket are among the most well-known ones, and for a reason—they’re simple, have a large user base, and can be very valuable in day-to-day software-building work.

Which one your developers use comes down to their preference, but also to other factors.

For instance, GitLab is more suited for DevOps teams, Bitbucket is excellent if they use Jira, and GitHub is a well-rounded platform with plenty of features.

The tools mentioned in this section are only the tip of the iceberg. Many more can contribute to a great developer experience, and it’s worth exploring them further.

Evaluate and improve your processes

Although consistency in the work process is generally viewed as a positive element, you should know when to evaluate them and change to provide your developers with a great experience.

Sticking with processes that don’t work with your developers won’t suddenly make them work.

On the contrary, if you don’t reevaluate and improve, it could lead to frustration and even your developers leaving the team.

They might already think that you don’t know what they want in their work.

For example, according to a survey by Pluralsight, many developers believe that managers don’t understand what makes them productive.

As you can see, the higher up the manager’s ladder they go, the less they think people understand their work process.

The approach many companies are adopting lately is to create psychological safety.

That’s the term coined by Harvard Business School professor Amy Edmondson. Here’s how she defines it.

In other words, that means that you trust your developers and give them autonomy in their work.

More freedom and trust create a better developer experience. Your developers can feel that they’re valuable and can work on their own terms, as long as they deliver results.

But what if you feel like you need to change the whole framework? That’s what Adobe did when they evaluated their processes.

When the company moved to cloud-based services for its popular software products, their work processes changed.

Instead of developing software for months and releasing it once it’s finished, they needed to make many regular software updates.

Therefore, they needed to evaluate and improve, turning to the DevOps system.

That resulted in faster releases and better product management, leading to a 60% increase in their daily and weekly software delivery volume.

DevOps clearly worked for Adobe’s business results but also for its developers.

According to Ryan Granard, the company’s former Vice President, they could concentrate more on their preferred tasks—building great customer experiences.

However, that doesn’t mean that it is a universal solution for every developer team. DevOps requires a wide range of skills, which could turn out as it did for this Reddit user below.

Developers have more responsibilities in DevOps, from writing code and testing to user support.

It’s vital that you evaluate that process and assess if it’s right for your development team before it drives them to the breaking point.

That also stands for any other process your developers might use.

A great developer experience is possible only if the processes bring out the best in them, so ensure that you regularly improve them when the time comes.

Conclusion

Creating a great developer experience translates into many positive outcomes for your business.

Besides having and keeping a team of happy and satisfied developers who have everything they need to produce outstanding software, you get happy and satisfied customers who use that software.

Of course, that leads to better business results and more resources for creating an even better developer experience. It’s a loop you want to be in.

By embracing the practices from this article, you can accomplish that.

Keeping good internal documentation, automating tasks, providing needed tools, and constantly evaluating and improving are the foundations of a great developer experience.