The impact of developer experience on software development

A good developer experience improves the software development process. In fact, the quality of your DevEx can have an outsized impact on how well the process works at your company.

Here’s a summary of how developer experience impacts software development and how to use this knowledge to improve your engineering organization’s work.

What is developer experience?

Developer experience is the lived experience of developers in their everyday work and the relative ease or friction they experience.

Developer experience, or DevEx, refers to the various technologies, processes, and techniques developers use while working. DevEx includes platform tooling, CI/CD, infrastructure, documentation, error messages, testing libraries, project management tools, onboarding processes, and on-call procedures.

Unrealistic deadlines, complicated tooling, and frequent interruptions detract from the developer experience. In contrast, precise requirements and deadlines, intuitive tooling, and ample time for deep work often contribute to a positive developer experience.

Developer experience can be broken down into three dimensions:

• Flow state: Immersing developers entirely in their core work without interruption.
• Feedback loops: The time it takes to receive and process feedback.
• Cognitive load: The mental processing required to perform a task.

How developer experience impacts the software development process

Most companies follow a six-stage software development lifecycle (SDLC) when bringing their products from ideation to production.

These six stages are:

• Requirements
• Design
• Implementation
• Testing
• Deployment
• Maintenance

How does developer experience impact each of these areas?

Requirements

The requirements stage crisply defines end-user requests for new product features and how these features should operate. Getting solid on requirements before design and implementation — and managing changes through a defined process — provides a stable environment for developers.

Last-minute changes result in emotional distress for devs that impact their overall job satisfaction, according to the study “The Emotional Roller Coaster of Responding to Requirements Changes in Software Engineering” by Kashumi Madampe, Rashina Hoda, and John Grundy.

Developers say they work better when:

• What they’re working on is clearly defined, and
• Large, nebulous tasks are broken down into smaller, concrete tasks.

Quickly changing requirements creates developer dissatisfaction, as developers feel the work they’ve already done has to be discarded. On the positive side, developers say they feel encouraged when they can see that the work they’re doing has clear value to the business.

Design

Design review is an early stage in the software development process where stakeholders can provide design feedback, identify potential problems, and avoid costly mistakes in the subsequent steps of development.The approval of designs plays a crucial role in the satisfaction level of a development team. Complex designs can lead to a higher cognitive load and reduced developer satisfaction.

The MIT study “System Design and the Cost of Architectural Complexity” found that systems with greater architectural complexity can lead to higher developer stress and reduced productivity. Such complex architectures can also reduce developer productivity by 50% and increase staff turnover.

Implementation

In software development, implementation is the phase where developers write the source code that brings the software design to life, creating a software product that meets all the original requirements. Implementation is a crucial step in the software development life cycle as it directly impacts the quality, performance, and reliability of the software.

One key factor in implementation is the flow state. Today’s development environments often use dozens of languages and leverage multiple cloud providers. That creates pressure, cognitive complexity, and distractions, making implementation challenging without deep focus time.

We discovered that enabling the flow state of developers resulted in a 50% increase in their productivity. Additionally, we learned that developers who find their work engaging are 30% more productive. Fast code review turnarounds contributed to a 20% increase in innovation among developers. Furthermore, providing quick responses to technical queries reduced technical debt by 50% – meaning that by improving this key aspect of developer experience, software implementation becomes a faster, more productive process.

We have discovered that when developers enter the flow state, their productivity increases by 50%. Moreover, we have learned that when developers find their work engaging, their productivity increases by 30%. Fast code review turnarounds contribute to a 20% increase in innovation among developers. Additionally, providing quick responses to technical queries reduces technical debt by 50%. This means that improving this key aspect of developer experience makes the software implementation process faster and more productive.

We’ve found that developers hit a major productivity boost — up to 50% — when they’re in a flow state. Similarly, when they find their work truly engaging, there’s a 30% increase in their productivity. Quick turnarounds on code reviews also lead to a 20% spike in innovation. Moreover, it cuts technical debt in half when technical questions are answered swiftly. This shows that enhancing these critical elements of the developer experience can significantly speed up and improve the software development process.

Testing

Developer experience is enhanced by using a strong test suite and developing a smooth testing process. Testing implemented software can include:

• Unit tests that test paths in isolation using mock data, with a focus on testing happy paths, edge cases, and unexpected inputs
• Integration tests that verify the connectivity between systems
• Acceptance tests that test the system end-to-end from a functional user perspective

