3 Ways Enterprise Architects Can Bridge the Socio-Technical Gap
09 August 2023
Request your demo of the Sigrid® | Software Assurance Platform:
22 June 2022
4 min read
We all know about the law of diminishing returns when it comes to software development, adding yet more developers to a team to increase output. However, software development houses have thought of creative workarounds to this problem: dividing work into smaller pieces, relying heavily on open-source software, or sub-contracting. All viable solutions and understandable from the market perspective over the last 10 years.
In the end, these solutions are all a variant of ‘If the only tool you have is a hammer…’, you know the rest. Ultimately they all throw more people at the problem in the hope that more hands mean more output.
However, this solution is seemingly coming to an end. Open up any noteworthy technology news outlet you’ll see headlines about how difficult it is to retain and hire talented IT workers. A tech shortage has been slowly building these past few years and by far the majority of the opinionated people out there will try to convince you about the solutions they propose.
When you look at some of the suggested solutions, all are geared towards being the first or providing a more attractive workplace or hiring young or offering more benefits, or going globally (As if there is nobody fishing in that local pond already?)… the list goes on.
Don’t get me wrong; some of these suggestions do impact the total body of technical skills out there. Better benefits might allow people to work part-time who otherwise might leave the marketplace. And the same can be said for offering flexible working arrangements. Still, the overarching theme remains geared at increasing the pool of hands that can do the work.
In the end, this will not be enough.
Our technical progress will outpace the speed with which we can get new people to the job market. So why not turn this around? Why are we not trying to limit the work that needs to be done? One thing that has amazed me over the last 10 years is that so few people have grasped the benefits of building quality software. The effect this has on the speed of development and what a single person/team can achieve is explosive.
I see that technical debt is a growing concern, and it’s estimated that 25% of IT budgets are spent on handling technical debt every year. If we know the problem, should you not invest in your future right now?
Stop building technical debt in the first place. Focus on building a good quality application that is less costly to maintain. If you are building something that your clients will use for years to come, focus on quality code. It will yield returns in both cost and speed that will dwarf the solution of just adding new developers to your team.
We already know that 80% of the application cost is in the maintenance phase of the life cycle. We also know that both the implementation of new functionality and the speed of fixing bugs is easily up to 25% faster in applications with only market average build quality versus those below. Furthermore, high-quality code systems require 3.5 times less effort (= cost) to maintain than low-quality systems. These numbers, especially in a market strapped for talent, should turn some heads and organizations should take the time to reflect: Are you really tackling the problem at hand?
Our industry needs to learn that ‘doing things the right way’ is a necessity that cannot be skipped over anymore. To stay competitive and deliver new features to your customers faster, your teams need to develop and solve problems quickly. This means building quality code.
Curious how to get that done? We might know a thing or two about this…
We'll keep you posted on the latest news, events, and publications.