What Is DevX (DevEx)? Essentials for Improving Developer Experience and Productivity

Did you know that companies with better work environments for their developers achieved 4-5 times greater revenue growth than their competitors?

Referred to as  'Developer Experience' (DevX or DevEx), this encompasses how developers feel about, think about, and value their work — and naturally has a high impact on their productivity.

In this article, we'll explore what DevX really means, why it's helpful for your business, and how you can measure and improve it.

Sections:

‍

At its core, Developer Experience (DevX or DevEx) encompasses how developers feel about, think about, and value their work. It's the sum of all interactions a developer has with their tools, processes, and work environment. But DevX isn't just about providing fancy IDEs or the latest MacBook Pros. It's about creating an ecosystem where developers can thrive, innovate, and deliver value efficiently.

Think of DevX as the UX of software development. Just as we obsess over user experience in our products, we need to apply the same mindset to the developer's journey. A positive DevX may lead to higher productivity and happier, more engaged developers.

The framework boils down to three core dimensions:

A. Feedback Loops

Imagine trying to have a conversation where your partner responds to everything you say with a 5-minute delay. Frustrating, right? That's what poor feedback loops feel like in software development.

Feedback loops are all about the speed and quality of responses developers get to their actions. This includes everything from how quickly your code compiles to how long it takes to get a code review. Fast, high-quality feedback allows developers to work efficiently with minimal friction. It's like having a real-time conversation with your tools and teammates.

Examples of good feedback loops include:

• Near-instantaneous compile times
• Quick unit test runs
• Rapid code review turnarounds
• Real-time error highlighting in IDEs

When feedback loops are optimized, developers can iterate quickly, catch errors early, and maintain their flow state (more on that next!).

B. Flow State

You know that feeling when you're so absorbed in your work that time flies by, and you emerge hours later with a sense of deep satisfaction? That's flow state, and it's the holy grail of developer productivity.

Flow state is a mental state where developers are fully immersed, focused, and enjoying their work. It's where creativity meets productivity, and it's when developers do their best work.

For developers, achieving flow state might look like:

• Uninterrupted coding sessions
• Solving complex problems without distraction
• Rapid prototyping of new features

Frequent experiences of flow lead to higher productivity, innovation, and employee development. It's not just about getting more done – it's about enjoying the process and producing higher quality work.

Based on scientific studies, it takes at least 10-15 minutes to get back into flow after an interruption. It would be amazing if people realized the high cost of context switching for developers!

One way to get a sense of how often people are being interrupted is by getting visibility into the meeting load people are carrying and how much focus time (or, as Paul Graham calls it, "maker time") each person has. Multitudes provides a unique calendar integration to automatically surface this data.

To increase opportunities for flow state, you can try:

• Group meetings together so there are longer blocks of focus time in between
• Avoid unplanned work in a sprint (or have a rotating support person each week so that only one person is being impacted by ad hoc asks that come up)
• Set a culture of “Google-first” before asking someone, followed by consolidating requests for help into a single message (as opposed to sporadic pings for help).

Once again, the work environment also matters – creating a supportive team atmosphere that provides developers with both independence and appropriate challenges markedly increases their likelihood of attaining and maintaining flow.

C. Cognitive Load

Imagine trying to juggle while riding a unicycle on a tightrope. That's what high cognitive load feels like for developers. Cognitive load is the mental effort required for a developer to complete a task.

In software development, cognitive load comes from various sources:

• Understanding complex codebases
• Learning new technologies and frameworks
• Navigating convoluted development processes
• Dealing with poor documentation

High cognitive load is exhausting and prone to errors. It's like trying to solve a Rubik's cube while someone keeps changing the colors. Reducing cognitive load allows developers to focus on what really matters: delivering value to customers.

Strategies to reduce cognitive load include:

• Well-organized and documented code
• Intuitive development tools and processes
• Clear project requirements and goals
• Simplified architectures and systems

By minimizing cognitive load, we free up mental resources for creative problem-solving and innovation. This enables developers to concentrate more on creating value, rather than untangling complexities.

Let's look at some compelling reasons why DevX should be at the top of every tech leader's priority list:

1. Revenue growth: A 2020 McKinsey study found that companies with better developer work environments achieved 4-5 times greater revenue growth than their competitors. [1] When developers have a great experience, they can focus on creating value instead of fighting with tools or processes.
2. Innovation Catalyst: When developers spend less time on friction and more time in flow state, innovation flourishes. Great DevX creates an environment where new ideas can be rapidly prototyped and tested — with more time spent actually building software.
3. Quality Improvement: Better DevX often leads to high quality code. With reduced cognitive load and improved feedback loops, developers better concentrate in flow and fix issues earlier in the development process.
4. Faster Time-to-Market: Streamlined processes and tools mean features can be developed and shipped faster, giving your company a competitive edge in software change lead time.
5. Cost Efficiency: While investing in DevX might seem expensive upfront, it often leads to significant cost savings in the long run through increased productivity and reduced turnover.