Testing promotes greater system stability, resulting in fewer flow breaks and emergencies. Deployments become easier because fewer failures require all hands on deck. This leads to fewer distractions, improving flow.

Deployment

Deployment is the process of releasing the final version of an application or software to the production environment and making it available for end-users. It signifies the transition from the development stage to the actual usage in real-world scenarios. Although deployment can occur in different environments, such as testing or staging, its primary objective is to make the software operational for its intended audience.

Today, when software engineers update their code, they often use continuous deployment. This advanced release process builds on two other processes called continuous integration and continuous delivery (CI/CD).

With continuous deployment, all code updates are automatically tested. If the tests pass, the updates are deployed to the public without human intervention. This allows software engineers to focus on building software and see their updates go live within minutes or hours, assuming the tests pass.

Developers are 50% more innovative when their tooling is easy and intuitive, as more intuitive continuous deployment tools reduce the overall cognitive load. This suggests that simplifying the deployment process streamlines workflow and enhances creativity and innovation by allowing developers to focus more on creative problem-solving and less on navigating complex tooling.

Overly complex continuous deployment tooling can result in the following:

• Deployments that fail because of manual steps that lead to mistakes and differences in configuration between environments can cause issues
• Errors as a result of poorly documented command line tooling

In contrast, simple, easy-to-use tooling has benefits like fewer errors during deployment, increased project velocity, enhanced collaboration, and reduced costs.

Maintenance

Maintenance in software development refers to managing the software after it’s been deployed so that it continues to work effectively. During this phase, the software is updated to meet the changing needs of users, comply with new regulations, and keep up with the latest technology.

The stability of the software’s release systems is a critical aspect of maintenance. A stable release system is crucial for a smooth and uninterrupted development process, as instability can disrupt workflows, necessitating immediate, resource-intensive fixes.

Moreover, as software projects expand, they often become more complex and harder to manage, leading to the accumulation of technical debt. This term refers to the extra work that arises when developers opt for quick, easy solutions over the best long-term approaches. Technical debt can significantly drain resources—up to 30% in some cases—impacting developer morale, retention, and the productivity of the team as a whole.

Ensuring a positive developer experience is pivotal for effective maintenance. When developers have access to tools, practices, and an environment that encourages efficient and stress-free coding, the likelihood of generating technical debt decreases. This leads to more stable release systems, fewer disruptions, and a more maintainable codebase.

A supportive developer environment not only enhances productivity but also ensures that software can be easily updated and maintained, aligning with user needs and technological changes over time.

How to improve the software development process

Improving the software development process not only boosts the quality and speed of software production but also increases the satisfaction and happiness of developers.

There are many opportunities across the SDLC to incorporate developer experience improvements. We recommend the following steps, adapted from our paper DevEx in Action, for identifying areas of improvement, getting buy-in, and implementing and reporting on how changes have affected the software development process.

Collect data on your current state

Conduct a survey, manually or through a tool like DX, with questions structured around the software development process.

For example, request feedback on overall engagement and satisfaction across each stage of the software development process to help determine where to advocate for changes first. Or, conduct a more general survey and then narrow your focus to a particular area based on your findings (e.g., internal tooling).

Set goals based on your data

Where does your information on developer experience intersect with your current business priorities or other engineering KPIs?

For example, miscommunications during the requirements phase might lead to widespread dissatisfaction among the development team. Additionally, throughput and velocity are goals commonly mentioned throughout your organization.

Using the data and insights you’ve gathered, you can launch an initiative to improve the requirements phase. This initiative can focus on better communication among the development team and setting clearer software development KPIs for how the requirements align with the business objectives. The expected outcome of this initiative would be increased developer satisfaction and reduced time spent addressing business issues during the design and implementation stages.

Implement accountability mechanisms within your team and organization

Set goals at the team level and shared goals with dependent teams. These will help you stay on track and accountable for implementing and measuring changes. Focus on delivering outcomes over outputs.

Share progress and ROI

Continually share the progress of DevEx initiatives. Use qualitative feedback and quantitative metrics to show changes in developer satisfaction and engagement alongside quantitative metrics.

It is important to keep track of quantitative and qualitative metrics to demonstrate their positive correlation. This way, you can show how improving your developer experience can unblock critical areas of your software development process.