“[Public Organization X] wasted X billion [currency units Y] on the Z software project!”
Every manager in software purchasing organization I’ve talked with is nowadays aware of the pitfalls of buying software. And what I’ve heard would suggest the headlines are all about public companies only because private companies do not want to disclose their biggest blunders.
So buying software development seems to be really hard to do right. It does not matter if you are the CEO of a new startup or a business executive of a major company. Companies are trying old and new ways of buying software development in a more cost-effective way.
Usual tactics involve setting an acceptable, i.e. quite low, hourly rate for contracting, sending RFPs to several vendors and asking for bargains. The ineffectiveness of these tactics have, however, frustrated companies. Even the largest companies with muscle to strong-arm the cheapest deals from vendors have been left disappointed with contractors that have failed to produce working software by the agreed deadline. The penalty payments they receive from these failures stop short on covering the costs of missing the chosen time to market.
So companies both big and small are now looking at outsourcing for more options for decreasing costs related to software contracting. They feel they have to consider that option for the lack of others, even though there is a considerable chance all of the risks I mentioned above will affect also outsourced software contracting.
Let me offer another way to be effective about buying software development work.
Our one-step guide: Invest aggressively in the changeability of the software
Changeability of software is a property of software closely related to software quality properties. Changeability of software means how easy it is to modify the software. Traditional software quality literature talks about maintainability, but for me changeability is a more telling term. We discover new needs the software product could meet every day and if we cannot change the software to meet those needs easily, we are screwed.
Why is changeability of software a key element in being cost-effective?
Software development has, as a discipline, struggled long and hard with the concept of change. Intuitively it would seem that changing software is easy compared to other kind of construction work as there are no material costs. Very early on, though, programmers have noted that if we change our minds every day about what the software should do, we end up wasting a lot of time building software that has no use anymore and then modifying that for the new imagined use.
That experience led to the rise of traditional software development discipline, which some call the waterfall model. In waterfall, you try to minimize waste created by changing our minds on the requirements by making changing requirements very hard.
In the last 15 or 20 years though, we have became increasingly sceptical about the assumption that we could specify what kind of software we need before we start building it. It has been found out that the act of building software is a continuous discovery process where we come up with a more clear picture of more and more fitting solution for the problem we want to solve as we go on. In fact, we even get a better picture about the problem itself.
<p class="videoframe"> <iframe class="full" src="http://www.youtube.com/embed/502ILHjX9EE?rel=0&start=458&end=&autoplay=0" frameborder="0" allowfullscreen></iframe> </p>
Because of this discovery process it is inevitable that the software will evolve iteratively during the development. That is why it is essential to optimize the process of building software for changeability. That way we can be confident that we can change the software being built when we learn with the least necessary effort and cost.
Another thing to consider is how the lifetime costs of software are distributed. The initial development costs of software are only 4 - 40 % of the total lifetime costs. Most of the costs occur when the software is in production and it is maintained and developed further.
And that statistic is true with software that is typically of poor quality and of poor changeability. Which leads to massive rewrites of code or replacing a system with a new one to have better changeability. For easily changeable software, this divide may be even more drastic. If you are certain you can keep on developing the software more, you can settle on a smaller scope at publishing time. That moves the emphasis even more to the latter part of the software lifespan.
This, coupled with the fact that software changeability determines how much maintenance and further development will cost, makes changeability focus a no-brainer. The only exception for this are software products with very short lifespan. Which are not normally a problem in terms of cost-effectiveness anyhow.
How to find a contractor worth working with
But how to find companies who can produce truly changeable software? That really is a topic for another blog post. Luckily, I have covered that in my talk “Technical Excellence: Why does it not stick, even now?” at Agile By Example 2013 in Warsaw.
<p class="videoframe"> <iframe class="full" src="http://www.youtube.com/embed/a_gU6ZxzH28?rel=0" frameborder="0" allowfullscreen></iframe> </p>
In short, my experience of this is that like with other quality attributes, changeability of the software cannot be ensured by process policies or target metrics, contractual terms or product backlog prioritization techniques. The most influential factor in whether a contractor can produce highly changeable code is his or her intrinsic motivation to do that. That means that as a buyer you need to find the reliable partners that really believe changeability of software is most important part of the programmer’s work.
Of course, the contractor must also have the understanding and skill needed to make changeable software, but when the motivation to do that is there, the understanding is there too and the amount of skill is only a matter of time to learn.
If you are looking for a contractor that really strives to keep all the software it develops easily changeable, we can help! Please contact us or leave a comment below.