Our app maintenance and support plan starts on launch day and runs on a fixed monthly calendar. You get a two-week handover, scheduled OS and dependency updates, crash monitoring, written response times and a monthly report. The code, accounts and credentials stay in your name, so you can leave whenever you want.
This post walks through each step. For each one, we cover what happens, what you receive, how long it takes and how much of your team's time it uses. If you worry the agency will disappear once the invoice clears, this is how we prevent that.
Why an app decays even if nobody touches it
An app that nobody changes still breaks. The platforms, libraries and devices around it change every few months. Each change can cause crashes, store rejections or security gaps.
Three forces do most of the damage:
- Store rules. Google Play requires new apps and updates to target an Android API level within one year of the latest major Android release. If you miss it, you cannot ship a bug fix until you upgrade.
- Toolchain minimums. Apple sets a minimum Xcode and SDK version for uploads and usually raises it once a year. An app that has not been built in 18 months often needs a day or more of upgrade work before it compiles.
- Vulnerable dependencies. A typical React Native or Flutter app pulls in hundreds of indirect packages. Some will show up in security advisories. A few may appear in CISA's Known Exploited Vulnerabilities catalog, which lists flaws attackers are already using.
The trade-off is simple. Small, regular updates cost a few hours a month. Skipping them for a year typically turns into a multi-week upgrade project, done under pressure when a store deadline or a breach forces it.
You get the same predictability from the first week when you see how a project with us runs before committing to anything.
How our app maintenance and support plan runs, step by step
The plan has five parts. The first two happen once. The last three repeat for as long as you keep the plan.
Step 1: Handover and access check (weeks 1–2)
First, we confirm that everything lives in accounts you own. That covers the Apple Developer and Google Play accounts, the cloud project, the domain, the Git repository and the error-tracking tool.
You receive:
- An access register listing every system, who has admin rights and where the credentials are stored.
- A runbook covering deploys, rollbacks, environment variables and how to rotate secrets.
- Architecture notes short enough to read in 30 minutes.
Your time: typically two to four hours, mostly granting access and reviewing the register.
Step 2: Baseline audit (week 3)
We record where the app stands on day one, so later reports have something to compare against. We list OS targets, SDK versions and outdated dependencies. We also record the crash-free session rate, API error rate and backup status.
You receive a short written baseline and a ranked list of risks. Each risk carries an effort estimate in hours. You decide what to fix now and what to schedule.
Your time: one 45-minute call to agree on priorities.
Step 3: The monthly cycle
Every month follows the same pattern, so nothing depends on someone remembering. In the first week we apply minor and patch updates to dependencies, run the test suite and ship to an internal track. In the second week we review crash and error trends, fix the top issues and prepare a release.
We use tools such as Sentry or Firebase Crashlytics for crash data. Dependabot or Renovate raise dependency updates automatically. Major version upgrades go into the backlog with an estimate rather than shipping unannounced.
You receive a one-page monthly report. It covers what changed, what shipped, hours used, open risks and what is planned next month.
Your time: 30 minutes to read the report, plus release approval if your plan requires it.
Step 4: Quarterly platform work
Once a quarter we look further ahead. We check upcoming iOS and Android releases, store policy changes and expiring certificates or push-notification keys. We also check end-of-life notices for your backend runtime.
We test each new major OS version on beta builds before public release, usually between June and September. That gives you weeks, not days, to fix what breaks.
Your time: a 60-minute quarterly review, where we agree on the next quarter's larger items.
Step 5: Incidents
When something breaks in production, you report it in a shared channel or ticket system. Often our monitoring catches it first. We rank it by severity, then fix it or roll it back.
For anything at severity 1 or 2, we write a short post-incident note. It covers what happened, the root cause, the fix and what we changed to stop it recurring. No blame, no padding.
Response times we put in writing
These are our default targets. We adjust them per contract, and they are agreed in writing before you sign.
- Severity 1: app down, payments failing or data exposed. Acknowledged within one hour and worked on continuously until fixed or rolled back. Out-of-hours cover is part of the plan if you need it.
- Severity 2: a core feature broken for many users. Acknowledged within four business hours, with a fix targeted within two business days.
- Severity 3: a bug with a workaround. Acknowledged the next business day and fixed in the next release.
- Severity 4: cosmetic issues and small requests. Scheduled into the monthly cycle.
Acknowledgement means a named engineer has looked at the issue and replied. An auto-responder does not count.
Three plan levels and how to choose
Most clients fit one of three levels. The right one depends on how much the app changes and what an hour of downtime costs you.
Keep-alive
- For stable apps with little new feature work.
- Typically 8 to 15 hours a month, covering updates, monitoring, store compliance and severity 1–2 incidents.
- Trade-off: new features are quoted separately, so small requests wait.
Standard
- For apps with active users and regular small changes.
- Typically 20 to 40 hours a month, including minor features and every severity level.
- Trade-off: larger features still need a separate estimate.
Active development
- For products that are still growing and have a roadmap.
- A small dedicated team, often one to three engineers part time, running two-week sprints with maintenance built in.
- Trade-off: the highest monthly cost, but no separate upgrade projects.
A common rule of thumb is that yearly maintenance costs 15 to 20 percent of the original build. Treat that as a rough starting point. A simple content app can sit well below it, while an app with payments, integrations and compliance needs often sits above it.
On most plans, unused hours roll over for one month. After that they expire, which keeps both sides honest about planning.
What happens if you want to leave
The best protection against abandonment is not needing us. Everything we produce is set up so another team can take over.
- The code lives in your repository from day one, not ours.
- Store accounts, cloud billing and domains are in your company's name.
- We update the runbook and access register every quarter.
- Notice is 30 days, and we hand over the same way we took over.
If we have done the job well, a new team should be productive within a week or two. If they are not, our documentation failed, and we would want to know.
FAQ
What does an app maintenance plan usually include?
At minimum, it covers OS and SDK updates, dependency patching, crash monitoring, store compliance and bug fixes. Better plans also include written response times, a monthly report and a quarterly look at upcoming platform changes.
How much does app maintenance cost per year?
A common estimate is 15 to 20 percent of the original build cost per year, but the range is wide. Apps with payments, healthcare data or many integrations usually cost more to keep current than simple content apps.
Can you maintain an app another agency built?
Yes. We start with the same handover and baseline audit, which typically takes two to four weeks for an inherited codebase. If the code needs major upgrades first, we estimate that work separately before the monthly plan begins.



