Request access

Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.

The definitive guide for engineering teams to improve their Developer Experience (DevEx)

José Velez
José Velez
Founder & CEO
José Velez
September 21, 2023
 min read
The definitive guide for engineering teams to improve their Developer Experience (DevEx)

Over the last few months, as many businesses have struggled with challenging financial landscapes and slowing growth rates, it's evident that companies executing with speed and efficiency are the ones positioned for success. 

One of the most important components of this efficiency is the developer experience (DevEx). Beyond simply increasing developer satisfaction and reducing turnover, an exceptional DevEx is a driving force behind heightened engineering velocity and efficiency. 

In this article we’ll explore why DevEx matters to your organization, how to define and measure it, the role of internal developer portals and reliability engineering practices, and give you practical recommendations for you to improve it at your organization.

Why engineering leaders need to focus on improving developer experience in today’s landscape

Ever wondered how Silicon Valley tech giants release daily updates while some companies are stuck with monthly releases?

Many factors play into this, but there’s one major reason: top companies know that delivering value swiftly and efficiently gives them a competitive edge.

To match this pace, you need two things: the best talent in your team and the right environment for them to excel. However, many organizations offer a less-than-ideal developer experience (DevEx), pushing away potential hires and even current top performers. Remember, your top engineers aren't just assets; they're the driving force behind your innovations.

Engineering teams are struggling with cognitive overload, which significantly undermines their experience and productivity. The rapid rise of cloud-native tools and distributed architectures, alongside practices like the 'shift-left' and 'you build it, you run it' trend, is surely empowering but also burdening engineers, affecting their efficiency and overall job satisfaction.

Forward-thinking engineering leaders are taking note of this, and prioritizing the enhancement of developer experience. By streamlining the software delivery process, they not only empower engineers to innovate but also foster a smoother flow throughout the software development cycle.

A top-notch developer experience can set a company apart from the rest. It's crucial for leaders to make sure developers face fewer interruption so that they can work in a "flow" state, that their cognitive load is reduced so they can be more productive and to automate manual, repetitive tasks so that they can have more mental capacity for creative work, something humans are uniquely positioned to do (for now ^^).

In a nutshell, why are engineering leaders making DevEx a top priority?

  • Talent Attraction & Retention: Highly talented people are usually attracted to workplaces where they can thrive, thus they always look for places with a great DevEx. t’s usually a poor DevEx that is driving away your best people, or best opportunities to hire great people. And your best people represent your competitive edge.
  • Rapid Onboarding:  Building and retaining a high-performance development team starts with a positive onboarding experience, ensuring newcomers contribute value sooner. Developers are highly motivated and driven to make a difference when they join a new organization. Streamlined DevEx accelerates the onboarding process, for example, by unifying all the relevant resources they need to build, deploy and operate the services they will own, or by creating a simple but comprehensive developer environment workspace.
  • Increased Flow & Enhanced Productivity: Fewer distractions, a unified toolset, reduced cognitive load and less task-switching result in an optimized DevEx, propelling developers into a state of deep concentration and enhanced output.
  • Reduced Time-to-Market and enhanced product quality & reliability: By empowering your engineers with the autonomy to excel, while implementing necessary guardrails and automation, you can streamline workflows, minimize human error, and significantly enhance the delivery pace, quality, and reliability of your product.
  • Employee Well-being:  An enriching DevEx correlates with heightened mental well-being and job satisfaction, fostering a motivated developer community.

How do you define and measure developer experience?

In light of the compelling reasons mentioned above, engineering leaders are assigning DevEx a high priority. But what truly constitutes a good developer experience, and how can we tangibly measure it?

How to define Developer Experience (DevEx)

DevEx is a very broad term and can mean slightly different things to different people. It can refer to the well-being of developers, the strength of company culture, the quality of documentation and processes, and the tools available for tasks. It also emphasizes a culture where developers are encouraged to innovate and take risks, all while having the necessary time and space without unnecessary distractions.

