Back to all posts
Android7 min read·November 1, 2026

How to Keep App Progress When Android Closes the App

TB
ThynkBlox Apps Team
App Engineering

If your Android app loses progress when switching apps, plan recovery around saved drafts and restorable screens. Android can end a background app process, so keeping unfinished work only in memory is not enough. Android's process lifecycle documentation explains that the system can end cached background processes when it needs memory. Save permitted progress as users work, then restore it after checking their account and the latest data.

What should “resume where I left off” mean?

Define the promise for each important journey. Returning to a blank home screen after writing a long description feels different from losing a search filter.

For a booking form, the promise might be: restore the selected service, entered notes and current step, then check availability again. For a purchase, it might mean restoring the basket while confirming prices and payment status.

Separate three kinds of state:

StateRecommended recovery
Unfinished workRestore a saved draft
Screen and navigationReopen the relevant step using saved references
Current business informationFetch again and explain any changes
Sensitive inputAsk for it again where required

Agree on these rules while mapping mobile app user flows. Recovery belongs in the journey design, including the messages users see when something cannot be restored.

How should the app save unfinished drafts?

Treat valuable unfinished work as a draft with its own identity and owner. Decide which fields belong in it, when it expires and how the user discards it.

Save permitted edits during the journey. Do not wait for the user to finish or close the journey before saving. Android's activity lifecycle guidance explains that the system can end the app's process while the user is away, and recommends saving persistent data at suitable moments while the app is in use.

Ask the development team to define the save boundary. If saving happens after a pause in typing, an interruption before that save may lose recent input. The interface should show “Saved” only after the relevant write succeeds.

Choose where the draft belongs:

  • On the device: for recovery on that installation.
  • In the account: when users should continue elsewhere.
  • In both places: when offline editing and later syncing are required.

These are product choices with different failure cases. A device save and an account save should have distinct status messages. Use the offline data and sync planning guide to define pending changes, retries and conflicts.

How should the app restore the right screen?

Restore a meaningful destination, not a frozen picture of the old interface.

Save the draft reference, relevant record references and the current step. Add selected tabs, filters or scroll position where they help users continue.

For lightweight screen state, Android provides saved-state mechanisms intended to support recreation after system-initiated process death. Android's guidance on saving UI state says saved state is for small, simple values and is not long-term storage; data you cannot lose belongs in persistent storage such as a database.

Plan restoration in a clear order:

  1. Establish which account is active.
  2. Load the draft that account may access.
  3. Refresh information needed for the next action.
  4. Open the appropriate step.
  5. Explain anything that changed.

If a selected item is no longer available, keep the user's notes and ask them to choose again. If a record was deleted, show a useful explanation and a safe destination.

Also check the Back action. A restored form should lead somewhere sensible when users leave it.

What should happen when the session has expired?

Keep draft recovery separate from permission to submit.

If the session has expired, ask the user to sign in again before accessing protected information or sending the draft. Once sign-in succeeds, return them to the intended step where access is still allowed.

Define what happens if they choose a different account. A draft belonging to one account should not appear in another account's workspace. Explicit sign-out should follow a documented rule for clearing or retaining local drafts.

Use a clear message: “Sign in again to continue your saved draft.” Only promise this when the draft is available.

After sign-in, recheck anything the final action depends on. A recovered screen should not imply that old availability, permissions or payment status remain valid. The guide to storing login tokens securely covers the related credential decisions.

Which fields should stay unsaved?

Use an explicit list of fields allowed in a draft. Avoid saving every form field automatically.

For this recovery feature, exclude passwords, one-time codes and payment verification codes. Ask users to enter them again when needed. Do not copy authentication credentials into draft records.

Review free-text fields and attachments too. A support message, health note or identity document may contain sensitive information even when it is labelled simply “Details”.

For each sensitive field, decide:

  • Whether retaining it is necessary.
  • Where it may be stored and who may access it.
  • When it should be removed.
  • What sign-out, account changes and shared-device use should do.

These decisions should also shape the interface. If a field will not be restored, explain that before the user relies on recovery. Avoid including draft contents in diagnostic reports.

What would a complete recovery flow look like?

Consider an illustrative service-request flow. The user selects a service, writes a description and reaches the review screen. They switch apps before submitting.

The proposed behaviour is:

  • Save the permitted description and service reference as a draft.
  • Record that the user reached review.
  • Restore the draft after the app starts again.
  • Check sign-in and whether the service remains available.
  • Display the review screen with any required corrections.
  • Request any excluded sensitive input again.

Now consider an interruption immediately after Submit. The recovery flow should check whether the request was already accepted before offering another submission.

Ask for a duplicate-prevention design that covers retries and interrupted responses. Restoring the draft alone does not answer whether the original action completed.

How do you test process death rather than ordinary backgrounding?

Switching away and returning proves only that the app handled that particular interruption. The process may have stayed alive.

Likewise, recreating a screen and ending the whole process are different events. Android's saved-state guidance notes that some in-memory screen data survives recreation but is lost when the system ends the process, so a recreation test alone does not prove recovery.

Ask for a test that backgrounds the app, terminates its process under conditions that allow system restoration, and then returns through the recent-apps entry. Record the original process identity and verify that recovery runs in a new process.

Keep force-stop and removing the app from the recent apps screen as separate scenarios. Android treats these as the user dismissing the app, and the same guidance says saved screen state is cleared in those cases.

Use this acceptance checklist:

  • Ordinary backgrounding preserves the expected progress.
  • Confirmed process death restores permitted, successfully saved fields.
  • The restored step and Back action work.
  • Expired sign-in returns the user to the draft after authentication.
  • Switching accounts does not reveal another account's draft.
  • Offline recovery gives an accurate save and sync status.
  • Removed or changed records produce a useful recovery message.
  • Sensitive fields remain empty.
  • An interrupted submission does not create a duplicate.
  • Save failures never produce a false “Saved” message.

Add these cases to the Android release testing plan.

Which common mistakes should you avoid?

Saving only the screen number. Reopening the review step is useless if its fields are empty.

Keeping the only draft in memory. That leaves recovery dependent on the process surviving.

Restoring stale decisions. Recover the user's intent, then recheck information that controls the next action.

Treating every closure alike. Document separate expectations for background process death, explicit sign-out, task removal and force-stop.

Promising recovery without limits. Explain whether drafts survive reinstalling, changing devices or choosing Discard. Include each promised behaviour in testing.

What else do product owners ask about restoring progress?

Should every screen return exactly as it was?

No. Prioritise unfinished work and the next useful action. A refreshed status screen may be appropriate, while an interrupted application form needs its saved inputs.

Does every draft need an account backup?

No. Choose account backup when continuing across devices is part of the promise. Device-only drafts need clear limits so users know where their work is available.

Should the app submit a restored draft automatically?

Require a deliberate confirmation unless the journey explicitly supports automatic submission. Recovery should help users continue and give them a chance to review changed information.

Ready when you are

Planning an app of your own?

Tell us where your project is today. We will help you work out the scope before you commit to a budget.