Developer experience (DevEx) refers to the overall experience software developers have while interacting with tools, platforms, frameworks, and processes to build, test, deploy, and maintain software applications. It includes all aspects contributing to how efficiently and effectively developers can perform their tasks.
A DevEx Team is a group of developers and DevOps experts responsible for analyzing, prioritizing, and implementing improvements that better enable software developers. This article comprehensively covers all aspects of DevEx and provides practical guidance on where to focus your improvements and justify your investment in DevEx.
Background
Our definition builds upon teachings from the User Experience (UX) profession, which traditionally used UX teams used surveys, questionnaires, and focus groups. These time-tested techniques are great for evaluating perception but fail to provide quantitative proof of how to best improve user experience. Modern UX teams rely heavily on automatic data collection to understand how their users engage with products in real time and to measure the success of new features. Similarly, our definition reflects the reality of modern software engineering teams who need to quantify both the perception and the reality their developer teams face.
The Importance of Developer Experience
Simply put, developer experience is a key indicator of engineering productivity. Researchers from MIT and Oxford found that happier employees perceive they are more productive. Naturally, a happy developer is more likely to feel productive at work, and there is a bidirectional relationship between satisfaction and developer productivity. Additionally, research from Google, National Instruments, and Bloomberg found the top predictor of productivity is whether the person is enthusiastic about their job.
To fully understand the importance of DevEx, we need to take a look at the major sources of friction. Researchers from the University of Helsinki and the University of Stuttgart identified ten factors that contribute to poor developer experience:
- Being stuck while solving a problem
- Time pressure to complete tasks
- Poor code quality and coding practices
- Under-performing teammates
- A feeling of inadequacy with one’s work
- Mundane or repetitive tasks
- Unexplained or broken code
- Poor organizational decision-making
- Imposed development limitations
- Personal issues unrelated to work
The vast majority of these sources of unhappiness are partially or entirely outside the control of the typical developer. This lack of control is why having a person or team responsible for improving DevEx is critical.
One last consideration: unhappy developers are also more likely to search for a new job. Atlassian’s 2024 State of Developer Experience Report surveyed more than 2,000 developers and found that 63% of developers consider developer experience to be important or very important when deciding whether to stay in their current jobs. So, investing in DevEx is critical to retaining employees.
Developer Experience Roles and Responsibilities
The most common place for a developer experience function to live is within platform engineering because this team is typically responsible for improving internal tooling and processes for developers. However, your organization might not have a platform engineering function. In this case, the function can live in various locations, such as teams that manage internal systems, DevOps, digital services, or a dedicated developer productivity team. Wherever it exists, your DevEx team should have technical and soft skills to effectively enhance and optimize developers' interactions with the tools, processes, and environment your organization provides.
Here are some common technical skills for DevEx teams:
- Programming architecture proficiency: They should deeply understand software development methodologies and best practices.
- Tooling and Automation: They should be capable of managing your CI/CD pipelines, revision control systems, and deployment tools.
- API design: They should be familiar with API standards like REST and GraphQL because management of internal APIs often falls under DevEx.
- Monitoring and analytics: They should be familiar with logging tools and be able to analyze performance metrics and developer productivity.
Additionally, DevEx experts should have the following soft skills:
- Communication: Verbal and written skills to create clear and concise documentation and guides.
- Collaboration: Strong interpersonal skills and the ability to work cross-functionally to gather feedback and improve processes.
- Problem-solving: Analytical thinking skills to identify inefficiencies in developer workflows and a creative approach to identifying solutions.
- Empathy: Understand developer needs and challenges and be committed to improving developer experience.
- Project management: Ability to balance multiple projects and priorities to deliver software on time.
Here are some additional skills that beneficial to DevEx teams, but are less critical to overall success:
- UX design: Knowledge of how to create developer-friendly interfaces.
- Advocacy: Able to advocate for developer needs within the organization and promote best practices and continuous improvement.
- Education and Training: Ability to create and deliver training sessions, workshops, and webinars. Willingness to support and mentor other developers.
The Tools that Most Frequently Impact Developer Experience
Tools that developers use daily significantly impact their workflow and overall effectiveness. This includes integrated development environments (IDEs), version control systems, CI/CD pipelines, and collaboration platforms. In this section, we will delve into some of the most impactful tools that shape the developer experience, exploring how each tool enhances productivity, streamlines processes, and fosters a collaborative environment. By understanding and optimizing these tools, your DevEx team can create an environment where developers thrive, leading to better code quality, faster delivery times, and higher team morale
Integrated Development Environments
Examples: Visual Studio, IntelliJ, Eclipse, PyCharm
IDEs and code editors significantly enhance developer productivity by providing tools for writing, debugging, and navigating code efficiently. They offer features like intelligent code completion, syntax highlighting, and integrated version control, which streamline the development process and reduce errors. Your DevEx team can improve IDE and code editor usage by providing training sessions on advanced features and customizing settings to fit the team's workflow. Additionally, they can ensure that developers have access to the latest tools and plugins that enhance productivity and code quality.
Version Control Systems
Examples: Git, GitHub, GitLab, BitBucket
Version control systems are essential for managing code changes, enabling collaboration among developers, and maintaining a history of code versions. They allow multiple developers to work on different features simultaneously without conflicts. To optimize version control systems, your DevEx team can establish best practices for branching and merging strategies, conduct regular code reviews, and implement automated workflows. Providing clear guidelines and training on the effective use of version control can also enhance collaboration and reduce conflicts.
CI/CD Tooling
Examples: Jenkins, CircleCI, Travis CI, GitHub Actions
CI/CD tools automate the process of building, testing, and deploying code, ensuring developers can integrate and deliver changes quickly and reliably. This automation reduces manual effort, catches bugs early, and accelerates the release cycle, improving overall code quality and delivery speed. Automating build, test, and deployment processes can improve CI/CD to ensure fast and reliable feedback. Your DevEx team should regularly review and refine the CI/CD pipeline to remove bottlenecks, update dependencies, and incorporate best practices.
Collaboration Tools
Examples: Slack, Microsoft Teams, Confluence, Jira
Effective collaboration and communication tools enable efficient collaboration and alignment on project goals. When integrated with development workflows, they allow for seamless updates, code reviews, and documentation sharing. Enhancing collaboration and communication involves selecting the right tools that integrate well with development workflows and organizing regular team meetings for knowledge sharing. Encouraging shared documentation platforms and maintaining transparent communication channels can also improve team collaboration.
Containerization and Orchestration
Examples: Docker, Kubernetes
Containerization tools like Docker and orchestration platforms like Kubernetes provide a consistent environment for developing, testing, and deploying applications. They simplify dependency management, enhance scalability, and ensure applications run consistently across different environments. Your DevEx team can improve containerization and orchestration by providing training on Docker and Kubernetes, standardizing container images, and implementing best practices for resource management. Regularly reviewing and optimizing the deployment processes ensures applications run efficiently and reliably.
Code Quality and Analysis
Examples: SonarQube, Orca Security, ESLint
Code quality and analysis tools automatically review and enforce coding standards, detect potential bugs, and provide insights into code maintainability. These tools help developers write cleaner, more reliable code and maintain high standards throughout the development lifecycle. To enhance code quality and analysis, your DevEx team should integrate automated code review tools into the development pipeline and enforce coding standards. They can also organize code quality workshops and ensure regular feedback loops for continuous improvement.
Testing Frameworks
Examples: JUnit, pytest, Selenium, Jest
Testing frameworks provide structured methods for writing and running tests, ensuring code functions as expected. DevEx teams facilitate automated and consistent testing practices, helping identify bugs early, improve code quality, and maintain reliability. Improving testing practices involves promoting comprehensive testing frameworks and ensuring that tests are automated and integrated into the CI/CD pipeline. Your DevEx team can foster a culture of test-driven development and conduct regular testing workshops.
Package Managers
Examples: npm, pip, Maven, Yarn
Package managers simplify installing, updating, and managing dependencies, making sharing and reusing code easier. They enhance the development workflow by automating dependency resolution and ensuring compatibility across different projects. Your DevEx team can streamline package management by standardizing package managers across projects and ensuring dependencies are well-documented and up-to-date. Implementing automated dependency updates and security checks can further enhance reliability.
Monitoring and Logging
Examples: Prometheus, Grafana, ELK Stack, Datadog
Monitoring and logging tools provide real-time insights into application performance and behavior, helping developers detect and resolve issues quickly. They enable proactive performance management, improve reliability, and provide valuable data for troubleshooting and optimization. Enhancing monitoring and logging involves setting up comprehensive monitoring tools and dashboards to track application performance and health. DevEx teams should also ensure logs are structured and accessible and configure alerts and notifications to address issues promptly.
How to Improve Developer Experience
The most critical component of launching a successful DevEx initiative is getting buy-in at all levels of your organization. Your executive team needs to justify investments in DevEx and see the positive impact those investments have on delivering value to customers. DevEx leaders need visibility into developer friction and the ability to implement improvements. Developers want their voices to be heard and have autonomy to improve their experience.
The process of getting buy-in can be boiled down to three steps:
- Justify DevEx Investments
- Identify and Address Developer Friction
- Empower Developers
Let’s take a look at each of these.
Justify DevEx Investments
Benchmark Your Investment Profile
Productive companies invest in DevEx. If you overinvest in new features and underinvest in the critical infrastructure needed to keep the lights on, you’ll respond more and more to unexpected situations. Excess time spent on bugs, tech debt, and unplanned work indicates poor DevEx, directly impacting productivity.
LinearB's engineering benchmarks report, which includes data from over 2,000 organizations and 3.6 million PRs, found that the average organization invests 15% of its time into DevEx. This category includes improvements to developer productivity and overall work experience, such as enhancing tooling and platforms, adding test automation, restructuring code to reduce technical debt, and reducing backlog.
Knowing where your engineering organization invests time allows you to make data-backed decisions. New projects typically focus on new value and DevEx, while mature projects invest more in feature enhancements and keeping the lights on. Understanding your investment profile is crucial for tracking and improving DevEx, regardless of stage.
Measure Your Planning / Capacity Accuracy
High-performing organizations are predictable. Two primary metrics measure your engineering organization’s predictability: planning accuracy and capacity accuracy.
- Planning accuracy measures the ratio of planned work vs. what was delivered. This metric tells you how well your teams prioritize and execute against planned work.
- Capacity accuracy measures the total completed work divided by planned work. This metric tells you if your team takes on an appropriate amount of work.
Collectively, these represent if business expectations match developer capabilities. An imbalance of either can make developers feel they’re subject to unrealistic goals. You should aim to have a planning accuracy above 85% and a capacity accuracy between 85%-115%.
Identify and Address Developer Friction
Monitor Team Quality and Efficiency Metrics
Most of a typical developer's day occurs inside the software cycle: creating, reviewing, merging, and deploying code. Inefficiencies impact developers individually, but the bottlenecks that make them often exist at the team level.
Problems such as high coding time, high pickup time, high review time, and high deployment time can indicate issues like poor scoping, communication gaps, uncertainty in the merge process, and poor post-merge experience. These issues severely impact DevEx but are outside their control, leaving developers powerless to fix anything.
You should aim for a cycle time between 2 and 4 working days because anything longer risks spreading work activity across multiple weeks. The longer the delay between writing and releasing software, the bigger the context switch for developers managing numerous ongoing tasks.
You should also monitor your Change Failure Rate (CFR) and Mean Time to Restore (MTTR) because a high rate of production failures may indicate software complexity or quality issues that negatively impact DevEx.
Establish Working Agreements
Working agreements put teams in control of defining how they want to work together by establishing guidelines, rules, and behaviors the team has agreed upon. Sometimes, individual expectations don’t match team expectations, and a mismatch can result in a poor DevEx. Working agreements provide a shared sense of responsibility, making identifying and discussing positive and negative behavior easier. Working agreements empower team members to hold each other accountable for collaborating and providing support.
Managers should work with their teams to establish working agreements that improve efficiency, enable all developers to participate, and provide a framework for uncovering problems that need broader support. Here are some examples of focus areas your working agreement might include:
- Pickup / Review Time: Research shows that code reviews are the most consistent bottleneck for software delivery pipelines. Hence, it’s crucial to recognize the value of developers who unblock code reviews and reallocate support to those who need it.
- PR Size: Small PRs are a leading indicator of software delivery efficiency. Large PRs could indicate a developer is working with complex parts of the codebase or needs tasks to be better scoped.
- Review Depth: Code reviews improve your codebase and facilitate knowledge sharing and mentorship. Shallow reviews introduce quality risks and minimize knowledge transfer gains that help build more sustainable practices.
Empower Developers
DevEx initiatives are more likely to succeed with bottom-up buy-in, and individual empowerment is how you get this buy-in. Developers want autonomy, but that doesn’t mean they want complete freedom because they often prefer clear guidelines about optimal pathways. The key to a successful DevEx initiative is to make the path of least resistance the most likely to result in success.
If you’re struggling to understand the biggest blockers to developer empowerment, one option is to run a one-time survey to gauge the perception of your developer teams and compare that to objective, quantifiable metrics.
Build a Culture of Continuous DevEx Improvement
Creating a positive developer experience is an ongoing process. It requires continuous feedback, regular assessments, and a commitment to improvement. Establish a culture where feedback is encouraged and developers feel safe to voice their concerns and suggestions.
By investing in DevEx, organizations can ensure their developers are productive, satisfied, and motivated, leading to higher-quality software and better business outcomes.