The Gartner® report “Software Engineering Leader’s Guide to Improving Developer Experience” succinctly describes that “Developer experience refers to all aspects of interactions between developers and the tools, platforms, processes, and people they work with, to develop and deliver software products and services.”

A common misconception is that DevEx is primarily affected by tools. The latest consensus, however, shows that human factors such as having clear goals for projects and feeling psychologically safe on a team have a substantial impact on developers' performance. Improving DevEx increases not only productivity, but also satisfaction, engagement, and employee retention.

The Three Core Pillars of DevEx

Rooted in Gartner's insights and data from the research paper titled “DevEx: What Actually Drives Productivity: The developer-centric approach to measuring and improving productivity”, DevEx is structured around three main pillars:

Feedback Loops

Feedback loops in software development refer to the speed and quality of responses to actions performed. Shortening feedback loops is crucial for improving Developer Experience (DevEx). Developers often face delays in receiving feedback, whether from tools or people, which hampers their productivity. Fast feedback loops enable developers to complete their work efficiently, while slow feedback loops disrupt the development process and cause frustration and delays. To enhance DevEx, organizations should identify areas where development tools can be accelerated and improve hand-off processes to minimize delays.

Cognitive Load

Cognitive load represents the mental effort required by developers to perform tasks. As software development becomes more complex, managing cognitive load becomes crucial. High cognitive load, caused by challenges like poor documentation or unfamiliar development frameworks, leads to errors and hinders developers' ability to deliver value to customers. To improve DevEx, teams and organizations should aim to reduce cognitive load by creating well-organized code, improving documentation, and providing intuitive, self-service tools.

Flow State

Flow state refers to the state of being fully immersed and focused on a task, leading to higher productivity and innovation. Developers who experience flow state regularly perform better and produce higher-quality products. Interruptions, delays, and lack of autonomy hinder developers' ability to enter the flow state. To enhance DevEx, organizations should minimize disruptions, provide developers with autonomy, and offer stimulating and challenging tasks. Creating positive team cultures that support flow state is also essential for improving DevEx.

How to measure DevEx

These three dimensions of DevEx offer a practical framework for identifying potential areas of improvement.

Companies looking to enhance DevEx need to figure out what to measure and how. Understanding DevEx is essential to spot areas for growth, see trends, and gauge the return on investments.

The essence of measuring DevEx lies in understanding developers' experiences when they work on software. This involves looking at how well the technical systems perform and getting feedback from developers about these systems. It's also key to consider team dynamics and workplace culture.

DevEx isn't just one dimension — it's multi-faceted. Understanding its different aspects helps organizations get a complete picture of how teams function, leading to better decisions. 

Based on the research framework above, the recommendation is for you to measure developer experience from multiple angles: using KPIs (key performance indicators) or "North Star metrics" that capture the bigger picture and by capturing developers' perceptions and workflows across  the three previously mentioned dimensions.The table below has specific examples of metrics that can be used for that purpose:

In order to measure these indicators, you should collect data from both people and systems in order to gain full visibility into their software delivery processes.
Surveys play a key role in measuring DevEx and identifying challenges developers face during software delivery. To augment surveys, it's vital for organizations to gather data directly from their systems. However, obtaining comprehensive system data can be challenging due to the need of standardized instrumentation throughout the different teams, services and tools.

Later in this article, we will explain how adopting some tools, such as Rely’s internal developer portal, and some reliability engineering practices not only make it possible for you to more efficiently measure the developer experience, but also to improve it.

What are the common symptoms of a poor developer experience?

Naturally, you shouldn’t wait until you get all these indicators in place to actually start improving developer experience. The best organizations take an iterative and agile approach.

Therefore, before we get into the topic of understanding how to improve developer experience, it’s important to first be able to understand where you need to improve, by recognising some of the common symptoms of a poor developer experience so that you can find “quick wins”.

As leaders, spotting these early warning signs is essential. These hints can suggest underlying problems which, if ignored, might result in dissatisfied developers, reduced efficiency, and a potential setback for your product's success.

Here's what to watch out for:

1. Tool Overwhelm & Clunky UX

