Managing complexity is the lot of software engineers. Programmers make choices that impact the cost of everything that follows.
It costs significantly less to write perfect software than to write software of dubious quality. It may cost more initially in terms of time and resources, but your teams will save several times that cost if they get the code right from the start.
The people who make up your software teams are the linchpin of your projects. That’s why continuous improvement for teams and continuous learning for people are the best investments you can make. When your teams don’t have what they need to function efficiently, success becomes less likely.
These are the top efficiency killers for your software teams:
1: No product market fit
It doesn’t matter how efficient or effective your software organization is if you don’t have product market fit. What you produce is only as valuable as your market makes it.
2: Poor quality
Errors in the code cause not just bad customer experiences but rework for the team, which increases labor costs and takes the team away from further progress in building the system.
And an absence of trustable automated tests makes it expensive and risky to make changes to simplify the code, which makes the team move even slower.
3: Cost of change
Unless you take deliberate steps to reduce complexity, adding to a code base naturally increases that complexity. This makes it more and more time-consuming, and therefore expensive, to make subsequent changes to the code. Pressure from stakeholders or management to move on quickly to the next task drives teams to skip the refactoring steps needed to keep the cost of change low.
The effects of this aren’t always detected when they happen, and the ultimate effect is to make system changes unaffordable, and to rob teams of the bandwidth they need to correct the trouble they’ve gotten into. For a small software company, the ability (or lack thereof) to control runaway cost of change can mean life or death.
4: Bad team dynamics
A dysfunctional team can’t function well – it’s that simple. Hiring for qualities that make people good teammates, giving teams time to get through the “forming-storming-norming-performing” curve, and keeping well-functioning teams together for the long term leads to better-performing organizations.
Organizations can make the mistake of inadequately staffing one or more roles as they define development processes that involve handoffs from one role to another as code moves toward production.
Quality assurance is a frequent victim here. Some organizations set up their teams in such a way that multiple teams depend on the output of other teams, which may not be able to deliver all the things the downstream teams need in a timely fashion. The whole organization is only as fast as the slowest bottleneck along the value chain.
6: Manual, repetitive work
In software, there’s no such thing as standard work. If your team finds any, it must quickly be automated out of existence. Repetitive manual work is error-prone and expensive, and manual processes don’t scale as your system does.
Deployments, system patches and other manual work can quickly eat up time that a team doesn’t have to spare.
7: Unneeded complexity
When it takes a long time to edit, build, test and deploy software, that slows progress. Slow automated tests, written using end-to-end testing tools, adds to a team’s cycle time. So do manual testing, long deployment processes, and code review processes inserted in the middle of the edit-to-deploy cycle.
These days, it’s all about reducing complexity. But organizations need to remember what weakens or even destroys the efficient development of software. The strength, health and cohesion of your teams are what will make or break your projects. People don’t necessarily need to be 100% qualified according to the specified job requirements to succeed in a role -many of those requirements can be taught along the way.
Thinking in terms of soft skills – communication, collaboration and so on – when hiring will help build stronger teams. Providing ongoing training will also help. Keep the seven efficiency killers discussed above top of mind as you create a more efficient and effective software engineering cohort.
About the Author:
Susan Davis is CTO of Certn