Let’s be honest, we were all hoping 2023 would bring some relief from the challenges of the past few years. But here we are dealing with supply-chain issues, the great resignation, quiet quitting, and what might be the first global recession. This uncertainty means DevOps and engineering managers are under tremendous pressure to maintain developer productivity levels and make the most out of resources.
What sounds like an impossible task, might be an opportunity to rethink how we increase programmer productivity. Industry research and our own first-party survey of hundreds of developers suggest that reducing friction and wasted time is a more effective way to increase developer productivity than efforts to make programmers code faster.
The return on investment looks promising: McKinsey & Company found that the savings produced by reducing each developer’s wasted time by five minutes on a team of 500 developers could support a full team of developers working on standardization.
In our recent report, we explore where productivity is lost and look at solutions DevOps and engineering managers can implement to reduce friction and increase developer productivity.
It’s time to get rid of things that are throwing shade on your developers' day-to-day work. By making more time for the type of work that makes them happy (think: more coding, less of everything else) you’ll see developer productivity multiply.
What is developer productivity?
At Garden, we believe improving the developer experience is the key to helping developers increase productivity (and happiness, but more on that later). In this context, developer or programmer productivity refers to how quickly and efficiently individual developers complete their code and pass all the tests. When the development process runs smoothly, developers complete more work faster (and with less frustration). This in turn increases development velocity for the team as a whole.
How to improve developer productivity
How can engineering managers help developers increase their productivity? By addressing places where productivity is lost, reducing friction, and empowering developers to spend more time coding and less time on pretty much everything else.
Analysts at Gartner and McKinsey both recommend a “servant-leadership” approach that focuses on removing roadblocks and empowering teams to be successful. “When leaders identify and resolve roadblocks, for example, their teams are 16% more effective. Likewise, when leaders take on coordination with stakeholders like project managers or governance partners, they up team effectiveness by another 11%,” writes Laura Starita, in Garner’s “3 Ways to Make Your Software Engineering Team 50% More Effective”
Developers know where their time is wasted and can be valuable partners in creating better standards and processes. Involving developers in standard setting makes them 23% more effective than their counterparts who don’t participate in standard setting, wrote Starita.
Make work a happy place (psychological safety)
Toxic metrics and pushing developers to perform better without improving the process or their experience are unfortunately still problems in the industry. Creating a safe and happy workplace is critical to helping developers do their best work and be more productive. The most important cultural attribute is psychological safety, according to research on developer velocity by McKinsey & Company. This means protecting developers’ ability to experiment and fail, and investing in tools and systems that minimize the cost of those failures.
Invest in the best developer productivity tools
McKinsey & Company identified best-in-class tools as the top contributor to business success — enabling greater productivity, visibility, and coordination. Yet only 5 percent of executives ranked tools as one of their top-three software enablers. “The underinvestment in tools across the development life cycle is one reason so many companies struggle with “black box” issues,” write researchers in “Developer Velocity: How software excellence fuels business performance.”
How does happiness affect developer productivity?
There’s a synergy between productivity and developer happiness. Developers are happier when they feel more productive and they’re more productive when they're happy. Improving the developer experience helps identify and remove roadblocks to reduce frustration and increase productivity.
Consider these findings. A Stack Overflow survey on developer happiness, found that feeling unproductive at work was the number one (45%) cause of unhappiness — even above salary.
In a separate study, Forbes found that happy developers were 1.8 times more likely to deploy to production multiple times a day compared to their grumpier counterparts.
Wondering what makes developers unhappy? Check out our whitepaper for more insights and learn what engineering managers can do to improve the developer experience and unleash productivity.
How more complex systems impact developer productivity
“Application complexity is an issue that most organizations need to deal with, and how you deal with it will impact the future of your application, the health and stability of your development organization, and the future of your business.”
-Lee Atchison, InfoWorld, "A cure for complexity in software development"
The proliferation of cloud-native capabilities offers tantalizing possibilities for building containerized architecture, unique digital experiences, near-instant data processing, AI and ML applications. Developers are experimenting with and adopting new tech at a breakneck pace. This fuels innovation, but it also creates complex systems that evolve organically — and this can get a little messy.
In a recent study on developer velocity at work, McKinsey & Company found that companies use as many as 50 different tools. And these tools can be extremely complicated: Kubernetes is barely a decade old and developers who’ve mastered it are in limited supply. Yet 70% of IT leaders said they work for organizations that use Kubernetes, according to Red Hat’s State of Enterprise Open Source Report.
More time wrangling tools means less time coding
We adopt new tools because they offer exciting possibilities, but those benefits come at a cost.
Garden found that developers spend 14 to 16 hours every week wrangling internal tools, setting up environments, and waiting for tests, builds, and pipelines. Developers at organizations using Kubernetes were at the higher end of that range.
More time spent wrangling tools means less time coding. Similar to Garden’s findings, ActiveState observed an approximate 20% decrease in time spent programming between their 2018 and 2019 surveys. The number of respondents who spend eight or more hours a day programming dropped by almost 50% in the same timeframe.
Developer productivity tools: What are the benefits?
Sometimes it's hard to see how the development process can work differently. Productivity tools can help management identify blockers and reduce friction points that frustrate developers and slow processes down. Also, resources like DevOps automation tools, can save time and significantly improve the developer experience.
In Zenhub’s 2022 Software Developer Happiness Report, developers positively rated many aspects of productivity tools:
How to measure developer productivity
It’s hard to talk about productivity without metrics, but developer metrics are often associated with toxic practices. Let’s be clear: productivity metrics should be used to measure impact or identify areas for improvement — not to spur developers to code harder and faster. We’re pretty sure business leaders and customers care more about business outcomes, such as more frequent deployments and fewer incidents and rollbacks, than they do about lines of code.
Healthy vs. harmful use of developer productivity metrics
No business can simply “metric” their way to sustainable, higher productivity. Metrics help organizations, teams and individuals figure out what they’re doing well, where they can improve and how changes impact performance. They help managers understand how different parts of the process are working, predict timelines and identify blockers.
“The goal of tracking and analyzing software metrics is to determine the quality of the current product or process, improve that quality and predict the quality once the software development project is complete.”
Alexandra Altvater, Stackify, "What Are Software Metrics and How Can You Track Them?"
While metrics are helpful, they can be misused and they rarely tell the whole story. Focusing too narrowly on one metric, or one type of metric, can be misleading and detrimental to improvement efforts. A common example of this is measuring lines of code. This can inadvertently reward developers who write a lot of low-quality or simplistic code, and punish those who accomplish the same thing more efficiently.
We want developers to write elegant code that works well and is easy to maintain. We want high-quality software. Focusing on a narrow measure like lines of code can result in a sort of busy work that artificially mimics productivity, but fails to result in better outcomes.
What developer productivity metrics should you use?
No one seems to agree on one golden metric that works for every business. A good practice is to choose some metrics that focus on speed and velocity and some that focus on quality and stability. This prevents unintentional trade-offs.
Google Cloud’s DevOps Research and Assessment (DORA) team identified five metrics that strike this balance. These metrics are based on eight years of research and measure both software delivery performance and operational performance. Teams that strike this balance and excel in all five measures exhibit exceptional organizational performance.
DORA’s 2022 State of DevOps report highlights the importance of measuring different aspects of performance. “We have evidence that suggests that delivery performance can be detrimental to organizational performance if not paired with strong operational performance,” write the authors to explain why they added a fifth metric: reliability.
Metrics within the metrics
While the DORA metrics are a valuable tool in identifying areas for improvement in DevOps, developers are often more focused on the early part of the process. Meanwhile, engineering managers are focused on the full cycle: What’s the delta between when a developer thinks they’re done (they’ve written and delivered code) and when they’re actually done (code has passed all the tests or is in production)? How long does each step take?
Measuring how the early part of the process is working can help identify areas for improvement that can lower change failure, increase deployment frequency and lower lead time for changes. These metrics can include time between starting a new branch and getting a pull request merged, time between starting new work and getting the test to pass, and how frequently you need to push to get code done and working.
Looking at underlying metrics that impact high-level metrics can help teams improve productivity by making small changes in the right places. Instead of managers challenging teams to deploy more frequently (and leaving them wondering how), you can identify and remove specific roadblocks and take a more holistic DevOps approach to reduce friction and increase overall productivity.
Maximize developer productivity with Garden
Garden provides tools that reduce friction and provide the insights engineering managers need to remove roadblocks and make delivery faster and more predictable. Learn more about increasing developer productivity in our whitepaper, or schedule some time to chat about how we can integrate with your current tools and help you start developing faster now.