Lorixen.
EN

Forcing users onto a new app version: soft prompt or hard block

Short answer: Default to a soft prompt and save the hard block for the rare release where an old version would break, lose data or expose users. Build the logic around a "minimum supported version" your app reads from a server or remote config at startup, so you can raise it later without shipping anything. On Android, Google Play's in-app updates API gives you a flexible (background) and an immediate (full-screen) flow; on iOS you compare versions yourself and send people to your App Store page.

Every app eventually ships a change the old versions can't handle: a new API, a changed payment flow, a security fix. The question isn't whether to have an update mechanism, it's how firm to be. Too soft and your backend carries five old versions forever. Too hard and you lock out a customer standing at your counter with a phone that hasn't updated in months.

The decision tree

Work through this for each release you're tempted to force.

1. Will the old version stop working or cause harm once this release is live? (For example: the API it calls is being removed, it sends malformed orders, or there's a security issue.)

  • No → go to 2.
  • Yes → go to 3.

2. Is there something users would genuinely want in the new version?

  • No (bug fixes, small polish) → do nothing in-app. Let normal store updates take care of it.
  • Yes (a new feature, better performance) → soft prompt: a dismissible banner or Android's flexible update. Show it once, then not again for several days.

3. Can you keep the old behavior running on the server for a few weeks?

  • Yes → soft prompt now, hard block later. Announce it, prompt for two to four weeks, then raise the minimum version.
  • No → go to 4.

4. Is the risk to users or data serious (security, payments, data loss)?

  • Yes → hard block now: a full-screen "update required" screen with a single button to the store.
  • No → reconsider; you may be able to add a compatibility layer on the server instead of blocking anyone.

Most releases end at step 2. That's the point: a forced update is a cost you impose on every user, so it needs a real reason.

The building block: a minimum version you control remotely

Whatever the platform, the reliable pattern is the same:

  1. Your app knows its own version.
  2. At startup (and when returning from the background), it fetches two values: minimum_supported_version and latest_version, plus optional message text.
  3. If installed < minimum → hard block screen.
  4. If installed < latest → soft prompt, respecting a "don't show again for N days" rule.
  5. Otherwise → nothing.

Store those values somewhere you can change without a release. Firebase Remote Config is one example: Google's documentation describes changing app behavior and appearance with no need to publish an app update, targeting values by conditions including app version, and a client library that fetches and caches values while letting you control when they're activated. Your own backend endpoint works just as well.

Two details save pain later:

  • Fail open. If the fetch fails (no signal, server down), let the app run. Blocking everyone because your config server hiccupped is worse than the problem you were preventing.
  • Compare versions properly. "1.10.0" is newer than "1.9.3". Compare numeric parts, not strings, or use build numbers.

Android: the in-app updates API

Google Play's in-app updates feature is part of the Play Core libraries. As of November 2026, Android's documentation says it supports devices on Android 5.0 (API level 21) or higher, on phones, tablets and ChromeOS devices, and isn't compatible with apps using APK expansion (.obb) files.

It offers two flows:

Flow What the user sees Use it for
Flexible Background download while they keep using the app, then a prompt to restart Soft prompts, non-critical improvements
Immediate Full-screen flow; they must update and restart to continue Updates critical to core functionality

Two signals help you choose automatically:

  • Staleness: clientVersionStalenessDays() tells you how many days an update has been available. Google's own example waits a few days before a flexible prompt, then a few more before requiring an immediate update.
  • Priority: you can set inAppUpdatePriority from 0 (default) to 5 for a release through the Google Play Developer API, then read it in the app. Google's example strategy maps minor improvements to no prompt, performance work to flexible, and critical security fixes to immediate.

The API only knows what's on Play. It doesn't know about your backend's minimum version, so it makes sense to combine both: the Play API for the update flow, the remote minimum for the decision to block.

iOS: build the check yourself

There's no equivalent of Play's in-app update flow to call. The usual approach is the remote-minimum pattern above, with your own screens:

  • Soft prompt: a sheet or banner, "A new version is available," with "Update" (opens your App Store page) and "Not now".
  • Hard block: a full-screen view with a short reason and a single "Update" button. No close button, but a link to support or your website in case the store is unavailable to them.

Keep the App Store link and your store app ID in the config too, so the button never breaks.

Before you flip to a hard block

  • App review builds. Make sure the build you submit for review is at or above the minimum you plan to enforce, or a reviewer may hit your block screen.
  • Staged rollouts. If the new version is only reaching a percentage of users, don't raise the minimum until it's fully available everywhere, or people will be told to install an update they can't get yet.
  • Old devices. Check your oldest supported OS. Raising the minimum for users whose devices can't install the new version locks them out for good, so say so clearly on the block screen.
  • Message quality. "Update required to keep ordering — this version can no longer place orders" beats "Your version is not supported."
  • Measure first. Look at what share of active users are still on old versions in your analytics before deciding how firm to be.

FAQ

Will a hard block hurt my store ratings?

It can, if it's used often or arrives with no warning. Announced, rare, and explained blocks tend to cause far less friction.

Should the soft prompt appear every launch?

No. Show it once, then back off for several days. Repeated nagging trains people to dismiss without reading.

Do I need a backend for this?

You need somewhere to store the minimum version that you can change without a release. A remote config service or a tiny JSON file on your server both work.

Can Android users decline an immediate update?

The immediate flow is designed to require the update before continuing, but keep your own version check too; it's the one rule you fully control.

When you need an update path that keeps old app versions from breaking orders without locking people out, let's plan the version rules together.

Sources

WhatsAppLet’s talk