Every developer has an arsenal of tools. But when these tools function in silos, the ripple effect on productivity is significant.  Even the best engineers can be overwhelmed by an ever-growing array of dev tools, especially when they don't integrate well with each other. Tool sprawl is more than just an inconvenience; it's a major roadblock to productivity. Jumping between different interfaces disrupts focus, and if these tools have a poor user experience, developers waste valuable time navigating them instead of coding.

2. Lack of Self-service Workflows

When developers have to wait on other departments or individuals for resources or permissions, they can't operate at full efficiency. This isn't just about speed; it's about the momentum of creativity and problem-solving. Delays in accessing the necessary tools or resources disrupt the workflow, leading to frustration and sometimes even to starting tasks from scratch.

3. Slow Feedback Loops

Feedback is the compass by which developers navigate adjustments and how they learn and get better at what they do. It tells a developer if they're on the right track or if changes are needed. Delayed feedback (i.e. waiting for the QA team to test the changes, or not having automated quality assessment after a release to production) means that developers will likely need to switch to other tasks before being able to finish the current ones. Being subjected to this context switching significantly hinders productivity and creativity.
This inefficient back-and-forth can demotivate developers and lead to suboptimal product outcomes.

4. The Hunt for Documentation

Develop rely on clear and concise documentation to understand how different services operate and interact with each other. Absence or ambiguity in documentation leads to guesswork. This not only increases the potential for errors but also wastes time as developers search for or request the information they need.

Another important point to consider is the domino effect. When one engineer seeks information, it can disrupt the workflow of multiple others as they try to find answers. This “domino effect" also impacts stakeholders like Product, who need to interact with technical specifications and architecture, even though they are not the owners. As a result, they often have to reach out to the technical expert for additional clarification.

5. Rising Burnout and Turnover

Burnout is a real concern in tech industries. It's not just about long hours; it's about feeling unsupported, undervalued, or stuck in inefficient processes. Chronic stress and a poor developer experience can push top talents away from the organization, leading to lost knowledge and increased recruitment and training costs.

6. Fragmented Team Collaboration

Collaboration shouldn't be hard. Think about the hours wasted just trying to get a status update, waiting for a pull request review, or figuring out who's responsible for a specific service during an incident. When teams lack clear communication and transparency, it slows everyone down. More meetings pop up, pulling developers away from their work, and frustration builds up. It's not just about wasted time; it's about lost focus and lower morale.

7. Product Issues and Delays

When a product suffers from frequent bugs, delays, or shifts in launch dates, it often hints at deeper issues within the development process. These issues can stem from any combination of the above symptoms, from lack of clear documentation to inefficient collaboration. Such delays and quality drops can lead to customer dissatisfaction and harm the reputation of the organization.

Awareness is the first step; action should follow. Keep these signs in mind to ensure you address them quickly and you're on the path to a stronger developer experience, and ultimately, better products.

The role of internal developer portals and platform engineering in providing a good developer experience

Over the last few years, it has become increasingly (and painfully) clear that cognitive overload on developers is one of the root evils creating a poor developer experience. The explosion of cloud native tooling and infrastructure, combined with the shift left and “you build it, you run it” trend, can be overwhelming to engineers and decrease both their productivity and overall quality of experience.

Platform engineering to the rescue

To navigate these complexities, many engineering orgs have started implementing automation, unification, and guardrails over their cloud-native environments. These internal “Dev Tools” are then provided to the engineering teams in the shape of a product, or platform. These trends have been inspired by industry leaders like Google, Airbnb, and Spotify and they come under the banner of "platform engineering".

This is why, more and more, we see platform engineering teams taking on the role of enhancing the developer experience for various product teams. These teams create essential tools to create a streamlined, self-service internal development platform. By treating this platform as a product, they aim to consistently refine the developer experience, using ongoing feedback from developers to guide improvements. 

Gartner's 2023 Agile and DevOps HypeCycle offers insights that resonate with this shift:

  • "Platform engineering has climbed rapidly to the Hype Cycle's peak. Emerging innovations, like internal developer portals, are making notable entries.”
  • "Few organizations showcase a high level of Agile and DevOps maturity. The mandate for software engineering leaders is dual-fold: nurture advanced teams while also guiding or restarting others on their journey."

