DevOps
Better developer platforms are the key to better digital products
What drains developer productivity?
A developer tasked with integrating, say, an API from service A into service B can easily spend days simply searching for the API contract, gaining access and then finding an appropriate test environment. If you've been in this situation you'll probably know all too well that the process can often involve frustrating redirections through multiple colleagues and access approvals. Sometimes a week (or more) can pass with minimal progress on actual development.
Scenarios like this are all too familiar in large organizations. Research in recent years has shown that developer productivity is invariably negatively impacted by technical debt, inefficient tools, poorly structured information and waiting for approvals. These issues are commonly found in large organizations and emphasize the importance of enhancing developer experience (DX).
The four essential elements of developer experience
Developer experience encompasses all the interactions a developer has during the software development lifecycle (SDLC). These can be grouped into four essential elements or needs:
Community. Collaboration in 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 and up-to-date API specifications, architecture decision records (ADRs) and technical notes.
Why do developer experience initiatives often fail in large organizations?
Although developer experience is critical, it's unfortunately not uncommon to see such projects falter. There are a number of common pitfalls that need to be acknowledged if they're to be avoided:
Big bang approaches. Attempting to solve every issue at once can overwhelm teams and lead to ineffective solutions.
Misaligned priorities. Addressing low-impact problems first often results in poor adoption.
Redundant solutions. Rebuilding similar tools for different teams wastes resources.
Lack of feedback loops. Without tracking progress, teams risk veering off course, which can lead to reduced trust and engagement.
Consequently, developer portals and platforms often suffer from low adoption rates. Enhancing these experiences requires targeted initiatives. While smaller teams may find success with simpler solutions, scaling DX initiatives across larger organizations presents a significantly greater challenge.
To navigate these complexities, a strategic and evolutionary approach to scaling DX is essential.
Five proven strategies to scale and enhance DX 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 take a look at them now.
Adopt a customer-first mindset
Developer experience initiatives are paramount for any organization that values its software development teams and aims to optimize productivity. To truly enhance DX, it's essential to adopt a developer-centric approach, which begins with a deep understanding of the challenges and frustrations developers face 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 issues. For example, if developers are consistently delayed by slow and cumbersome access approval processes, a DX initiative could 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 barriers to productivity, organizations can significantly improve developer satisfaction, engagement and, ultimately, the quality and speed of software delivery.
Embrace an incremental approach
When developing internal developer platforms, it's essential to adopt an incremental approach centered around a minimum viable product (MVP). This strategy ensures that the platform remains adaptable and loosely coupled, preventing it from imposing restrictions on the overall architecture or technology stack choices.
For instance, if your organization decides to migrate from Jenkins to GitHub Actions for CI/CD orchestration, your platform should seamlessly support this transition without necessitating extensive reconfiguration or imposing limitations on team autonomy. This flexibility is crucial to accommodate the evolving needs of development teams and the ever-changing technology landscape. By prioritizing adaptability and avoiding rigid dependencies, you can create a platform that empowers developers to select the best tools and technologies for their specific requirements, fostering a culture of innovation and agility.
By building incrementally and focusing on the core functionalities of your MVP, you can create a platform that provides long-term value and supports the evolving needs of your organization.
Enable self-service
To empower developers and boost their efficiency, organizations should move away from traditional, ticket-based systems. AWS is a prime example, as it allows developers to directly provision resources, streamlining the development process. Additionally, organizations can leverage platform orchestrator systems like Kratix or Humanitec to build self-service capabilities for development tasks. This reduces reliance on other teams, empowers developers and improves efficiency and service quality.
Create a 'single pane of glass'
To optimize developer experience and streamline workflows, it’s essential to consolidate disparate tools and processes into a unified, easily accessible portal. This centralized platform should serve as a single point of entry for developers to access all the resources they need to perform their daily tasks, eliminating the need to navigate multiple sites and applications.
A key feature of this unified portal is a robust search function that allows developers to quickly and easily find the information they need, including APIs, catalogs, documentation and other relevant resources. This eliminates the time-consuming and frustrating process of searching through multiple sources to find the necessary information, significantly improving developer productivity and efficiency.
Measure what matters to developers
Developer experience shouldn't be measured by productivity metrics, which are often mistakenly used. Instead, focus on metrics that indicate a developer's flow state. These include wait times for tools, infrastructure and access, as well as delays in feedback. Define clear metrics of success, data collection methods and how it all comes together to improve the overall developer experience.
Using both lagging and leading indicators, gather 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 results can improved DX deliver?
Accelerated onboarding. Streamlining the developer onboarding process, reducing the time it takes for new developers to become productive from weeks to a mere 15 minutes. This could include providing pre-configured development environments, clear documentation and automated setup scripts.
Self-service API consumption. Allowing developers to consume APIs through a self-service platform, reducing the cycle time from weeks to minutes and achieving 70% coverage. This entails providing easy-to-use API documentation, developer portals and tools for discovering, testing and integrating APIs.
Rapid and reliable deployments. Implementing a robust continuous integration and continuous delivery (CI/CD) pipeline, enabling developers to deploy code changes to production multiple times per day in minutes. This involves automating testing, build and deployment processes and ensuring a smooth path to production.
The role of Backstage in scaling DX
To bring these techniques to life, we’ve 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 integrating markdown files directly into the portal.
Software Templates. These automate the creation of new services with best practices built in.
Pluggable Architecture. This Backstage feature Allows customization and seamless integration with existing tools.
For example, integrating Swagger as API specification documentation into Backstage, developers can easily search and access all APIs without any additional effort. This seamless integration eliminates the need for manual API specification and saves developers valuable time and effort.
Start successfully scaling developer experience
Improving developer experience isn't about implementing quick fixes or large platforms that claim to solve every issue. Instead, it involves focused, gradual improvements that prioritize the needs of developers, encourage autonomy and promote 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 Thoughtworks.
