The pace of software development is slowing down over time

You're not imagining it. As you scale the joint challenges of growing product and organisational complexity conspire against the best efforts of people to keep software moving quickly.

For bureaucrats procedure is everything and outcomes are nothing.

Our process is the problem

Dependencies and blockers increase as we scale

Process blockers

The road to dependency hell is paved with good intentions. Without a clear vision of how to work it is easy to add layers of approvals and sign-offs that solve an immediate problem but hurt innovation and create a long term drag on the system.

We add task separation and sign offs that slow down delivery.

Technical blockers

With one team working on a code base there are no risks of conflict and there is no bottleneck for releasing. But as we add more teams we introduce dependencies between them. These dependencies add overhead and can lead to cascading delays.

Multiple branches leads to merge hell, unnecessary dependencies and release bottlenecks.

We've always worked this way!

Why change now?
Because contexts change

Customers demands are increasing faster and AI is making software easier to build. If we don't start removing dependencies and blockers our increase in changes will grind the system to a halt.

Bureaucracy overload.
Things that used to work well start breaking as you scale. But the solutions slow down delivery. More process, more approvals, more meetings.
Cascading delays.
Everyone sharing the same code base introduces dependencies between teams. Once one team is delayed it causes delays for all of the other teams.
Technical debt.
With each project focusing on their immediate deadlines the long term health of the code base suffers, making it harder to add new features in the future.