The adage “Many hands make light work” is something we often take for granted. If we get a lot of people working together on a particular task, we can quickly knock it out. Think of stocking shelves as an example. The more people you have, the quicker you can unload a truck and get the shelves restocked – as long as everyone knows where the goods are supposed to go.
But in software, the idea that “many hands make light work” doesn’t hold up. In almost all cases, many hands – at best – make a timeline something achievable. But the many hands will not make the work light.
Why is this?
It’s very simple. Writing software doesn’t require much in the way of developer effort.
Consider the typical homework assignment for a college programming class. There’s not a lot of code being written. In this case, many hands wouldn’t accelerate what needs to be done. There’s not enough work to go around.
But if you scale up a project (such as enterprise software), we have a lot of work to do and not a lot of time to get it all done. While multiple developers reduce the timeline, the burden on each developer stays consistent.
For really large projects, the approach is usually the same: having more developers means more timeline reduction. But, the amount of work required for the overall project increases with each developer added.
This increase happens for two main reasons.
The first and most apparent burden is caused by the need for more communication. With more people involved, the reliance on communication grows. This requires project managers to track all the work that is currently being done and what work still lies ahead. Someone has to “project” where this project will go.
The second burden on the project is design. With many developers in the mix, you can’t just turn people loose and assume work will get done. One of the key values of a design is the ability to scale your development team. With a good design, it is easier to understand how the components of a system will interact. We can put developers to work on independent components where they can work without having to wait on others.
The concept of “many hands make light work” is something we often take for granted; it’s usually quite obvious. Ironically, the opposite is true in the software development world. Many hands may get the work done sooner, but that’s about it.
With software, more hands means more work. It’s not about each developer taking a smaller portion of the work. When you increase the number of developers working on the same product, more planning is required – and this involves more roles to manage that planning. So if you know your project will involve multiple developers, make sure you have a great project manager and do enough upfront planning. Because when you do, the likelihood of success goes up.