It will surprise no one reading this that enterprises (1000+ employees) have the highest cycle time compared to their startup (0-200 employees) and scale-up (200-1000 employees) counterparts. But it’s only after a study of 3.6 million pull requests (PRs) from 2,000+ development teams across 64 countries that we’ve revealed exactly why this is. Spoiler: the devil is in the details.
In this article, I’m going to do three things that will allow us to dive into these mission-critical details.
- Build an enterprise software delivery profile using data.
- Identify where complexity is a blocker vs. real opportunities to improve.
- Lay out a plan to help any enterprise engineering org start moving faster.
The Enterprise Software Delivery Profile
It’s nearly impossible for engineering teams to improve if they don’t have data-backed targets to work toward. From this problem, our Software Engineering Benchmarks Report was born. As engineering leaders look to industry standards — including data segmented by organization size, geography, and industry — they can set a more realistic plan of action for engineering improvement.
Let’s look at the differences in engineering metrics of enterprise engineering teams and their startup and scale-up counterparts:
Enterprises excel at:
- Enterprises have the lowest coding time compared to startups and scale-ups, with elite enterprise teams spending <.25 hours, elite scale-up teams spending <.50 hours, and elite startup teams spending <.35 hours coding.
- PR pickups. Enterprises have the lowest PR pickup time when compared to startups and scale-ups, with elite enterprise teams spending <.5 hours, elite scale-up teams spending <1.5 hours, and elite startup teams spending <1 hours for PR pickups.
Enterprises could improve at:
- Cycle time. Enterprises have the longest cycle time compared to startups and scale-ups, with elite enterprise teams spending <29 hours per cycle (this even goes for enterprise teams with excellent pickup — <30 min — and coding times — <15 min), compared to scale-ups and startups spending <27 and <21 hours, respectively.
- Deploy time. Enterprises have the longest deployment time compared to startups and scale-ups, with elite enterprise teams spending <4 hours to deploy, compared to scale-ups and startups, which both spend <3 hours.
- Merge frequency. Enterprises have the lowest merge frequency compared to startups and scale-ups, with elite enterprise teams hitting >1.5 per dev/week, compared to scale-up and startup teams, which hit >1.75 and >2, respectively.
- Cross-team collaboration. Enterprises have the lowest rate of cross-team PR collaboration compared to startups and scale-ups, at 14.63%.
- Rework rate. Enterprises have a 17% higher rework rate than startups.
- Working hours overlap. Enterprises have the fewest hours of overlapping work across their teams, coming in at around 70%, with scale-ups hitting 75% and startups hitting 80% of overlap time.
It’s easy to say that enterprises are slow-moving behemoths because of legacy code and code complexity, but that’s not the whole story. Our data shows that developers working at enterprises are not slow or lazy — the reality is quite the opposite.
Enterprise devs are actually quantitatively faster than devs at smaller organizations, with the lowest cycle time and PR pickup time. The higher deploy time and rework rate is not due to a lack of developer code quality, but due to higher code standards and more complex integrations.
Complexity vs. Opportunity
With all these metrics in mind, where can we blame enterprise complexity for shortcomings and where can we actually look to improve?
The truth of the matter is that when enterprise code fails, it costs more. Enterprises have more expansive codebases and larger customer bases, meaning greater risk every time they merge code. This, in conjunction with a higher complexity of code and infrastructure, requires more rigorous testing, QA, security, etc.
Where do enterprises actually have an opportunity to improve? Well, it’s not typing faster. It’s far more human than that. To improve enterprise software delivery speed, engineering leaders need to focus on breaking down information silos and promoting better team collaboration. This is not a novel idea, as it’s something DevOps and the Agile Manifesto have preached for decades, but now we finally have the data to back it up.
Helping Enterprise Software Development Move Faster
Startups and scale-ups often see rapid release cycles, yet enterprises can struggle to match this pace. While the coding, pickup, and review phases of the development cycle are comparable between enterprises and their smaller counterparts, it is the deployment phase that significantly slows down the overall cycle time for enterprises.
Deploy time can be further complicated by the fact that it typically doesn’t directly overlap with merge activities. This means accumulating undeployed code can create a significant burden on developers and hinder their ability to merge code frequently. That, coupled with indirect factors like the percent of overlap in working hours across a distributed dev team, means deploy time is impacted by more than just pickup and review times.
In fact, our study found that merge frequency is higher when dev team members work similar hours to their teammates. Through faster feedback loops and reduced communication barriers, dev teams can reduce the time it takes code to move through the software development lifecycle, speeding up issue resolution and progress.
Enterprises that work to facilitate collaboration across their teams, add automation to their code review processes, and hone their focus on detailed benchmarking around merge frequency can greatly improve efficiency and output. When you build an environment of collaboration and efficiency, your team will naturally find new and better ways of improving your software delivery process.