Introduction to developer experience: What, why, and how
Senior Technical Content Marketing Manager
The core concept of developer experience (or DevEx) is simple: happy developers are more effective developers. Great developer experiences create opportunities for success, while poor DevEx leads to frustration and delays.
Though the concept is easy to grasp, real-world developer experiences depend on many complex factors. The choice of software tools, the number of interruptions in an average workday, the efficiency of team communications, all of these variables (and many more) contribute to the overall developer experience.
Software products are ultimately only as good as their developers. Enabling developer success is the core philosophy of DevEx. Addressing developers’ challenges empowers innovation and problem-solving, helping teams work as efficiently as possible.
What is Developer Experience (DevEx)?
Developer experience is about understanding what developers like and dislike in their work environment. A quality developer experience produces high-quality software, speeds up development cycles, and improves the company’s bottom line.
The main goal of DevEx is to minimize any barriers that frustrate developers or slow down their workflows. In addition to giving developers the tools they need, DevEx also focuses on ensuring organizations have the right processes, resources, and culture to support developer’s efforts.
Key components of the developer experience include:
- Tooling: Software development relies on a huge number of tools. Development environments, project management tools, ticketing systems, and many other tools are integral to the developer’s experience. Most of their time is spent working with these tools, and seemingly small inefficiencies can compound into real difficulties.
- Workflow: Software development methodologies may be the basis of a developer’s workflow, but they only provide a template. Real-world workflows conform to the realities of business needs and the availability of resources. Workflows also fluctuate with the nuances of individual developers. Optimizing workflows for the developer experience invites us to examine the whole picture of a developer’s role and daily tasks.
- Culture: Company and team culture are major factors for any job. Cultures that foster collaboration and communication typically improve the developer experience. Meanwhile, issues like toxic competition or lack of trust in management can depress a developer’s outlook.
- Outcomes: Providing developers with clear goals, celebrating their wins, and seeing the results of their efforts come to life creates excitement and motivation to keep teams moving forward.
Why is developer experience important?
Businesses put a great deal of emphasis on the user experience. They map every step of a user’s journey looking for opportunities to optimize. The developer experience can also be mapped like this. Developers are also users. They use a suite of internal tools and processes to create software.
The developer journey varies with every team, company, and project. By focusing on DevEx, companies can ensure their talent enjoys high job satisfaction. This increases productivity, boosts morale, and creates an attractive environment for new hires.
Onboarding new developers is a crucial aspect of the developer experience. It is their first impression of what DevEx looks like at a company. Onboarding can be a maze of access requests and pinging senior staff with questions, or it can be a well-defined process of systematically introducing new team members to tools and resources.
A seamless onboarding process is a good sign for a positive developer experience. It also serves the practical purpose of getting developers comfortable in their new roles and up-to-speed as quickly as possible.
Good DevEx is mutually beneficial for the developer, the company, and the product. It helps developers get the most out of their jobs. It helps companies maximize their return on investment from hiring developers. It even benefits the end user, who enjoys a better experience using the software.
How to measure developer experience
Business runs on metrics and statistics, making concepts like developer job satisfaction seem hard to quantify. Fortunately, there are some common stats you can use to measure the effectiveness of DevEx.
We’ve divided these metrics into four broad categories of the developer experience:
- Onboarding
- Efficiency
- Quality
- Developer Satisfaction
Here are some specifics.
Onboarding and adoption
Onboarding can either serve as a bottleneck or a launchpad. Developers who encounter difficulties in onboarding may form a poor first impression of a company’s developer experience. It can also hamper their ability to get to work quickly and slow their ability to make meaningful contributions.
Some key metrics to examine the efficiency of onboarding for developers include:
- Time to first commit or merge: Tracking the interval between a developer’s first day of work to their first commit or merge provides a concrete metric for how quickly they make the journey from onboarding to contributing useful code.
- Platform usage and stability: Monitoring how new hires use company platforms and how readily they adopt their new tools provides insight into how quickly they can begin producing results. How consistently developers use their tools provides key data that shows whether the company is making the right resources available to enhance the developer experience. If the platform lacks stability, developers will frequently switch tools and search for new solutions. An ideal developer experience would provide a stable suite of tools suited for long-term usage.
Most organizations are set up to track these metrics. The time to first commit or merge can be tracked through Version Control Systems (VCS) like GitHub. Platform usage and stability tracking is available through Remote Management and Monitoring (RMM) tools that enable visibility into how much time developers are spending with specific tools.
Efficiency
Developers love to be efficient. Any stumbling blocks on the most efficient paths degrade the developer experience. To understand the efficiency of developers’ performance, you can track metrics including:
- Cycle time: A metric tracking the speed of progress from the time coding begins to delivery of that code.
- Pull request review time: Tracks the interval between one developer submitting a pull request to another team member completing a review of that request.
- Throughput: The amount of work completed in a specific timeframe. Exact metrics for measuring throughput vary from team to team. For example, some teams may track the number of tasks completed weekly as their throughput, while others may track the number of user stories in a given sprint as their throughput. Another important metric for throughput is the number of automated workflows run or triggered by code changes.
- Mean Time to Repair (MTTR): MTTR measures the average time it takes to fix an error and return the system to its operational state.
- Workflow duration: The overall duration of a given workflow from initiation to completion. Durations can vary significantly depending on the project’s complexity.
- Idle time: Tracking how much time your developers spend idle can reveal inefficiencies or major challenges in the developer experience. While some idle time is necessary, excessive idling may signal frustrations with tools, or difficulties with context switching.
Tracking efficiency requires a variety of different systems. Workflow duration, idle time, and cycle time can be measured with RMM software. Data on pull requests and review times can be found in VCS tools. Stats like MTTR are often tracked through incident reporting tools and ticketing systems. Throughput may be tracked through project management tools or other means, depending on the team’s metric for throughput.
Quality
Supporting developers’ productivity enhances the quality of their output. DevEx should take steps to track the quality of developers’ work, as poor or inconsistent quality can be a potent indicator of problems in the developer experience.
Most software development teams track metrics relating to their code quality. These same metrics can assist in understanding DevEx:
- Code coverage: How much code is executed during automated testing. High code coverage is a hallmark of quality code.
- Success and failure rates: Low success rates are a common sign of DevEx challenges. Data on build and test workflow success rates tracks whether code passes internal quality gates and reveals how much code is ready for deployment. Failure rates tell the other side of the story. High numbers and rates of deployment failures, commonly encountering critical issues, and incidents of performance degradation can all be symptoms of underlying issues in the developer experience itself.
- Defect density: The number of defects per line of code. While bugs are inevitable, high defect density can reveal problems in tooling, testing, code review, and other crucial areas of the developer experience.
Tracking code quality relies on automated tools like code coverage and defect density reports. To see the full picture, this data should be combined with data from incident reporting and ticketing systems tracking failures and bug reports.
Developer satisfaction
The ultimate factor in developer experience is the happiness of the developers themselves. How satisfied are they with their day-to-day work? How do they feel about their team, project, and product overall? How do they feel about their work and their contributions to the team? Are they making a meaningful and visible impact on the project?
Engaging directly with developers allows them to express their unique perspectives and offer real-world feedback. In addition to tracking the metrics we’ve discussed above, organizations can also look to:
- Engagement survey results: Engagement surveys provide insights into job satisfaction and provide useful feedback directly from developers. A well-crafted survey will allow respondents to rate and comment on the developer experience.
- Retention and churn rates: How likely developers are to remain at a company (retention rates) and how often the company replaces developers (churn rate) are vital metrics for understanding the long-term results of DevEx.
Gauging developer satisfaction requires engaging directly with developers. While a survey may not provide the empirical data of many other DevEx metrics, it offers a valuable human connection to the reality of developers’ day-to-day experience.
Improving developer experience
Good developer experiences promote flow states. While in a flow state, a person is completely focused on a particular task. They feel engaged, energized, and able to give their best efforts to the task at hand.
Developers flourish in flow states. They avoid annoying context switching, are free from interruptions, and move seamlessly from one task to the next.
Best practices for improving the developer experience vary from one team to the next. But there are some general-purpose best practices to keep in mind:
- Standardizing with platform engineering: The practice of platform engineering prioritizes DevEx and efficiency. Effective platform engineering standardizes processes and workflows while optimizing tooling and ease of use. This allows teams to define repeatable patterns for successful, happy developers. The benefits of platform engineering reach every aspect of the developer experience. They help shield developers from time-consuming and error-prone tasks. Quality platforms provide highly usable and reliable tools that make dev work more effective. Platform engineering simplifies onboarding, speeds time to first commit, and keeps developers feeling supported by their tools.
- Augmenting with Artificial Intelligence (AI): AI tools can substantially improve the developer experience. When used correctly, AI can reduce developer toil. It can help write code, debug, document, test, and many other development-related tasks. The right AI tools let developers spend more time innovating and problem-solving and less time performing rote work. In the right hands, AI can help minimize workflow duration, reduce defect density, and improve code coverage. These tools provide real gains in productivity but come with the risk of reducing code quality. Developers utilizing AI tools should place an even stronger emphasis on automated testing to provide guardrails as teams use AI to boost their output.
- Automating with CI/CD: With CI/CD developers can automate the process of building, testing, and deploying their code. A smooth CI/CD pipeline is an integral part of a good developer experience and a prerequisite for software development at scale. CircleCI provides a complete CI/CD solution built with DevEx in mind. CI/CD significantly reduces a developer’s workflow duration when making code changes. Automating testing as part of the pipeline helps code coverage stay high and catches errors before they can cause serious problems.
Modern solutions such as CI/CD improve the developer experience immeasurably. Not only does the pipeline automate time- and labor-intensive processes, CI/CD tools also provide a collaborative environment that enables developers to make and track changes easily.
Conclusion
A great developer experience is one of a company’s greatest assets. Empowering developers to succeed in their roles ultimately leads to better software, better returns, and most importantly: happy, productive developers.
Investing in DevEx requires examining how developers work. With the right tools, processes, and support in place, developers can thrive in flow states and enjoy high productivity. This all culminates in job satisfaction, which pays dividends in efficiency while enhancing the company’s reputation.
Ready to improve your team’s development experience?Sign up for a free CircleCI accounttoday and see how automated testing and validation can help your developers ship faster and more confidently.