Why Developer Experience Is Key to Productivity
Author: Rob Nicholson, Philips Software Excellence Leader, Innovation Excellence
The software development industry is rife with tales of teams achieving tenfold productivity gains. And many organizations have developers who are highly productive, sometimes referred to as “10x developers.” However, while not everyone is a 10x developer, every team can achieve 10x and even 50x productivity with the right developer experience. On the other hand, even the best developers can’t achieve their full potential without the right developer experience.
It’s this experience that empowers developers to excel by removing the friction and obstacles that slow them down and reduce productivity. Through this article, I’ll discuss strategies to enhance developer experience and ensure that your team can harness its full potential and drive productivity to new heights.
Interestingly, regardless of the industry you’re working in — even in sensitive fields such as healthcare — focusing on developer experience can be an important step toward boosting productivity.
A telling example
In 2019, Nicholas Chaillan, then-chief software officer for the US Air Force, visited SpaceX headquarters with 50 of his software leads. Their mission was to get lessons from SpaceX’s renowned software prowess. What they found was a lean team of 50 developers, deftly managing the software for nine of SpaceX’s vehicles — a stark contrast to the 2,500 developers in Chaillan’s government organization tasked with similar challenges.
The SpaceX software team’s productivity was impressive. They were not just matching but outperforming their government counterparts by a factor of 50. They had a dedicated software simulation team capable of emulating rocket flights 17,000 times daily before deployment to production. Their approval process for new tools was streamlined to a single day, and they embraced a culture of radical reuse and agile platforms — practices that significantly accelerated their development cycle.
This narrative isn’t unique to SpaceX; it’s a recurring theme among leading software innovators. These trailblazers understand that unlocking a developer’s full potential is essential. By removing barriers and fostering an environment where developers can thrive, they achieve remarkable productivity.
When I refer to “developers,” I’m encompassing all roles within the software development lifecycle, including coders, DevOps engineers, designers — everyone contributing to the creation and deployment of software.
SpaceX’s success is particularly noteworthy given the highly regulated nature of the aerospace industry. Their ability to maintain such high productivity levels under stringent regulations is compelling evidence that improving developer experience is crucial, irrespective of the industry.
What is developer experience?
Optimizing developer experience is about crafting a collaborative environment where developers can achieve peak productivity, have a significant impact, and feel deeply satisfied with their work. It’s a multifaceted concept, encompassing three core elements: productivity, impact, and satisfaction — each deserving its own detailed exploration.
Productivity in developer experience pertains to the efficiency with which developers can introduce changes to the codebase. It’s about streamlining the journey from conception to implementation, ensuring that the process is as seamless as possible.
Impact focuses on the ease with which developers can inject new ideas and value into the code. It’s not just about writing code, but about making meaningful contributions that resonate through the product and ultimately reach the user.
Satisfaction is tied to the joy developers derive from their work. When developers are happy, their performance soars. They find their flow, maintain motivation, and focus on delivering value to end-users. Conversely, dissatisfaction arises when obstacles impede this flow, causing friction and diminishing morale. A developer’s happiness is amplified when they can efficiently deliver value, which in turn boosts their overall productivity.
Collaboration is the linchpin of developer experience. It’s not about solitary efforts but about a team of developers synergizing to amplify their collective output. As projects scale, the challenge is to prevent the team from stumbling over each other. Effective collaboration means aligning efforts so that they complement rather than complicate the work, magnifying the team’s impact.
Going deeper
Underlying the developer experience are three key components: tooling, architecture, and culture. Let’s start with tools.
Tools
The tooling environment is a cornerstone of Developer Experience, encompassing everything from IDEs, documentation, programming languages, Continuous Integration (CI), Continuous Delivery (CD), test automation, to static analysis and security scans.
Reflecting on the evolution of tools, we’ve come a long way since the 1980s when my setup consisted of the VI editor, a compiler, and “make.” Today, modern IDEs are equipped with AI and static analysis plugins that offer real-time assistance, akin to a pair programming partner.
Advanced CI and test automation tools enable scores of developers to work simultaneously on complex codebases, releasing updates hundreds of times per day. This collaborative efficiency has shortened the journey of ideas to production from months to mere minutes or hours.
However, regardless of all advanced technologies, the main principle remains constant: The key to a successful tooling environment is its ability to let developers achieve “flow state” concentrating entirely on the problem at hand, eliminating any distractions or friction.
Friction can manifest in various forms: struggling with code access and dependencies, sluggish or insufficient development machines, malfunctioning automation, lack of necessary tools, broken builds, and the pervasive issue of technical debt.
An optimal tooling setup proactively shifts left as many concerns as possible. This means that as soon as a developer writes code or opens a file in the IDE, they’re immediately alerted to issues and provided with suggestions. This not only streamlines the development process but also enhances the quality of the code from the get-go.
Architecture and code
The architecture and codebase are pivotal to developer experience. A well-crafted architecture facilitates rapid and effortless code changes, propelling ideas into production with speed and efficiency.
A robust architecture provides a platform that abstracts away the mundane, including many non-functional requirements. This abstraction allows developers to focus on creating value rather than getting bogged down by complex or oversimplified systems that fail to encapsulate architectural concerns.
Effective architecture enhances the development experience by simplifying the process of modifying and expanding the project. It ensures good cohesion and encapsulation, so developers can confidently adjust one part of the code without the fear of breaking hidden dependencies.
The clarity of the code is equally crucial. Clean, understandable code turns development into a pleasure, significantly boosting developer experience. It’s important to recognize that poor architecture doesn’t arise by design. Most projects commence with a clean, straightforward architecture tailored to the initial use case.
However, as projects evolve, so do their requirements. What was once a system that didn’t account for mobile devices or cloud integration may now need to encompass these aspects. Gradually, the architecture can become a hindrance rather than a help, complicating problems developers are trying to solve.
Acknowledging that architecture is dynamic is vital. It’s not a set-and-forget element of development; it requires ongoing investment to maintain cleanliness and relevance. As new requirements emerge, the architecture must adapt to continue supporting developers effectively.
Culture
Organizational culture is a critical, yet often overlooked, factor in shaping developer experience. A culture with the right characteristics can significantly enhance productivity and satisfaction.
Key to this culture is high cooperation. Cross-functional teams that bring together business analysts, developers, quality engineers, operations, security, and more, ensure that all perspectives are integrated into the software delivery process.
You need to train messengers that can convey bad news instead of hiding it under the rug. By conducting blameless post-mortems, organizations create a culture of openness and learning. Removing blame eliminates fear, encouraging transparency and continuous improvement.
Shared risks are another cornerstone. In high-performing teams, quality, availability, reliability, and security are collective responsibilities. Successful companies often have a single development and operations (DevOps) team so developers share responsibility for maintaining their code in production.
Encourage the breaking of silos. It’s crucial to facilitate collaboration between development, operations, marketing, finance, and other departments to ensure alignment and shared goals.
Embracing novelty is also vital. Organizations should value “wild ducks” — those who propose unconventional features, processes, practices, or tools that could drive innovation.
The overarching message is to cultivate a culture where responsibility and the rewards of building software are shared among all. Such an environment not only fosters collaboration and innovation but also contributes to a positive developer experience.
How Philips optimizes developer experience
Philips is pioneering the Code Hub initiative, offering a suite of top-tier tools readily available for self-service. This approach is designed to weave these tools into development teams’ workflows with minimal friction, streamlining their processes.
Through the software craftsmanship program, Philips aims to elevate the quality of both code and architecture. This initiative helps teams find their flow and unlock their creative potential, ensuring that developers can work with precision and passion.
Culturally, Philips champions the principles of a generative culture. The inner source program is a testament to this, promoting open sharing of code and practices across the organization, fostering collaboration and innovation.
I am convinced that by nurturing the right developer experience, any organization can amplify its productivity by up to 50 times.
Curious about working in tech at Philips? Find out more here
References
1. https://washingtonexec.com/2019/11/nicolas-chaillan Podcast. 44:00 timestamp.