One of the most important lessons to learn before setting out to build a technology-based business is that software is never finished - all software projects require ongoing maintenance, even when it appears that no new features are being added and you've finally reached "version 1".
Think of it like owning a car. You never just "buy a car" - you have to look after it and bring it in for regular servicing. If you're lucky you just need an oil change and a few new tyres. Sometimes you need new breaks. Other times you need body work to straighten out some dents. Owning a car requires constant oversight and attention.
Software is like owning a car … but worse.
Imagine you woke up one day and they'd changed the language of all road signs, or that everybody now drives on the other side of the road. Imagine your car now ran on ice cream, not petrol. Imagine they switched the colours of the traffic lights so that red meant go.
Due to the complex nature of modern software development and distribution, there are countless surprising ways that things can go wrong unexpectedly and through no fault of your own.
Here are just a few:
- Upgrades and patches. The machines hosting your software will need constant security updates, as will the dependencies and libraries in your own codebase.
- Bug fixes. Your code will never be free from bugs. As time goes on users will do things you never expected, uncovering surprising new bugs. These need to be tracked down, replicated and fixed.
- Dependency changes. Sometimes other pieces of code your application relies on disappear or change, potentially breaking your codebase without warning.
- Integration issues. Like dependencies, it's common for software to rely on other systems like external 3rd party APIs. These can change or disappear over night, requiring updates on your codebase.
- Hosting issues. There's no such thing as 100% uptime. Your hosting vendor is going to go down at some point and you may need to restore from backups or fix resulting problems.
- Technical debt. If you took shortcuts or made compromises early in the project, they may come back to haunt you.
- Scaling requirements. As your product grows, you may need to scale-up your infrastructure which can get complicated quickly.
- Compliance & regulation. Regardless of where you operate, new regulations like GDPR can be introduced, requiring you to update your application or codebase to remain compliant.
- Training. In bigger systems you're going to need to constantly train new members of staff in how to use the software.
- Documentation & knowledge transfer. Over time, original team members might leave, and new developers come on board. If proper documentation isn't maintained or if knowledge transfer isn't done effectively, there can be costs in terms of time and productivity.
So what can you do about this?
- Plan. Discuss this with your developer or CTO ahead of time and factor ongoing costs into your budget.
- Document. Make sure that there is some sort of documentation available for your codebase. It doesn't have to be perfect but it does have to exist
- Test. Ensure your developers are creating test suites for your software so that features can be easily verified as OK when code changes.
- Look ahead. Don't allow developers to pick trendy technologies that may disappear in a year. Choose trusted technologies that will be around for decades.
- Inform yourself. You may not be a developer yourself, but you should understand where everything is: who is your web host, where is the code base, who has access.