A website left alone keeps working. The server serves the same files, the browser renders them, and nothing underneath changes in a way that breaks it.
Mobile apps do not behave like this, and teams who budget for an app the way they budget for a website are surprised in year two.
Why apps degrade
Four forces, all outside your control.
Annual OS releases. iOS and Android ship major versions every year, with API deprecations, behaviour changes and new permission models. Something that worked last year may behave differently or stop entirely.
Store policy changes. Both stores update their requirements regularly — privacy declarations, account deletion, permission justifications, target SDK versions. Non-compliance means your update is rejected, and eventually the app can be removed.
Required SDK targets. Google enforces a minimum target API level, raised annually. An app below it cannot be updated and eventually cannot be discovered by new users. Apple applies similar pressure through build requirements.
Dependency rot. The libraries your app depends on get updated, abandoned, or found to have vulnerabilities. A dependency unmaintained for three years becomes a liability rather than a convenience.
None of these are things you can decline.
What maintenance actually involves
OS compatibility updates. Testing against each new iOS and Android release, usually in beta before public launch, and fixing what breaks.
Dependency updates. Keeping libraries current, which is far easier incrementally than in one jump after two years.
Store compliance. Privacy manifests, declarations, permission justifications, target SDK bumps.
Crash fixing. Real devices produce crashes your testing did not. These need monitoring and addressing.
Backend compatibility. If your API changes, old app versions still in use must keep working or be forced to update gracefully.
Certificate and credential renewal. Signing certificates, push notification keys, API credentials — all expire, and an expired push certificate silently stops notifications.
Security patching. Vulnerabilities in dependencies need addressing promptly.
What it costs
Rather than a figure, the useful framing is a proportion: budget a meaningful percentage of the original build cost annually, every year the app is in use.
The variables:
- Complexity. More features, more integrations, more to break.
- Dependency count. Every third-party library is a maintenance commitment.
- Platform coverage. Two native codebases cost roughly twice one cross-platform codebase to maintain.
- Backend coupling. An app tied to a changing API needs more attention.
- User base size. More users means more device variety and more crash reports.
The important point is that this is recurring and non-optional, not a contingency you might not need.
What happens if you skip it
The sequence is predictable:
Year one. Mostly fine. Minor issues on the newest OS version, affecting a small share of users.
Year two. Crashes on current devices. Some features stop working. Store warns about target SDK. Negative reviews mention bugs.
Year three. Cannot submit updates without substantial work. Features relying on deprecated APIs are broken. The app may be hidden from new users. Dependencies have moved so far that upgrading is a project rather than a task.
Year four. Effectively a rebuild. The accumulated gap between your dependencies and current versions is too large to bridge incrementally, and nobody on the team remembers how it works.
This is the trap: deferred maintenance does not stay deferred at a constant cost. It compounds, and the cost of catching up grows faster than the cost of keeping up.
The minimum
If budget is genuinely constrained, these are not optional:
Crash reporting. Sentry, Crashlytics or similar. Without it you learn about problems from one-star reviews, which is both late and public.
Annual OS compatibility testing. At minimum, test against each new iOS and Android release and fix what breaks.
Target SDK compliance. Keep up with the minimum, because falling behind eventually blocks updates entirely.
Security updates. Patch vulnerable dependencies promptly.
That is the floor. Below it, the app has a predictable end date.
Reducing the burden
Decisions at build time that lower ongoing cost:
Fewer dependencies. Each one is a commitment. A library imported for one function is rarely worth it.
Prefer well-maintained libraries. Check commit frequency, issue response and release history before adopting. A popular library with no commits for two years is a future problem.
Cross-platform over two native codebases, where the app does not need native. One codebase to maintain rather than two.
Automated tests on critical paths, so an OS update that breaks something is caught by CI rather than by users.
Feature flags, so a problematic feature can be disabled without shipping an update and waiting for review.
Documentation. Architecture, build process, credentials, deployment. Maintenance by someone who did not build it is far cheaper when documented.
Arranging it
Three common models:
Retainer. A fixed monthly amount covering monitoring, updates and a set number of hours. Predictable for both parties and the most common arrangement.
Annual block. A chunk of work each year covering OS compatibility and dependency updates. Cheaper, with a slower response to urgent issues.
Ad hoc. Call someone when it breaks. Lowest commitment, highest cost per incident, and it tends to mean problems are found by users.
Whichever you choose, agree it before launch. Negotiating maintenance after something has broken is a worse position for everyone.
The honest advice
If you cannot budget for maintenance, reconsider whether you need an app.
A mobile website requires far less ongoing work and does not have a predictable expiry date. An app built and abandoned is money spent on something that will stop working, generate negative reviews and eventually embarrass the brand.
That is not an argument against apps. It is an argument for counting the real cost before committing, which includes several years of keeping it alive.
If you have an app that has fallen behind and want an assessment of what catching up would involve, get in touch.
