Increasing Development Efficiency

The first step in improving efficiency is to agree what we mean by development efficiency because there are at least three, and possibly many more, ways that companies measure efficiency today.

1. Utilisation
   Is everyone on the team actively working on productive (aka capitalisable) features?

2. Plan completion
   Are we tracking on-time and on-budget towards our agreed delivery date?

3. Lead time
   How long does it take to go from idea to satisfied customers?

The tactics and techniques that a company can use to improve the efficiency of development differ depending on which of the types of efficiency they are targeting. And a preference for one type over another often end up in opinion battles with no real winner.

Fortunately, the team at DevOps Research and Assessment (DORA), Nicole Forsgren, Jez Humble and Gene Kim, did the hard work of identifying which metrics are correlated with business success, which they covered in their book Accelerate. Low Lead Time has a statistically significant correlation with improved business outcomes.

Reducing Lead Time

To identify how to improve lead time, we need to understand the factors that influence delivery speed. Fortunately, there is a very simple formula that we can use: Little's Law.

Little's Law states that the average number of items in a system (L) equals the average arrival rate (λ) multiplied by the average time each item spends in the system (W). In software development terms:

This means that if we want to improve efficiency in our system we can either increase throughput or reduce work in progress (WIP). Let's explore both approaches in detail.

Increasing Throughput: The Three Pillars

1. Improving Individual and Team Efficiency

The first approach to increasing throughput focuses on making existing resources more efficient. This strategy involves several key components:

Principles, Patterns, and Frameworks

While we never built the same thing twice, we are often building systems similar to what others have already built. Rather than reinventing the wheel each time we can significantly boost efficiency by leveraging established principles, patterns, frameworks, and templates. For example:

• Principles: Shared guidelines like "write clean code" or "prefer composition over inheritance" align teams on best practices.

• Patterns: Architectural patterns like MVC (Model-View-Controller) or design patterns like Singleton streamline problem-solving.

• Frameworks: Tools such as React or Django encapsulate best practices and accelerate development.

• Templates and Starter Functions: Boilerplate code and pre-configured templates enable developers to start projects with minimal setup.

These layers of abstraction not only reduce boilerplate but also allow developers to focus on solving higher-value problems, increasing throughput and quality.

Training and Knowledge Transfer

Efficiency isn’t just about tools—it’s about people. Developers' speeds can vary significantly due to their knowledge and skills. Training and knowledge-sharing practices like communities of practice, lunch-and-learn sessions, and documentation repositories ensure that knowledge flows freely within, and across, teams.

High-Quality Tooling

Tools are the backbone of developer efficiency. Integrated development environments (IDEs), code linters, and CI/CD pipelines automate repetitive tasks, reduce errors, and enhance developer productivity. Investing in developer experience (DevEx) through high-quality tooling creates a multiplier effect, amplifying the impact of every team member.

Just get AI to write it

AI isn’t good enough to replace developers (yet), but studies show that developers who utilise AI tools are 36% faster at completing tasks. Teams should be looking at the latest models and the IDE’s that enable better AI integration.

2. Scaling Team Size

While adding more developers might seem like an obvious solution to increase throughput, Fred Brooks' Mythical Man-Month reminds us that this approach comes with significant challenges:

Onboarding: Moving Slowly to Move Fast

Bringing new people into a team requires deliberate planning. Effective onboarding includes:

• Documentation: Comprehensive guides to workflows, codebases, and tooling.

• Mentorship: Pairing new hires with experienced team members.

• Gradual Integration: Allowing new hires to start with smaller tasks to build confidence and understanding.

A slow, structured onboarding process minimises disruption and ensures that new team members contribute meaningfully without derailing existing workflows. Given the disruption and slow adoption speed, team size increases should be a last resort after other methods have been exhausted.

3. Process Optimisation

Reducing Waiting Time

Waiting time is often the biggest inefficiency in software development. Delays in code reviews and pull requests (PRs) stall progress by creating bottlenecks. These practices were designed for asynchronous, zero-trust environments like open source development but introduce unnecessary delays with the collaborative nature of modern teams.

Pair and Mob Programming

Instead of relying on asynchronous processes, consider real-time collaboration:

• Pair Programming: Two developers working together on the same code increases quality and reduces waiting time.

• Mob Programming/Teaming: Extending this concept to a whole team ensures that everyone’s input is captured in real-time, eliminating back-and-forth and enabling immediate feedback.

While pairing and teaming require cultural and process shifts, the gains in quality and speed often outweigh the investment.

Automating Reviews

Automation tools for code reviews and CI/CD can streamline processes by catching errors earlier and reducing the burden on human reviewers. These tools, from linters to security scanners, enhance efficiency without compromising quality.

Reducing Work in Progress (WIP)

The other side of Little's Law involves reducing WIP to improve lead time and overall efficiency.

Backlogs: A Hidden Time Sink

Backlogs, such as Ready for Dev, Ready for Review, Ready for Test or Ready for Release, allow different functions within a team to operate at different speeds. The problem is that managing backlogs becomes a job in itself.

Backlogs lead to constant context switching, as people need to re-learn the context when re-starting on a piece of work. Any clarification questions also require context switching for other functions. Reducing WIP by keeping backlogs lean is one of the fastest ways to increase throughput.

But Backlogs Exist for a Reason

Different parts of the development process take different lengths of time. A designer might be able to create a wireframe in a few days that would take weeks or months to implement. With no development backlog the designer would be prevented from doing any work during this time. Also, backlogs allow batching of work for more efficient processing. For example, QA and Operations people prefer to work on multiple items at once rather than dipping in an out more frequently.

In summary, backlogs exist to ensure more efficient working at each individual function. But, paradoxically, improving efficiency at a function may negatively impact the flow efficiency of the process as a whole. Backlogs slow down the overall flow in the system.

To overcome the conflict between individual and process efficiency, we should again look to adopt Pair and Mob practices. In this model, teams work on a single piece of work at a time, delivering higher-quality outcomes faster. While it appears less efficient at a functional level, research shows the increase in quality results in less rework and ultimately equivalent development speed.

Conclusion

Improving development efficiency starts with agreeing on the efficiency we are trying to optimise for. Research from DORA shows that Lead Time is the best efficiency metric as it is correlated with business success.

Improving lead time requires improvements that tackle both sides of Little's Law; increasing throughput and reducing WIP. By improving processes and team practices we can increase throughput. We can also reduce WIP through cross-functional teams and modern development approaches like mob programming.

Remember that change takes time and patience. Start small, measure results, and adjust your approach based on what works best for your specific context. There's no one-size-fits-all solution, but the principles outlined in this article provide a solid foundation for improving your development efficiency.