Now that we understand the importance of DevX, the next question is: how do we measure it? Measuring DevX is crucial for identifying improvement opportunities and understanding the impact of your investments. But how do you measure something as nuanced as developer experience?

To effectively capture DevX, organizations should focus on metrics that span the three core dimensions: feedback loops, cognitive load, and flow state. These metrics can be categorized into three types: perceptions, workflows, and North Star KPIs.

1. Perceptions: These metrics capture developers' attitudes, feelings, and opinions about their work environment. They provide invaluable insights into the lived experience of developers across all dimensions of DevEx.
2. Workflows: These are objective measures of system and process behaviors. They offer concrete data on how development processes are functioning in practice.
3. KPIs: These are overarching metrics that serve as key performance indicators for your DevEx initiatives. They provide a high-level view of the overall state of developer experience in your organization.

The interrelationship between these metric types is important. Perceptions and workflows often complement each other, with workflows providing objective context for subjective perceptions. For instance, a developer's perception of slow build times can be verified against actual build time metrics.

KPIs, on the other hand, offer a bird's-eye view that can help identify discrepancies between perceptions and workflows. For example, if overall perceived productivity is high but workflow metrics show inefficiencies, it might indicate areas where developers have developed workarounds that feel productive but are actually suboptimal.

By measuring across these areas and understanding their interrelationships, you'll gain a comprehensive and nuanced view of your DevEx landscape. This holistic approach ensures that you're not only tracking objective performance but also considering the subjective experience of your developers - both of which are crucial for truly understanding and improving DevEx.

This framework provides a starting point for what to measure. Remember, the specific metrics most relevant to your organization may vary based on your unique context and goals. The key is to ensure you're capturing a balanced view across perceptions, workflows, and overall KPIs.

If you want to get a 360-degree view your DevX landscape, check out our product which tracks Developer Experience holistically. If you're interested to see this in action, join our beta today.

While the DevEx framework offers valuable insights into improving developer productivity, it is only just a framework. In practice, it requires careful consideration of your company’s unique context. Here are six key points to keep in mind:

1. Start with trust: Trust is the foundation of any successful DevEx initiative. Without it, metrics become meaningless or even harmful. In low-trust environments, survey data may be unreliable as people are incentivized by fear to lie, rather than seeking improvement.  For tips on how to build trust, start with our guide here.
2. Use surveys and metrics complementarily: The DevEx framework recommends using both surveys and system metrics. When implementing surveys, consider their frequency and design carefully. While system metrics provide real-time data, surveys are typically conducted less frequently, which may delay the identification of certain issues. Thoughtful survey design is needed to ensure reliable data collection and to capture team-specific insights. Will Larson (who's led engineer at companies including Carta, Calm, Stripe, and more) shared his template for running a developer experience survey here.
3. Prioritize data ethics: It's also important to developing strategies for ethical and contextual use of survey and metric data. If a company is stack-ranking developers based on Lines of Code, then even the best survey won't be enough to mitigate the risk of poor decisions made from stack-ranking of people. Read more about how we do this at Multitudes with our data ethics principles.
4. Link DevEx to business outcomes: A successful DevEx strategy aligns developer well-being with business success. This approach not only keeps everyone focused but also helps build a strong case for DevEx investments. We reccomend linking DevEx goals back to OKRs where possible to connect developer productivity metrics back broader business outcomes.
5. Consider external feedback loops: External factors like customer feedback, market trends, and technological advancements significantly impact developer experience and productivity. The biggest driver we’ve seen is leveraging automation to minimize repetitive tasks and enabling programmers to concentrate on more innovative and significant projects. Multitudes, for example, streamlines data collection and metrics calculations, so you can focus on taking action on the insights.
6. Act on insights: The true value of metrics lies in the actions they inspire. After building trust and gathering insights, what matters most is what people do with the insights – does it support continuous improvement in teams? Are people getting the right information to support their next retro, stand-up, or 1:1? That’s why we’ve built Multitudes to integrate with Slack to share timely nudges based on changes to metrics.

By keeping these considerations in mind, organizations can more effectively leverage the DevEx framework to improve developer productivity while tailoring the approach to their unique context and needs. Remember, implementing DevEx is a journey of continuous improvement, and it's okay to start small and iterate as you learn what works best for your organization.

To effectively measure Developer Experience, teams can use Multitudes, which is an engineering insights platform for sustainable delivery. Multitudes integrates with your existing development tools, such as GitHub and Jira, to provide insights into your team's productivity and collaboration patterns.

With Multitudes, you can:

• Automatically track DevEx metrics across Feedback Loops, Cognitive Load, and Flow
• Get visibility into work patterns and where the team’s time went, e.g. into feature development vs. bug fixing
• Identify collaboration patterns and potential silos within your team
• Understand individual and team well-being through metrics like out-of-hours work, incidents, and meetings
• Get nudges via Slack about blocked work and who might need more support, sent just in time for your next stand-up, retro, or 1:1

Multitudes surfaces insights on wellbeing and productivity, freeing up teams to spend more time taking action.

Ready to unlock happier, higher-performing teams?

Try our product today!