Furthermore, Gartner TalentNeuron data highlights a surge in demand for skills enhancing developer experience via platform engineering. From mid-2020 through mid-2022, job postings citing such skills have spiked.

An internal developer platform is the primary product of a platform team. 

As defined by the internal developer platform org, “an Internal Developer Platform is built by a platform team to build golden paths and enable developer self-service. It consists of many different techs and tools, glued together in a way that lowers cognitive load on developers without abstracting away context and underlying technologies”

The true value of a platform lies not only in its implementation but also in its adoption rate among engineering teams and the tangible impact it has on their workflow and product development.

Internal developer portals act as the gateway for developers to discover and leverage the capabilities of the internal developer platform. It is through these portals that developers can easily access and explore the vast array of tools and resources, making the internal developer portal the backbone of platform engineering.

Internal Developer Portals: The solution to complexity

How can software engineering leaders minimize friction and maximize flow in the design, development, and delivery of software? The answer lies in internal developer portals. These portals offer a versatile framework that abstracts away complexity in various workflows, such as design, development, deployment, and post-deployment operations.

As explained by Paul Delory, a Research VP with Gartner, “IDPs provide a curated set of tools, capabilities and processes. They are selected by subject matter experts and packaged for easy consumption by development teams. The goal is a frictionless, self-service developer experience that offers the right capabilities to enable developers and others to produce valuable software with as little overhead as possible. The platform should increase developer productivity, along with reducing the cognitive load. The platform should include everything development teams need and present it in whatever manner fits best with the team’s preferred workflow.”

Developer portals play a crucial role in enhancing the developer experience. They create a centralized "app store" that promotes software reuse, enhances onboarding, streamlines delivery, and facilitates knowledge sharing. By integrating with documentation, source code, and artifact repositories, organizations can adopt and scale innersource practices. Moreover, the portals integrate with automation, monitoring, and incident management tools, enabling continuous operations.

It's important to note that developer portals go beyond providing a superficial overview. As eloquently described in this article from the Platform Engineering Org, "putting a pile of bullsh*t on a pane of glass won't solve any problems." To begin with, it is essential to curate and present only the relevant information for the specific use case. Furthermore, taking action is of utmost importance. Therefore, the steps for improvement should not only be easily accessible and comprehensible but also ideally automated, enabling standardization and enhancing the workflow for developers.

Internal developer portals should empower developers to perform activities throughout all phases of the software delivery life cycle (SDLC).

  • Day 0: Discover and Create - Provide ready-to-use templates, documentation, and integration with developer tooling for creating new software applications, services, and components. This includes a software catalog for tracking assets and dependencies.
  • Day 1: Integrate and Deploy - Offer a single dashboard to manage distributed infrastructure across cloud and on-premises environments. Support multiple DevOps automation tools and facilitate API management for creating, managing, and exploring API definitions and policies.
  • Day 2: Operate and Improve - Provide access to service dependency graphs, operational metrics, logs, and traces. Offer an application-centric view into Kubernetes clusters for containerized deployments. Enable understanding of interdependencies, performance, ownership, on-call responsibilities, and incident response.

By unifying a diverse set of platform services and tools into one cohesive portal, internal developer portals enhance developer experience and simplify development workflows.

If you're interested in learning more about internal developer portals in the age of Platform Engineering, check out our recent article, "Ultimate Guide to Internal Developer Portals." It delves into the emergence of platform engineering and reliability trends to address the needs of modern engineering organizations.

In a nutshell, building an internal developer platform and adopting an internal developer portal are quick wins for improving the developer experience. Additionally, reliability engineering plays a vital role in ensuring standardization, providing developer autonomy, and enabling focus time by minimizing disruptions caused by incidents.

What can I do right now to start improving my developer experience?

Developer experience, as mentioned earlier in this article, requires more than simply the adoption of tools.

It requires changes in the culture of the organization, their processes and behaviors as well. Below are some of the ones we have found to be somewhat universally applicable to most companies:

