What holds back developer productivity?
A developer tasked with integrating, say, an API contract from service A to service B can easily spend several days just looking for the API specification, obtaining access, and finding a suitable test environment. If you have lived through this situation, you probably know that the process often involves frustrating hand-offs across several colleagues and access approvals. Sometimes a week (or more) can pass with minimal progress on the actual development work.
Scenarios like this are unfortunately common in large organizations. Research in recent years has shown that developer productivity is consistently affected negatively by technical debt, inefficient tooling, poorly structured information, and waiting for approvals. These issues are common in large organizations and highlight the importance of improving developer experience (DevEx).
The four essential elements of developer experience
Developer experience covers every interaction a developer has throughout the software development lifecycle (SDLC). These interactions can be grouped into four essential elements or needs:
Community. Collaboration through meetings, instant messaging, and other shared tools. Content. Comprehensive onboarding documentation, clear functional context, and accessible learning paths and tutorials. Delivery infrastructure. Efficient infrastructure provisioning, readily available tools and access, optimized CI/CD pipelines, effective monitoring, and well-organized code repositories. Documentation. Clear, up-to-date API specifications, architectural decision records (ADRs), and technical notes.
Why do developer experience initiatives often fail in large organizations?
While developer experience is critical, it is unfortunately not uncommon to see these projects fail. There are a number of common pitfalls that need to be recognized in order to be avoided:
"Big bang" approaches. Trying to solve every problem at once can overload teams and lead to ineffective solutions. Misaligned priorities. Prioritizing low-impact problems often results in low adoption. Redundant solutions. Rebuilding similar tools for different teams wastes resources. No feedback loops. Without tracking progress, teams risk drifting off course, which can reduce trust and engagement.
As a result, developer portals and platforms often suffer from low adoption rates. Improving these experiences requires targeted initiatives. While small teams can find success with simpler solutions, scaling DevEx initiatives in larger organizations presents a considerably bigger challenge.
Navigating these complexities requires a strategic, scalable approach to expanding DevEx.
Five proven strategies for scaling and improving DevEx implementation
While effective developer experience initiatives can sometimes prove challenging, there are a number of strategies and approaches that can be incredibly helpful. Let's walk through them now.
Adopt a developer-centric mindset
Developer experience initiatives are essential for any organization that values its software development teams and aims to optimize productivity. To truly improve DevEx, it is essential to adopt a developer-centric approach, which starts with a deep understanding of the challenges and frustrations developers encounter in their daily work. This can be achieved through surveys, feedback sessions, and direct observation of developer workflows.
Once these pain points are identified, the next step is to design and implement platforms and portals that directly address these problems. For example, if developers are constantly delayed by slow and cumbersome access approval processes, a DevEx initiative might focus on streamlining and automating these approvals, perhaps through a self-service portal or integration with identity and access management systems.
By proactively addressing these pain points and removing obstacles to productivity, organizations can significantly improve developer satisfaction, engagement, and ultimately the quality and speed of software delivery.
Adopt a progressive, MVP-centered approach
When developing internal developer platforms, it is essential to adopt a progressive approach centered on a minimum viable product (MVP). This strategy ensures the platform stays adaptable and loosely coupled, preventing it from imposing restrictions on overall architecture or technology stack choices.
For example, if your organization decides to migrate from Jenkins to GitHub Actions for CI/CD orchestration, your platform should seamlessly support this transition without requiring extensive reconfiguration or imposing limitations on team autonomy. This flexibility is crucial for adapting to the evolving needs of development teams and the ever-changing technology landscape. By prioritizing adaptability and avoiding rigid dependencies, you can build a platform that empowers developers to select the best tools and technologies for their specific needs, fostering a culture of innovation and agility.
By building progressively and focusing on the core features of your MVP, you can create a platform that delivers long-term value and supports your organization's evolving needs.
Enable developer autonomy
To empower developers and increase their efficiency, organizations must move away from traditional ticket-based systems. AWS is a great example of this, as it allows developers to provision resources directly, streamlining the development process. Additionally, organizations can leverage platform orchestration systems like Kratix or Humanitec to build self-service capabilities for development tasks. This reduces dependency on other teams, empowers developers, and improves the efficiency and quality of services.
Create a "single pane of glass"
To optimize developer experience and streamline workflows, it is essential to consolidate disparate tools and processes into a unified, easily accessible portal. This centralized platform should serve as the single entry point for developers to access all the resources they need to complete their daily tasks, eliminating the need to navigate between multiple sites and applications.
A key feature of this unified portal is a robust search function that lets developers quickly and easily find the information they need, including APIs, catalogs, documentation, and other relevant resources. This eliminates the tedious and frustrating process of searching across multiple sources to find needed information, significantly improving developer productivity and efficiency.
Measure what matters to developers
Developer experience should not be measured by productivity metrics, which are often misused. Instead, focus on metrics that indicate a developer's state of flow. These include wait times for tools, infrastructure, and access, as well as delays in feedback. Define clear success metrics, data collection methods, and how it all works together to improve the overall developer experience.
By using both lagging and leading indicators, collect qualitative and quantitative feedback to ensure continuous improvement and alignment with organizational goals.
> Every developer needs a seamless user experience that accelerates outcomes and drives greater business impact.
What outcomes can improved DevEx deliver?
Faster onboarding. Streamlining the developer onboarding process, reducing the time needed for new developers to become productive from weeks to just 15 minutes. This could include providing preconfigured development environments, clear documentation, and automated setup scripts. Self-service API consumption. Enabling developers to consume APIs through a self-service platform, reducing cycle time from weeks to minutes and achieving 70% coverage. This involves providing easy-to-use API documentation, developer portals, and tools to discover, test, and integrate APIs. Fast and reliable deployments. Implementing a robust continuous integration and continuous delivery (CI/CD) pipeline, enabling developers to deploy code changes to production multiple times a day in minutes. This involves automating testing, build, and deployment processes and ensuring a seamless path to production.
Backstage's role in scaling DevEx
To put these techniques into practice, we leveraged Backstage, an open-source internal developer portal developed by Spotify. Its features align with the principles outlined above:
Software catalog. This organizes and tracks ownership of all services and APIs. TechDocs. This simplifies documentation management by directly embedding markdown files into the portal. Software templates. These automate the creation of new services with best practices baked in. Modular architecture. This Backstage feature allows for customization and seamless integration with existing tools.
For example, by integrating Swagger as API specification documentation within Backstage, developers can easily search for and access all APIs with no extra effort. This seamless integration removes the need for manual API specification lookups and saves developers valuable time and effort.
Getting started with scaling developer experience
Improving developer experience is not about implementing quick fixes or large platforms that claim to solve every problem. Instead, it involves gradual, targeted improvements that prioritize developer needs, encourage autonomy, and foster seamless collaboration.
By adopting the five techniques mentioned above and using tools like Backstage, organizations can empower their developers, increase productivity, and cultivate a thriving engineering culture.
Disclaimer: The statements and opinions expressed in this article are those of the author(s) and do not necessarily reflect the positions of Adservio.
STAY POSTED
Get our next analyses and field notes straight to your inbox.
