Short answer
A maintenance SLA for an AI-built or AI-powered app should define severity levels with response and resolution targets, cover iOS, Android and dependency updates, handle model and API changes explicitly, and keep code, accounts and credentials in your hands. The most common gaps are store policy changes, third-party model deprecations and unclear ownership of the developer accounts.
On this page
Why AI apps need a different maintenance contract
Classic app maintenance contracts were written for apps whose behaviour changed only when someone shipped new code. AI-built and AI-powered apps break that assumption in two ways.
First, apps produced with agentic coding tools or AI app builders often reach production faster than their documentation, tests and architecture mature. The maintainer inherits a codebase that works but has thin safety nets. Second, apps that call language models depend on external services that change on someone else's schedule: models are deprecated, prices change, output formats shift slightly and prompts that worked last quarter start drifting.
A good SLA acknowledges both. It does not just promise "bug fixes within X hours", it defines who watches for change, who tests against it and who pays for adaptation.
The core building blocks of the SLA
Severity levels with measurable targets
Define three or four severity levels and attach both a response target (someone acknowledges and starts work) and a target for restoring service. Response is easy to promise, restoration is what matters to the business.
| Severity | Example | Typical response | Restoration target |
|---|---|---|---|
| Critical | App crashes on launch, login broken, payment flow down | Within business hours: 1 to 2 hours | Workaround same day |
| High | Core feature broken for a user segment, AI feature returns errors | Same business day | 1 to 3 business days |
| Medium | Non-core feature broken, visual defects on one device class | 2 business days | Next planned release |
| Low | Cosmetic issues, wording | Next planning cycle | Backlog |
These numbers are orientation, not a market benchmark. Agree on them based on how the app is used. A field-service app used at 6 am needs different coverage hours than an internal reporting tool.
Coverage hours and channels
State the hours in which the targets apply, the time zone, holidays, and the channel for reporting (ticket system, not a chat message to an individual). If you need weekend coverage for critical incidents, write it down explicitly and expect it to cost more.
Platform and dependency updates
This is the clause most often missing. Apple and Google release new OS versions every year, Google Play raises its target API level requirement regularly, and Xcode versions required for submission move forward. The SLA should say:
- The provider tests the app against new OS betas before public release
- Target API level and SDK updates are included up to an agreed effort, with anything beyond quoted separately
- Security updates for dependencies are applied within a defined window after disclosure
- Expiring certificates, provisioning profiles and push keys are monitored
AI-specific clauses
For apps with AI features, add clauses that classic contracts never needed:
- Model lifecycle: who monitors deprecation notices from the model provider, and how much lead time triggers a migration task.
- Regression evaluation: a fixed set of test prompts and expected behaviours that is run before switching models or changing prompts.
- Cost guardrails: alerts when token usage or API spend exceeds an agreed threshold, and who may raise limits.
- Output incidents: a definition of when a wrong or harmful AI output counts as an incident, and the response (for example disabling a feature flag within a set time).
- Data handling: what user data may be sent to which model provider, and that any change requires your approval.
Ownership and exit terms
Maintenance contracts fail most painfully at the end. Protect yourself with clear terms:
- Code ownership: full source code in a repository you own, with the provider working in it, not delivering zip files.
- Accounts: Apple Developer, Google Play Console, cloud and model provider accounts belong to your organisation. The provider gets role-based access. Our guide on developer accounts for companies explains how to set that up.
- Documentation duty: architecture notes, runbooks and an up-to-date AGENTS.md or CLAUDE.md so that any competent team, human or agent assisted, can take over.
- Handover period: a defined transition effort if you change provider.
Pricing models and what they mean
Most maintenance agreements use one of three models. A retainer with a fixed monthly hour budget suits apps with steady change. A base fee for monitoring and updates plus hourly billing for changes suits stable apps. A pure per-incident model is rarely a good fit, because nobody is paid to do the preventive work that avoids incidents.
At apprat.io maintenance combines AI-assisted development with human developer hours: agents handle routine work such as dependency bumps, test scaffolding and first-pass bug analysis, and people take responsibility for review, releases and judgement calls. That mix keeps the hour budget focused on decisions rather than boilerplate. For larger organisations with formal procurement and SLAs, OnlineAppCreator provides done-for-you engineering for B2B and B2G clients.
A checklist before you sign
- Are severity levels defined with examples from your app?
- Are coverage hours, time zone and reporting channel written down?
- Is the annual OS and store requirements cycle explicitly included or priced?
- Are model deprecations and prompt regressions covered?
- Do you own all accounts, keys and the repository?
- Is there a monthly report with incidents, updates and upcoming risks?
- Is store submission work included, or handled by a partner such as appsubmitter.io?
- Is there a handover clause?
Signs your current arrangement is not working
You find out about OS incompatibilities from user reviews. Releases stall because nobody can find the signing certificate. AI costs jump and nobody noticed until the invoice. Every change request starts with "we first need to understand the code again". If any of these sound familiar, the gap is usually not effort but missing structure. Our article on maintaining an AI-built app after launch covers the operational side in more depth, and if the codebase itself is the problem, start with a rescue of the vibe-coded app.
apprat.io can take over maintenance of apps built with Lovable, Base44, Claude Code, Codex or traditional stacks, starting with an assessment of the codebase and the store accounts so the SLA is based on facts.
FAQ
What is a reasonable response time for app maintenance?
For critical incidents during agreed hours, one to two hours for a first response is common. More important is the restoration target and whether it applies outside office hours. Match it to how the app is actually used.
Are iOS and Android updates included in maintenance?
They should be, at least up to an agreed effort per year. Annual OS releases and Google Play target API requirements are predictable, so leaving them out of the contract only moves the cost into surprise change requests.
How do we handle AI model deprecations in an SLA?
Name a responsible party for monitoring provider announcements, define a lead time for migration, and require a regression evaluation with fixed test cases before switching. Budget the migration effort as part of the retainer.
Should the provider own our App Store account?
No. Your organisation should own the developer accounts and grant the provider access. That keeps the app, its reviews and its history with you if you change provider.