Remove cognitive load

One obvious way to improve developer experience is by reducing cognitive load. This can be achieved by unifying relevant information from different tools in the engineering stack into a single place. Developers shouldn't have to search through multiple tools that contain irrelevant information for common use cases. It's important to remember that visualizing issues without addressing their root causes doesn't provide a real solution. Instead, it's crucial to tackle the underlying challenges directly in order to make genuine progress. Our recommendation is to create a unification layer that seamlessly integrates with the necessary tools, allowing for easy navigation from high-level to low-level details when needed.

Efficient (async) collaboration

When it comes to establishing a strong culture of collaboration between different engineers (and teams), transparency is key. When it comes to tool integration, consider adopting a centralized platform that connects your core tools, such as Slack, Jira, or GitHub and connects them to your organizational context. With this approach you can easily find out who to reach out to and where when incidents happen, or when using a specific component or API from a different team.  Where companies can create team homepages with all the relevant information about each team and create a "Team API" with all of the information about how to work with this team. A few examples of the information that would live here would be:

  • The code (e.g. libraries, runtime endpoints, UI, libraries, repos owned by this team)
  • Versioning: how the team communicates changes to its code and services
  • Wiki, docs and how-to guides
  • Runbooks
  • Practices and principles w/ the team's preferred way of working
  • Communication (tools and channels used for communication)
  • Work info: what the team is working on, what's coming next and their overall priorities
  • Collaboration mode: how other teams should interact with these teams and contribute to the services they own

This can also help leaders identify teams with cognitive overloads in their areas of responsibility (services, domain complexity, software boundaries, etc).There are a few principles we should use when it comes to structuring teams to reflect Conway's Law (that states that the systems that are going to be built are a reflection of the team and communication structure of the people building it).

In the Team Topologies book, their research shows that you should try to reduce as much as possible the communication streams to only the people that need to be involved (too much communication is bad communication). Each team should communicate mostly within itself and a few touch points like the company all hands to make sure everyone is aligned should be enough.

Provide clear (incremental) milestones in a single place

Providing clear guidance on the next actions for engineers is crucial. It ensures they have a precise understanding of the subsequent steps required, whether it involves open pull requests, active incidents, or upcoming tasks for ongoing initiatives with their respective due dates. This approach not only alleviates cognitive burden for developers by consolidating all relevant information in one place, but also creates an engaging experience akin to Role-Playing Games (RPGs). Similar to role-playing games (RPGs), the clearly defined incremental steps cultivate a profound sense of accomplishment, delivering a dopamine hit and making the completion of tasks even more rewarding.

Promoting Self-service DevOps Workflows

Enabling developers to autonomously access tools and resources not only boosts their productivity but also ensures consistency across processes. This decentralized approach to software delivery allows teams to operate at the speed of business, striking a balance between autonomy and standardization.

Self-service plays a crucial role in improving the developer experience by eliminating process inefficiencies and unnecessary steps. For instance, the ability to create a development database or set up a test environment without raising a ticket can enhance developer productivity and maintain their state of flow.

Moreover, developer self-service brings consistency and repeatability to otherwise disjointed processes and manual handoffs, reducing errors. The goal is to make the right thing to do the intuitive thing to do. By offering access to pre-vetted open-source libraries from a trusted component catalog, self-service improves governance and enhances the developer experience.

Optimizing the Development Environment

To quickly identify areas of improvement in your development process throughout the Software Delivery Life Cycle (SDLC), it is crucial to recognize bottlenecks and inefficiencies. Here are some examples of how you can assess and address issues in your development environment:

  • If your Lead Time to Change (LTC) is within a week and you deploy at least once a week, but your Change Failure Rate is high, it may indicate that teams are rushing changes before they are ready or lacking support for the changes being deployed.
  • If you’re deploying once a month, on the other hand, and your MTTR and CFR are high, then your team may be spending more time correcting code than improving your product. To tackle this, we recommend implementing automated quality guardrails like release quality gates that utilize Service Level Objectives (SLOs) as the primary reliability and quality indicator that gates the release. This approach empowers developers to move quickly while ensuring high reliability.
  • If developers have limited focus time, consider initiatives such as designated no-meeting days, consolidating meetings, and promoting asynchronous work.
  • If the productivity is not up the expected standards, consider automating repetitive tasks, improving development tools, and refining coding standards.

