Software developers go to great lengths to consider user experience (UX) in the product lifecycle. But, software engineering is now starting to consider the developer experience (DX) as well.
Developers work within an increasingly complex world of cloud infrastructure, client libraries, SDKs, APIs, and open source code in their pipelines. It’s not always easy, which is why developer experience focuses on cultivating a more positive and streamlined experience for developers.
Read on to learn more about DX and why it’s important, as well as 11 strategies and tools to improve developer experience.
What is Developer Experience (DX)
Developer experience is a direct parallel to user experience. Developer experience focuses on the developer as the user and customer of a product, and it aims to improve the experience of interacting with the product.
It’s easy to ignore developer experience, especially with the assumption that developers have the skills to just “figure it out.” While that’s often true, think of the time developers could save if we made processes streamlined from the get-go. That’s one of the things developer experience teams set out to do. Great developer experience aims to create efficient and intuitive development workflows, both in the frontend and backend.
Not only is it practical from a business standpoint (saving time = saving money), but it’s simply about keeping your developers happy. It’s ultimately a practice of empathy. Improving DX is all about asking the right questions. What is the developer journey, and where are the points of friction?
Similar to how UX deals with the journey of end users, looking at the developer journey map — the user’s goals, emotions, path, touchpoints, and pains — helps to uncover areas for improvement. As such, DX improves the usability of the development platform.
Why having a developer experience strategy is important
Businesses understand the importance of investing in good UX, but investing in good DX is equally important to business health and product success.
Having a poor developer experience can delay time-to-market and contribute to a poor work culture. Many tools that promote good DX – like cloud implementation, APIs, and low-code solutions – promote flexibility and a low-risk incentive for developers to experiment. In addition, because most developer tools are SaaS (Software as a Service), they help reduce the overall cost of development to a low monthly fee, instead of costly upfront software expenses. Investing in good DX can also go a long way in attracting and retaining quality developers.
Achieving good DX goes beyond simply providing continuous delivery or reducing the gap between development and operations in DevOps teams. It involves asking critical questions about the developer’s experience throughout the project.
Here are some questions you can ask as metrics for a positive developer experience:
- What’s the cognitive load involved in completing an action? Cognitive load adds up as the day goes on, and frequent decisions add to decision fatigue.
- How many context switches does a developer go through in a day? This could be switching between platforms, or switching between types of tasks. Frequent context switches reduce productivity.
- How many interfaces are the developers using? In addition to GUIs, developers use API and CLI. Are these interfaces intuitive? Can you reduce the amount of interfaces your developers are using?
- Who does the developer interact with, and how effective is communication and interaction? Does it detract from the developer’s work?
What good DX looks like
Development teams with great DX have an increased sense of ownership and responsibility, a common goal, and an overall friendly atmosphere. These teams also allow for failure without penalty. In contrast, teams with poor DX can have finger pointing, constant crunch time, penalties for failure, and a diluted feeling of shared responsibility.
Although most of these effects of a good DX center around company culture and team atmosphere, specific improvements in the development process have an equally important impact on improving the developer experience. This can include automatable interfaces, infrastructure that’s easy to source, a seamless onboarding process, and a strong guide for how to work with the API, libraries, and platforms.
11 strategies and tools to improve developer experience in your organization
These 11 tools and strategies will help you improve developer experience in your organization. We chose these developer experience tools because they’re relatively easy and cost-effective to implement and will have the largest impact on your developer experience strategy.
- Start with company culture
Having a positive company culture is an integral part of a good developer experience. A positive and encouraging company culture empowers developers to innovate and take risks, and keeps them motivated at the task at hand.
In order to promote a healthy company culture, engineering teams should focus on providing a collaborative environment that honors everyone’s voice. There should be little retaliation for failures, to encourage innovation and risk-taking. Implementing these other 10 developer experience tools and strategies can also go a long way in promoting a healthy company culture because it shows developers that management cares about improving their daily experience.
- Developer onboarding
Developer onboarding is the first instance where the quality of DX shows. Onboarding developers in the middle of a project with no support or guidance can be frustrating and inefficient. It’s equally important to maintain momentum from the moment of onboarding to the initial start of the project. Provide developers a structured plan so they know exactly what will be expected of them at every step of the way.
Especially when working with new developers, it can be useful to assign small, specific tasks and then gradually add complexity. This can help build a strong foundation without throwing them into the deep end. Taking care to provide a smooth onboarding can help develop momentum for bigger projects.
- Understand the developer journey
Understanding the developer journey is as important as understanding the user journey. It can help build empathy with your developers, as well as understanding what they need in order to do their job most effectively. Are there any silos in the journey? Is there efficient communication at every step of the process?
You can get this information by asking your developers, as well as observing their work patterns.
- Time management and productivity tools
Effective time management is essential in order to meet software delivery deadlines without burning out your developer team. Scheduling uninterrupted Focus Time with Clockwise allows your developers to focus on their daily tasks without the context switches of having to attend meetings scattered throughout the day.
Asana is a great tool to help DevOps team stay on track with who is responsible for what tasks. Clockwise integrates with Asana to add tasks automatically to your calendar without having to switch between platforms. By utilizing time management and productivity tools, you can improve your DX by helping developers focus on the development process.
- Effective communication
Friction between management and team members often happens because of poor communication. Focusing on efficient ways to communicate can improve your developer experience by contributing to a more positive company culture, as well as being able to communicate potential problems and delays.
Clockwise helps automate meeting scheduling, so all parties can meet when convenient. Slack is also a great tool to facilitate asynchronous communication. The Slack integration by Clockwise automatically turns on Do Not Disturb time according to your team’s calendars.
- Improve workflow and shorten feedback loops
Agile and lean product development means working in small batches that facilitate a short feedback loop. A short feedback loop allows developers to receive feedback and iterate quickly. Implementing continuous integration and delivery tools like Jenkins or go.cd go a long way in feedback automation and shortening the feedback loop.
In addition, you can improve the workflow by providing a link to your source code or codebase on GitHub, and including a command to build the application. Building a microservices architecture can also help improve workflow, because small teams are in charge of highly testable services.
- Set up an IDE and use TypeScript
- Use consistent formatting with a linter
Consistent formatting ensures that everyone is on the same page, and makes collaboration and code integration easier. Using a linter, like ESLint, automates the process of code formatting, and applies all defined styling rules.
To go one step further, you should define code styles and formats in the beginning of the project, and make it part of the onboarding process.
- Use an API that put developer experience first
APIs, or Application Programming Interfaces, are the main platforms that developers work in. Using an API that’s built with the developer experience in mind can lead to happier developers and more efficient timelines. AWS by Amazon and GraphQL by Shopify are two examples of APIs that are known for a superior developer experience.
- Develop comprehensive SDKs
An SDK (Software Development Kit) is like the ecosystem in which development occurs. It contains all of the tools your developers need to get the job done. The SDK includes not only the frameworks needed to develop an application, but debugging and testing capabilities as well. The only downside of using an SDK is the potential for less security, which is why Apple seldom publishes SDKs. Microsoft and other platforms, on the other hand, risk the downside for the benefits of SDKs.
Putting together an effective SDK is all about documentation. It’s the best way for developers to understand how your platform works, and how to debug. Within your organization, SDKs are a great onboarding tool that gives your developers the tools they need to succeed.
- SemVer: Semantic versioning
Semantic versioning (SemVer) is a system for keeping track of unique iterations of your product. It’s important to keep track of every version of the product to ensure that developers are building off of the latest iteration of the product, as well as avoiding pitfalls from previous versions.
This universal way of versioning ensures that versions are correctly indexed at every step of the way, and that the system is understood by all. SemVer uses a 3 digit sequence: x.y.z. X represents major versions, Y represents minor versions, and Z represents patches. Semantic versioning helps developers inside and outside of your organization keep track of product versions and new features.
Investing in a solid developer experience strategy strengthens your product and overall development team. Developer experience tools not only improve developer experience on your DevOps team, but they also help developers outside of your organization develop with ease. Supporting your developers involves not only providing them the most effective practical tools they need to get the job done, but also fostering a positive company culture and creating a smooth onboarding process.
When developers are happy in their jobs, it’s easier to retain top talent. In addition, good DX improves developer productivity, allowing you to meet tight deadlines and produce a better product.