57 // journal

What app maintenance actually covers, itemized from our own schedule

guide · 2026-11 · 5 min read · clients · process · maintenance

journal/app-maintenance-schedule
What app maintenance actually covers, itemized from our own schedule

fig.01 · four lanes, one emergency exit

Every proposal for an app ends with a line like "maintenance plan available," and every client nods at it without knowing what they are agreeing to. That vagueness is expensive in both directions: clients pay for a word, and studios get blamed when the app breaks in a way nobody priced. So here is ours, itemized, with the cadences and the edges. If a studio's maintenance line cannot be broken down this way, it is not a plan.

The four lanes

The schedule splits into four lanes, each with its own clock, because the things that break an app break on different schedules.

OS and SDK testing. Apple and Google ship a major OS release every year, and each one arrives with a beta season. We test client apps against each major beta as it lands through the summer, so the app is already verified before the public release turns a breaking change into a live incident. Alongside the OS, both stores force an annual SDK bump: Play raises its target API floor each August, and Apple gates submissions on the latest SDK every spring. Missing either means your updates stop going out, which is exactly the kind of deadline we covered in the yearly update post.

Dependency and security updates. Everything under the app drifts: libraries, SDKs, the server stack, the payment provider's API. Dependencies get patched on a monthly cadence, and critical security advisories do not wait for the month; they get pulled forward as they land. The monthly part is hygiene, the out-of-cycle part is the difference between patched and exploited.

Monitoring and incident response. Crash reporting and uptime monitoring run continuously, not on a schedule. When something critical breaks, the commitment is same business day: acknowledged, triaged, and work started, not "we will look at it next sprint." The app stores add a second class of emergency, and the schedule has an explicit hotfix lane for it: a surprise store rejection on a routine update, or a critical bug in production, jumps the queue and ships through expedited review on the App Store, a resubmission fast-track on Play.

Store compliance upkeep. Both stores change their rules constantly: new declarations, new permission forms, new data-safety questions, age-rating questionnaires, privacy manifests. Someone has to watch them, answer them on time, and tell the client which ones actually require work. That someone is the maintenance plan. What this lane catches is paperwork until it is not: occasionally it is a real product change with a deadline attached.

What is not in it

Three boundaries make the honest version of the plan. New features and redesigns are not maintenance: adding a screen, changing a flow, or rebuilding a feature is scoped work with its own estimate, and a plan that quietly absorbs feature requests is a plan with a hidden hourly rate. Third-party outages are not ours to fix: when Stripe, Firebase, or a carrier goes down, we monitor it, confirm the blast radius, and advise the client, but we do not own the provider's recovery. And the warranty window is separate: after launch there is a fix-free period where defects in the delivered work get repaired at no charge, because a bug we shipped is not maintenance, it is ours.

How it is structured

The commercial shape is deliberately not a fixed tier. Every client gets the same four lanes and the same cadences; what varies is the surface area. An app with one screen and no backend needs the same kind of coverage as an app with payments and offline sync, but nowhere near the same amount of it, so the plan is sized to what the app actually runs rather than sold as small, medium, or large. The client sees the itemized list either way, which is the point of itemizing it: maintenance priced as a black box is how studios bill for doing nothing.

Our position

Maintenance is scope, not goodwill. An app is not finished when it ships; it is finished when someone owns the clocks that will break it: the OS betas, the dependency drift, the store rule changes, the 2 AM crash report. If a studio's plan cannot name its cadences and its exclusions, the real plan is "call us when it breaks and we will quote you," and that is a fine arrangement as long as everyone knows it is the arrangement. The worst version is the retainer that covers nothing specific, because it buys the feeling of coverage and none of the coverage.

The takeaway

Ask any studio, us included, these questions about the maintenance line:

LANES
os/sdk testing, dependency patches, monitoring,
store compliance; four different clocks, all named
CADENCES
betas tested as they land; deps monthly plus
out-of-cycle for critical; incidents same day
EMERGENCY
is there a hotfix lane for rejections and
production crashes, and what jumps the queue
EXCLUDED
new features and redesigns are scoped work;
third-party outages are monitored, not owned
WARRANTY
post-launch defects are fixed free inside the
warranty window; that is not maintenance
SHAPE
itemized lanes, sized to the app; a black-box
retainer with no list is a plan to bill, not cover

This schedule is what we run on the apps we ship in our custom software work, storefronts like Grain and Vine included. If your app's maintenance plan is a single line in an old proposal, send it to us and we will tell you what is missing.

// next step

We work this way on client projects too.

Tell us what you are making. We reply with a plan, a timeline, and a price.

← the journal