By optimizing your development environment, you can streamline processes, increase efficiency, and foster a more productive and reliable software delivery.

Improve documentation and processes

Let’s face it, it’s extremely rare to find companies that have all their documentation and resources up-to-date, well organized, easily accessible and with high quality.

However, it's crucial for organizations to invest in creating documentation, tutorials, runbooks, and guides that are user-friendly and readily available for specific use cases.

For example, having runbooks, API specifications, and dependency maps in a centralized location, alongside the incident triggering page, can greatly reduce cognitive load and mean time to recover during stressful incidents.

Creating and maintaining documentation is crucial, ensuring it is both comprehensive and easily accessible. By integrating the documentation process into workflows (e.g., making it part of definitions of done), it becomes a seamless part of development. Emerging AI tools automate content production, simplifying the documentation process by extracting relevant information from code and automating code comments.

To further enhance usability, consider utilizing internal developer portals (IDPs). These portals help unify all documentation from different tools alongside corresponding services, providing easy access whenever needed. The combination of streamlined processes, productivity-boosting AI tools, and IDPs ensures documentation is not only created and maintained effectively but also readily usable for all.

As you can see, by implementing tools such as internal developer portals, you can significantly enhance the attainment of these improvements. To delve deeper into the world of internal developer portals and kickstart your journey, I invite you to consult the comprehensive guide we wrote. It contains all the essential information you need to know about this topic.

However, it's important to emphasize that many of these improvements necessitate more than just adopting tools. They require cultural and process changes within your organization, as exemplified earlier in the article.

The key is to identify areas where you can make low-effort, high-impact improvements and address them promptly. Measure the impact and severity across different dimensions of DevEx for various teams, and prioritize accordingly.


These frameworks offer leaders valuable insights on enhancing developer productivity through the measurement and prioritization of key aspects of DevEx. By considering the dimensions of feedback loops, cognitive load, and flow state, organizations can effectively understand and improve developer experience.

To start, it is recommended that organizations identify common symptoms of poor developer experience, allowing for quick and easy improvements before investing in formal DevEx initiatives. Once the low-hanging fruits are addressed, organizations can then focus on measuring DevEx across the different dimensions to identify trends, make informed investment decisions, and navigate changes successfully.

For smaller organizations and startups, DevEx plays a crucial role in achieving rapid innovation and market fit. As organizations grow, prioritizing developer experience becomes instrumental in driving business performance through improved engineering efficiency, enhanced product quality, and increased employee retention.

While measuring developer productivity holistically remains a challenge, prioritizing and measuring developer experience provides a proven pathway to building high-performing organizations. Understanding the significance of DevEx, leaders can create an environment that fosters developer productivity and propels their organizations towards success.

José Velez
José Velez
Founder & CEO
José Velez
On this page
Previous post
There is no previous post
Back to all posts
Next post
There is no next post
Back to all posts
Our blog
See related articles
Introducing Dashboards
Introducing Dashboards
Dashboards in Rely allow your engineering teams to create and consume views that best tell the story and have answers for the use cases they care about
Samir Brizini
Samir Brizini
April 11, 2024
The definitive guide for engineering teams to improve their Developer Experience (DevEx)
The definitive guide for engineering teams to improve their Developer Experience (DevEx)
We’ll explore why DevEx matters to your organization, how to define and measure it, the role of internal developer portals and reliability engineering practices, and give you practical recommendations.
José Velez
José Velez
September 21, 2023
How a Reliability Champion (SRE, DevOps, etc.) uses
How a Reliability Champion (SRE, DevOps, etc.) uses
With Rely, you don’t need to worry about miss-communication, manual reports, or learning how to navigate a dozen different platforms - all the insights and literature exists in a single place.
André Cavalheiro
André Cavalheiro
August 10, 2023