There's a very common and very understandable idea: once a website or an app launches, the work is “done”. You've put in time and money, the product works, users are coming in. It looks like the end of the road.
It's actually the beginning. A digital product isn't an object you build once and leave sitting still; it's a living thing that coexists with an environment changing constantly around it.
What changes around you (even if you touch nothing)
Even if you don't change a single line of your product, the world it lives in does. New versions of iOS and Android come out. Browsers update. New phone models appear with different screens. Regulations change. The third-party services you rely on update their terms or their technology.
Your product was built for the environment that existed on launch day. With each of those external changes, the gap between “how it's built” and “how it should be built today” grows a little wider.
What maintaining really involves
Maintaining a product isn't waiting for something to break and then fixing it. It's continuous work and, largely, preventive:
Security updates. Vulnerabilities are discovered constantly. Keeping the software and its components up to date is what stops one of those doors from being left open.
Compatibility. Making sure it keeps working properly on the new operating systems, browsers and devices that keep appearing.
Dependency management. Almost every product relies on external libraries. Keeping them updated, and watching the ones that stop being maintained, is part of the job.
Bug fixing. Some faults only show up over time, with real use, with data volumes that didn't exist at the start.
What happens when you don't
Not maintaining a product doesn't cause an immediate problem. That's exactly the risk: for months it looks like nothing's wrong, until something is.
The first thing is usually vulnerabilities: outdated components with known security holes that turn your product into an easy target. Then comes degradation: an app that starts failing on newer phones, a website that looks broken on the latest browser version, features that stop behaving as they should. And in the end, almost always, the cost: fixing something that hasn't been touched in two years is far more expensive than looking after it along the way, because you have to rebuild ground that's gone fragile.
Preventing costs less than repairing (an example)
Picture two identical products launched on the same day. One gets quiet but steady maintenance: small updates every few weeks, dependencies kept current, faults fixed as soon as they appear. The other is left as it is, because “it works”.
Two years on, the first still runs normally and any changes it needs are small and cheap. The second needs a big intervention: updating years of accumulated dependencies all at once, resolving incompatibilities that have piled up and, often, rewriting whole parts. The total cost isn't just higher, it lands all at once and at the worst moment, usually when something has already broken.
Maintenance is part of the real cost
The conclusion is simple, even if it isn't always spelled out: the price of a digital product isn't only what it costs to build, but what it costs to keep alive. Just as a car needs servicing, a product in production needs regular care to stay secure, fast and reliable.
Seeing it that way changes how you plan: maintenance stops being a surprise expense and becomes a foreseen, manageable part of the budget.
At Liquid we don't see a launch as a finish line, but as the start of a longer relationship. We build products, yes, but we also stay alongside the people running them so they work just as well two years from now as they did on day one.
