Most people believe software is produced like any other product:
There’s a project kick-off, followed by an implementation phase, and at the end, there’s the finished app or service. Developing the software product requires resources in the form of developers, and once they have been compensated for their effort, that’s it.
However, assuming our software project is a one-off investment can result in a very costly mistake.
Most businesses build software like a house. But software does not behave like things we can build. Software is more like a living thing. That’s why I like to compare software to plants.
A plant needs regular watering, pruning, and the occasional treatment for mildew. For instance, growing a plant into a tree requires time and continuous effort to keep it alive.
Keeping software alive also requires continuous effort.
One reason is that our software ecosystem evolves all the time. Let’s take open-source libraries, for instance:
Nowadays, software is built on top of popular open-source libraries and frameworks. This saves time and money during development (let’s not reinvent the wheel) and keeps licensing costs low (if not zero).
While the open-source community’s developers constantly improve and develop these open-source libraries, security experts regularly identify new security issues. And, of course, the open-source community fixes these issues.
If we don’t continuously update our application with the new library versions—if we don’t take care of our plant—we will soon have a weakened tree with brittle branches and a hollow trunk, silently waiting to fall and harm our users enjoying a picnic in the shadow.
To keep our software up-to-date and secure, we need to reserve a monthly budget for a few hours of maintenance—a “Parks and Recreation Budget” if we want to stick with the plant metaphor.
Understanding that software, in its nature, behaves more like a living plant that needs continuous care and less like a house that can be left alone for a few years is a critical step. But we shouldn’t beat ourselves up for not knowing. Most software developers have never heard about it, either. And many custom software development companies simply don’t care.
Often, software projects are treated as one-offs. All the focus is put on features and design. Aspects that reduce maintenance costs, like readable code or test and deployment automation, are often neglected.
That’s why we, as product owners, must insist that our developers produce a maintainable software solution. If they don’t, upgrades will become increasingly expensive over time.
If we let our application wither like a plant, fixing it might become impossible (or at least unprofitable). That’s when everyone screams for a rewrite of the software. That’s when the company goes out of business.
Remember to include maintenance costs in your budget plan and to pick developers who care about creating a maintainable software solution that can be kept up to date with little effort.
See you around,
David
P.S. Are you unhappy with the current state of your software? Get in touch, and let’s find out how I can help.