For years, memory optimization on Android was often an afterthought, addressed only when applications began to falter or crash on lower-end devices. However, this reactive approach is becoming increasingly untenable. In August 2026, Google Play announced new performance requirements that will reshape how developers approach memory management. These requirements, which encompass dynamic memory usage, bitmap memory, and DEX code optimization, will be enforced starting February 2027. Applications that exceed these thresholds risk diminished visibility and publishing capabilities on the platform.
What Google Play is actually measuring
Google’s new guidelines dissect memory into distinct categories rather than presenting it as a singular heap-size figure.
1. Dynamic memory usage
This metric is defined as the sum of anonymous RSS and swap, essentially capturing the private memory utilized by the application. It includes active and compressed memory while excluding file-backed data such as code and assets. Google Play will assess this across various application states and device performance categories.
2. Bitmap memory
Google is particularly focused on whether applications retain bitmaps that are no longer visible. While it is acceptable to keep a large image in memory while it is displayed, retaining multiple images after the application transitions to the background presents a different challenge.
3. DEX optimization
To comply with Google’s standards, apps distributed through Play must achieve at least 25% coverage in optimization, shrinking, and obfuscation using tools like R8. This optimization is linked to a reduced memory footprint, quicker startup times, fewer application not responding (ANR) incidents, and enhanced runtime performance.
Note: It is crucial to understand that these measurements are contextual. A single memory figure from a developer’s device provides limited insight into how an application performs across varying RAM capacities, process states, and user interactions.
Why memory problems are difficult to reproduce
Consider a media-rich application. A developer launches it on a high-end device, scrolls through a feed, opens a detail screen, and returns. Memory usage climbs from 180 MB to 260 MB, then settles at 210 MB post-garbage collection. No crashes occur, and the app maintains its speed.
Now, imagine a different scenario: a user spends 40 minutes in the app, navigating through multiple image-heavy screens, sending it to the background, and returning via a notification. Alternatively, this sequence might occur on a device with only 4 GB of RAM instead of 12 GB.
Temporary memory growth is expected. Loading screens and decoding images naturally lead to brief spikes in memory usage. However, if repeated navigation causes the baseline memory usage to rise from 200 MB to 230 MB, then 260 MB, it suggests that some objects may be held longer than necessary. This pattern is often more revealing than isolated peaks.
Investigating memory growth
To investigate memory issues effectively, developers can utilize Android Studio’s Memory Profiler. Instead of immediately searching for the largest object in the heap, it is advisable to replicate a specific user flow multiple times to gauge memory optimization. For instance:
- Monitor memory changes after each iteration and following garbage collection.
- If memory consistently rises during a specific flow and then stabilizes, it likely indicates temporary allocations.
- If the baseline continues to increase, a heap dump should be taken.
Should the dump reveal multiple instances of a Fragment that should have been destroyed, the key question shifts from how much memory those objects consume to what they retain.
A Fragment may retain its view hierarchy, which can include an ImageView that references a decoded bitmap. This scenario illustrates how a seemingly minor lifecycle leak can keep several megabytes of image memory allocated. Understanding reference paths becomes more critical than merely counting raw objects.
Android Studio Quail 2 now integrates LeakCanary directly into the Profiler, streamlining the investigation of lifecycle-related leaks. For broader analyses, Perfetto can provide system-level context when a heap dump alone is insufficient. Each tool serves a unique purpose: profiling reveals when memory increases, a heap dump clarifies what remains allocated, and a system trace offers context about the application and system activities at that moment.
An example investigation: the gallery that never quite disappears
Imagine an image gallery built with Jetpack Compose. Users swipe through high-resolution images, close the gallery, and continue browsing. While QA reports no crashes, repeated gallery sessions lead to a gradual increase in memory consumption.
The initial assumption might be that the image loader’s cache is the culprit. Disabling caching reduces memory growth but does not eliminate it entirely. A heap dump taken after closing the gallery reveals that an object tied to the gallery remains reachable. Tracing the reference chain uncovers a long-lived component holding a callback created by the screen, which captures state that ultimately references the gallery’s image data.
Resolving this issue requires adjusting the ownership or lifecycle of that callback, rather than merely reducing cache size. This distinction is vital, as cache tuning may mask a leak without addressing it. The application might exhibit lower memory usage during a brief test while still retaining objects indefinitely during extended sessions.
A thorough investigation should thus progress from behavior to ownership: identify a repeatable flow, determine if the baseline memory grows, inspect retained objects, and only then decide on necessary changes.
Bitmap memory deserves its own investigation
Images warrant special consideration, as their compressed file size does not accurately reflect their runtime cost. A JPEG that occupies a few hundred kilobytes on disk can demand several megabytes once decoded. Bitmap memory is influenced by pixel dimensions and format, not merely the size of the downloaded file.
A common error is decoding images at a resolution larger than required for the UI. A 4000 × 3000 image does not need to maintain that resolution for a small thumbnail display.
While modern image-loading libraries manage much of this process, teams must still grasp their configuration and caching behaviors. Google recommends downsampling images to the dimensions needed by the UI. Current guidance suggests Kotlin-first and Compose projects utilize Coil, while Glide remains a popular option for Java-based applications.
Retaining a large bitmap while it is visible is generally acceptable, but keeping it after the screen disappears—or while the application is in a cached process state—requires scrutiny.
Move memory checks before production
The Play Console and Android vitals will soon provide valuable real-world memory metrics. Google is introducing dynamic-memory and bitmap-memory metrics categorized by percentile and RAM bucket, along with OOM-related termination filtering, DEX optimization insights, and proactive alerts when applications exceed the new thresholds.
However, production telemetry should serve as a final line of defense, not the initial detection method. Teams should establish several representative memory scenarios for each release candidate: cold launch and idle, navigation through high-traffic flows, image-heavy flows, repeated navigation into and out of complex screens, and transitions from foreground to background.
The key is repeatability. The same flow should be executed on consistent device categories or emulator configurations to enable comparisons with previous builds.
For instance, if a checkout flow typically stabilizes around 170–190 MB after completion, and a new build settles around 240 MB, this regression warrants investigation, even if both figures remain below platform thresholds.
Bonus read: Android App Development Trends
Build a memory budget instead of waiting for an OOM
Teams may establish a baseline after startup, an acceptable peak during the opening of a media-heavy screen, and an expected post-navigation baseline after that screen is closed. These numbers should be derived from measurements across representative device categories rather than copied from other applications.
This approach also prevents indiscriminate optimization of every allocation. If memory temporarily rises during a complex operation and returns to baseline, there may be no issue to address. Conversely, if a release consistently adds 30 MB of retained memory with each repetition of a common flow, this should be examined long before an OOM occurs.
Over time, these checks can evolve into part of performance regression testing. Continuous integration (CI) does not need to automatically diagnose leaks; even detecting that a benchmarked flow now consumes significantly more memory than its established baseline provides engineers with a reason to scrutinize the build before release.
A short pre-release memory checklist:
- Run critical user flows repeatedly and compare the post-flow baseline, not just the peak.
- Test on devices beyond just high-memory flagship models.
- Take a heap dump when memory remains elevated and analyze retention paths.
- Examine image dimensions, decoding configurations, and caching behaviors on bitmap-heavy screens.
- Evaluate transitions between foreground, background, and cached states.
- Review R8 optimization rather than assuming that enabling R8 guarantees optimal application performance.
- Compare memory measurements with previous releases and investigate significant regressions.
- Monitor Android vitals and Play Console warnings instead of waiting for user-reported OOM crashes.
As Google Play prepares to enforce its new requirements in February 2027, this shift represents more than just a deadline; it signifies a conceptual transformation. Memory should be treated as a critical metric to measure prior to release, rather than solely investigating it post-OOM. By establishing known baselines for important flows and identifying regressions before production, the Play Console can serve as an additional signal rather than the initial point of discovery for issues.
