When Should Your App Stop Supporting Older Android Versions?
Decide when to drop support for older Android versions by weighing three things: who would lose access, which dependencies limit your options, and whether you can keep essential functions safe and reliable. Raise the minimum version when maintaining the older versions is no longer a responsible choice, with a clear transition for affected users. There is no universal cutoff that fits every app.
What does dropping support actually mean?
Define the change before deciding whether to make it. “Unsupported” could mean no new features, no further app updates, or an end to access altogether. Those are different promises.
Your decision should state:
- Which Android versions will stop receiving new app releases.
- Whether the last compatible app release can continue connecting to your service.
- Which essential functions, if any, will remain available.
- How users can retrieve their information or move to another supported option.
Avoid announcing only that “older devices are no longer supported”. Tell users what will happen when they next open, update or reinstall the app, based on behaviour you have verified.
How are minimum and target Android versions different?
The minimum Android version sets the oldest operating system on which a particular app release can be installed. The target version declares the Android version whose platform behaviour the app is designed to work with. Raising the target does not, by itself, mean raising the minimum. See the official uses-sdk reference.
This distinction matters when someone says an update “requires newer Android”. Ask whether the requirement comes from distribution rules, a dependency, a feature or a deliberate product decision.
Review current Google Play requirements separately from your support policy. Google Play sets target API level requirements that affect both submission and availability.
Use the Google Play release checklist to plan the wider release, while keeping the minimum-version decision explicit.
Which affected users should influence the decision?
Start with people who still use the app, rather than everyone who has ever installed it. Choose a review period that matches your product: a daily work app and an occasional booking app need different definitions of active use.
Look at affected users by operating system, app release and essential activity. Ask whether they can complete the job they came to do, whether they have information stored only on the device, and whether a practical alternative exists.
Do not reduce the decision to a single count. A small group may depend on the app for an essential task. A larger group may have a straightforward way to continue elsewhere.
Where usage information is incomplete, record that uncertainty. Check relevant support requests and gather focused feedback before treating missing activity as proof that nobody depends on the older version.
Which dependency constraints justify a higher minimum?
Review the components needed for essential functions, including sign-in, payments, storage, notifications and communication with your service.
For each proposed update, ask:
- Does it actually require a higher minimum Android version?
- Is the component essential to the app’s core purpose?
- Can its current version still be maintained responsibly?
- Is a supported alternative practical?
- Could an optional feature be unavailable on older versions while core functions remain usable?
Some dependency releases specify their own minimum Android requirements. Check the exact release documentation rather than assuming every update forces the same change.
Separate a hard constraint from a preference. A simpler build is useful, but weigh that benefit against the disruption to users. Equally, do not keep an essential component indefinitely without a credible maintenance plan.
Can older versions still provide safe functionality?
Make this a decision about specific user actions. Review signing in, viewing private information, saving changes and completing any transaction the app supports.
For each action, ask whether the team can verify correct behaviour, maintain necessary protections and explain failures clearly. Include the service the app connects to: keeping an old app available is not a complete plan if its requests will soon stop working.
An older Android version alone is not enough evidence to declare every installation unsafe. Identify the actual limitation and the functions it affects.
If an essential function cannot be maintained safely, do not leave it available merely to avoid a difficult announcement. Consider restricting that function while preserving a verified route to view or retrieve information.
How should you compare the available choices?
Use a short decision record that connects evidence to an action.
| Evidence to review | Question to resolve | Possible response |
|---|---|---|
| Users still completing essential tasks | What would losing access prevent them from doing? | Continue support or provide a longer transition |
| An essential dependency requires a newer version | Can you maintain or replace it responsibly? | Raise the minimum if no suitable alternative exists |
| An optional feature needs newer capabilities | Can the core app remain useful without it? | Limit that feature on older versions |
| An essential function cannot be maintained safely | Can access be narrowed without putting users at risk? | Restrict the function and provide a transition |
| Little reliable usage information exists | What evidence is missing? | Gather evidence before setting a cutoff |
Illustrative example: an app uses a newer component for an optional scanning feature. If manual entry remains usable and testable, the team could consider keeping manual entry available on older versions. If the constraint instead affects essential sign-in, that option may not solve the problem.
The decision follows the affected function and available evidence, rather than the age of the operating system alone.
What compatibility testing should happen before release?
Verify both the proposed supported range and the experience of users outside it. Android compatibility also involves declared hardware and software features, so operating system version alone does not establish device compatibility. See the official device compatibility overview.
Use this checklist:
- Test installation and core tasks on the oldest version you intend to support.
- Test updates from the app releases users currently have.
- Check representative screen sizes, device capabilities and network conditions.
- Confirm what the last compatible release can still do.
- Test messages shown when a function or service becomes unavailable.
- Verify any data retrieval or alternative access route you promise.
Our guide to testing an Android app before release covers planning checks around real user tasks.
What should you tell existing users?
Explain the practical effect in plain language. Name the affected Android versions, say what will stop working or receiving updates, and describe the next step.
Distinguish an app update from an operating system update. Only recommend either as a solution when you have checked that it addresses the user’s situation.
Provide notice through channels affected users can actually reach. Do not rely solely on a message inside a new app release that they cannot install.
Where appropriate, consider:
- Continued use of a maintained, last compatible release.
- A supported browser experience, if one exists.
- A tested way to export or retrieve information.
- Help moving to another supported device.
- Clear handling of paid access affected by the change.
Choose only options you can deliver. Never promise indefinite access to an older release without a maintenance plan.
What common mistakes should you avoid?
Choosing a cutoff because a version sounds old. Establish the user impact and technical constraint first.
Confusing target and minimum versions. Confirm which setting or requirement creates the restriction.
Treating installation as proof of support. Include the services and essential actions the installed app depends on.
Assuming everyone can upgrade their phone. Give affected users a practical route where possible.
Keeping an old release available without ownership. Assign responsibility for testing, support and deciding when continued access must end.
Build the review into your ongoing app maintenance after launch, rather than waiting until a release is blocked.
What are the frequently asked questions?
Should every app support the same Android versions?
No. Set the supported range using your users, essential functions, dependencies and maintenance capacity. Record why the chosen range fits your app.
Will raising the minimum version remove an app already installed?
Android blocks installing a release on a device whose version is below that release's minimum, so those devices cannot take the new update. Whether the release they already have remains useful depends on its functionality and continued service compatibility.
Can you keep an older release working without adding features?
Consider it only if you can maintain and test the functions that remain available. State the limits clearly and review that arrangement as dependencies and services change.
When is the decision ready?
When you can explain who is affected, the constraint driving the change, the options considered, the testing completed and the transition offered. That is a stronger basis than choosing a universal cutoff.