Your app does not break on launch day. It breaks six months later, on its own, if nobody maintains it.
+300
Projects delivered
15+
Years of experience
100%
Senior team
Every year, iOS and Android ship new versions that break apps nobody has touched: deprecated APIs, changing permissions, tightening store requirements (minimum target SDK on Google Play, App Store deadlines). Add dependencies that stop being maintained, expiring certificates and new devices your UI was never tested on. Maintenance is not an extra: it is the difference between an app that ages well and one that disappears from the stores.
Dribba offers mobile app maintenance and evolution — Flutter, native iOS, native Android and React Native — with a defined SLA, real-time crash monitoring and a senior team that can also take over apps we did not build, after a technical audit.
As a market rule, maintaining an app costs 15–20% of its development cost per year: a €60,000 app needs a €9,000–12,000/year maintenance budget. Below that, what accumulates is not savings — it is technical debt.
Indicative plans
| Essential | Standard | Evolutionary | |
|---|---|---|---|
| Best for | Stable apps with little change | Production apps with active users | Products in active growth |
| New iOS/Android compatibility | Yes | Yes | Yes |
| Dependency and SDK updates | Quarterly | Monthly | Continuous |
| Crash monitoring and alerts | Yes | Yes (with response SLA) | Yes (with response SLA) |
| Bug fixing | Hour bank | Included with priority | Included with priority |
| Store compliance | Yes | Yes | Yes |
| Improvements and new features | — | Hour bank | Monthly product roadmap |
| Indicative annual cost | From €6,000 | €9,000–15,000 | From €18,000 |
Indicative ranges for mid-sized apps. The exact budget depends on app size, stack and code health — we assess it in an initial audit.
Complete guide
A mobile app is not a project with an end date: it is a living product in an environment that changes every few months. Apple and Google ship major OS versions every year, the stores tighten requirements continuously, and the library ecosystem moves at a pace that turns a «finished» app into a fragile one within two or three cycles. This guide covers what a good maintenance contract includes, what it really costs, and the signals that yours is not working.
Nobody touches the code and the app still fails. The usual causes: every iOS and Android version deprecates APIs and changes behaviour (permissions, background execution, notifications); Google Play enforces a recent target SDK — apps that do not update lose the ability to publish and even visibility on new devices; dependencies get abandoned (the payments library or maps plugin that stopped being maintained and now blocks every other update); and signing certificates and profiles expire. Each of these fronts is routine if someone watches it — and a fire if nobody does.
The pattern we see most in audits: an app that ran perfectly for a year without maintenance suddenly needs €15,000 of urgent clean-up because the mandatory target SDK update drags a chain of broken dependencies. Regular maintenance exists precisely so that snowball never forms.
The industry standard places maintenance between 15% and 20% of the initial development cost per year: 2–4 compatibility updates a year, continuous dependency management, monitoring and a buffer for bugs. A €40,000 app → €6,000–8,000/year; a €100,000 one → €15,000–20,000/year.
What makes maintenance cheaper: a single cross-platform codebase (maintaining Flutter costs less than two native apps), clean architecture with tests, CI/CD automating releases, and a conservative dependency stack. What makes it more expensive: two native codebases, legacy integrations, exotic dependencies and — costliest of all — undocumented inherited code from a provider who no longer answers.
Corrective is fixing what breaks: reported bugs, crashes caught by monitoring, failures after an OS update. Preventive is keeping it from breaking: updating dependencies before they block, adapting the app to iOS/Android betas before public release, watching store notices. Evolutionary is improving the product: new features, conversion optimisation, A/B testing — the boundary where maintenance becomes product growth.
A healthy contract always covers the first two and sizes the third to the product's stage. The usual trap in cheap contracts: they only cover corrective work, so every «unforeseen event» is billed apart — and in mobile those are not unforeseen, they are Apple and Google's annual calendar.
New iOS versions catch you by surprise instead of being tested before public release. Bugs take weeks to resolve with no SLA limiting it. Your app keeps getting slower and nobody can tell you why. Your provider will not give you access to the repository or store accounts — a sign of lock-in, not service. Or simply: your app has not shipped an update in over six months. Any one of these justifies a second opinion; several at once justify switching providers.
Everything starts with a technical audit: we do not take over code we have not seen. With the diagnosis, we define the plan and SLA, set up (or clean up) CI/CD and crash monitoring, and from there the cycle is predictable: compatibility updates aligned with Apple and Google's calendar, dependencies kept current, monthly reports with stability metrics and an evolution budget sized to your stage. A 100% senior team in Barcelona and Andorra — the same engineers who build the projects in our portfolio. Maintenance is never subcontracted or handed to junior profiles.
If your app needs a technical owner, tell us about it: initial audit with a fixed quote and an honest diagnosis — even if the conclusion is that you do not need to change anything.
Related services
Frequently asked questions
The market rule is 15–20% of the development cost per year: an app that cost €60,000 needs €9,000–12,000/year. At Dribba, plans start at €6,000/year for stable apps and scale with SLA, update frequency and included evolution hours. The tier breakdown is in the table on this page.
Three things, in this order: first it degrades (crashes on new OS versions, deprecated libraries, security warnings); then the stores penalise it — Google Play requires a recent target SDK and blocks updates of outdated apps, and Apple removes apps that stop updating; and finally the cost of reviving it far exceeds what maintaining it would have cost.
Yes — it is one of our most frequent cases: apps whose original provider disappeared or stopped delivering. The process starts with a technical audit (architecture, debt, security, dependency health) that tells us whether the code is maintainable as-is, needs prior clean-up, or whether a partial rebuild is more cost-effective. With the diagnosis, you get a fixed quote and an orderly handover.
The non-negotiables: compatibility with every new iOS and Android version, dependency and SDK updates, crash monitoring with alerts, bug fixing and compliance with the changing App Store and Google Play requirements (target SDK, privacy, permissions). Depending on the plan, evolution hours are added for improvements and features with a monthly roadmap.
We work with renewable annual contracts and no hidden lock-in: the code and store accounts are yours from day one, and if you decide to switch providers, the handover is documented. The relationship holds because of the service, not the lock-in.
Have a project in mind?
No commitment, no small print. An honest assessment of your idea with the team that will build it.