In his book The Inmates Are Running The Asylum, Alan Cooper calls it a riddle for the digital age: What do you get when you cross a toaster with a computer? Industrial-age thinking would make you believe you have a smarter, more capable toaster. But, as Cooper writes, what you really get is a computer with heated bread slots. The nature of the toaster is so affected by digital technology that it no longer behaves like a mechanical object. Rather, it behaves like every other computer in our lives, albeit with the ability to toast bread.
Anyone who has used a microwave in the past 20 years will recognize this. I still wistfully recall the first microwave I owned. The entire interface was a handle and two dials – one for time and one for power. That microwave did everything I have ever needed a microwave to do and it was easier to use than any microwave I’ve owned since. These days most microwaves literally want their users to be computer programmers. The greatest advancement in microwaves in the past decade or so has been the addition of the “+30 sec” button. It’s effectively the “ignore the rest of the stupidly complicated interface and just heat up my food a little more” button.
This effect isn’t limited to simple kitchen gadgets or even physical products – adding software changes everything it touches. Adding software to what was once a completely human service? You haven’t just streamlined operations, you’ve changed the very nature of your business. And that goes not just for what you sell, but the company too.
Once you add software to your product or service you are now a software company.
You may have thought that sprinkling some software into the mix would make your product or service a little (or a lot) better, but now that you're operating a software business, you have a few more things to manage.
Software development is not a one-time project with a definitive end date. It's an ongoing investment that requires constant attention. This is the one thing that can’t be overstated for people who are familiar with running traditional service businesses or know hardware development, but are new to software. Once you add software to the mix, you are now a software company and software development is never done.
With hardware products, once a product is manufactured and shipped, its physical form remains unchanged until the next model or version. Software, on the other hand, is malleable and continually evolving. Software is much more like a living organism that requires constant care. Updates, patches, and new features are part of its lifecycle. User feedback, security vulnerabilities, and technological advancements necessitate ongoing development. Market demands shift, competitors release new features, and customer expectations grow.
To maintain relevance and provide value, a software company must be agile and ready to adapt its products continually.
Just as hardware components might rely on parts from different suppliers, software often depends on third-party code libraries or open-source projects. These dependencies can dramatically accelerate development and reduce costs by providing pre-built functionality. Although this is often the right decision (you generally don’t want to build commodity features from scratch so you can focus on your true differentiating features), leveraging third-party software also introduces risk.
Over time, code doesn't age like a fine wine. Dependencies may become outdated, unsupported, or pose security threats. Regular audits, updates, and sometimes complete overhauls are necessary to ensure that software remains secure and functional.
When you hear developers talk about “paying down technical debt” they aren’t just sandbagging. They are talking about legitimate work that needs to be done because third-party libraries, frameworks, or services can quickly become liabilities unless they are continually updated. Ignoring these updates can turn small problems into big ones. The longer you put off maintenance, the more complex and costly it becomes to get everything up to date.
It may be tempting to think you can simply take a snapshot of third-party code at a point in time, but when eventually do want to make updates to your product, it will be orders of magnitude more difficult if you haven’t kept up-to-date with the latest third-party dependencies.
Establishing processes for regular updates and anticipating the resource implications of maintaining third-party code isn’t particularly hard, but it requires someone to keep abreast of the continually changing technology landscape and how it affects your product.
Distributing software often relies on platforms like the Apple App Store, Google Play Store, or other third-party marketplaces. Unlike distribution of physical products that often depend on deals that you can negotiate directly, these platforms have blanket rules that you can’t negotiate and with strict guidelines and policies that can change over time. Compliance isn't a one-time hurdle but an ongoing concern. Failing to adhere can result in your software being removed from the platform.
Distribution platforms not only host your software but also impact your reputation and revenue. Policy changes can affect monetization strategies, data collection practices, or require additional features for accessibility and security. Staying compliant means regularly reviewing platform policies and updating your software accordingly.
Even if your codebase has been stable for years, a policy change might force you to make a minor change and resubmit your app to stay compliant. You may quickly find that staying compliant opens up a pandora’s box of updating your own code and third-party dependencies if you haven’t stayed current with their updates along the way.
To avoid those problems, you need to allocate resources to monitor policy changes and implement necessary updates promptly.
If you haven't touched your code for a couple of years or more, you may find that it's not even possible to build your project in its current state. Development environments change, compilers evolve, and what used to work may no longer be compatible with newer versions of the same tools. The simple task of making a small tweak to your software can suddenly involve a time-consuming overhaul just to create a development environment that allows you to build your project again.
Even just fixing a typo, which sounds insignificant on its face, may require getting your development environment up and running again. A change that would take 5 minutes normally can become days or weeks of troubleshooting if you haven't stayed up-to-date with your tools. This is even more complicated if the original team who did the work isn't available to help. Puzzling out how to get old code running written by someone else when it's been untouched for an extended period can be a time consuming (expensive) challenge.
A lot of companies believe their code is valuable. Although what software enables can be tremendously valuable, the code itself is a rapidly depreciating asset.
In some ways code is a lot more like a car than a long-term investment. It loses about 1/2 its value the moment you drive it off the lot. It needs to be maintained, repaired, and eventually replaced. If you ignore maintenance, repairs are needed more frequently and are more costly. If you skip repairs, you’ll have to replace the whole thing sooner, and that will likely need to happen because it breaks down in spectacular fashion at the most inopportune time. Even if you keep it perfectly maintained, eventually it will become outdated and you’ll want to replace it with something that’s current with modern standards for safety, efficiency, comfort, and design.
While you don’t want to over-invest in future-proofing software that may not need to last a lifetime, assuming you'll never have to touch your code again after an initial launch is an unrealistic expectation. Sometimes companies only contemplate the extreme outcomes: instant success or complete failure. It’s easy to imagine that you’ll have plenty of resources to reinvest back into the software if you’re an instant hit. And if the product completely fails… it’s not an issue. But what if you have marginal success, or a slow ramp after launch? How do you plan to maintain what your customers rely on?
As long as your product has users, you are a software company and you need to plan to maintain and improve your software over time. Do you need a partner to help navigate that journey? Uptech Studio is here to help!
