Every megabyte of a mobile app is paid for somewhere — in install time, in cellular data, in storage. Once an app crosses the 150 MB threshold Google Play uses as a soft warning, install completion drops and post-install uninstalls rise. Consumer apps now aim for under 40 MB; content-heavy and enterprise apps, under 60 MB.
What follows is the playbook teams use to keep large apps under control.
Why the Bundle Format Matters Most
The single most impactful change of the past five years was the move from monolithic APKs to Android App Bundles (AAB), mandatory for new Play Store apps since August 2021. The AAB format ships a manifest rather than a universal binary, and Google Play assembles a device-specific install on demand — only the CPU architecture, screen density, and language resources that device needs.
Industry measurements put the average reduction at 15 to 30 percent versus a universal APK. iOS has its own equivalent in App Thinning, with slicing and on-demand resources, achieving comparable results.
Code Shrinking and Obfuscation
Below the bundle level, compiled code is a major contributor. Modern Android builds run R8 (the successor to ProGuard) as part of the release pipeline: code shrinking removes unused classes and methods, resource shrinking strips unreferenced drawables and strings, and obfuscation renames symbols to shorter strings. Combined savings often run another 20 to 40 percent on top of AAB optimization, especially for apps with large third-party SDKs. Aggressive shrinking can strip code only invoked through reflection or dynamic loading, so teams maintain a keep-list for those cases.
Compressing the Heavyweight Assets
Images, fonts, and audio are usually the largest line item in an app’s storage budget. The techniques that move the needle:
- WebP for raster images — roughly 25 to 35 percent smaller than equivalent-quality PNG.
- Vector drawables for icons and simple UI graphics — a few KB regardless of display density.
- AVIF or HEIC for newer Android targets where supported, with further savings over WebP.
- Variable fonts instead of multiple weight files for design systems with several weights.
- Opus or AAC at appropriate bitrates for sound effects rather than uncompressed audio.
A casino lobby is a useful case study because it stacks all of these problems: thousands of game thumbnails, full-screen promotional banners, distinct UI assets for portrait and landscape, and audio for live dealer games. The mobile app for an operator like nvcasino online has to compress and stream that catalog while staying under the install-size threshold that decides whether a player finishes the download.
On-Demand Delivery: The Architectural Shift
Compression alone has diminishing returns. The bigger structural move is to deliver content only when needed, rather than packing everything into the initial install. Android offers two mechanisms most large apps now use.
Play Feature Delivery lets a developer modularize the app and deliver some features on demand. A user who never opens the “live chat support” or “VIP rewards” section never downloads those modules; the moment they tap, the module installs in the background. Play Asset Delivery handles large media through three modes: install-time, fast-follow (downloaded silently right after install), and on-demand. iOS provides analogous tooling via On-Demand Resources and Asset Catalogs.
Fast-follow has become the 2025–2026 default for large apps: a functional launch in seconds, with the deeper catalog populating in the background.
Measuring What’s Actually There
Before optimizing, teams measure. Two tools every Android team uses:
- APK Analyzer (built into Android Studio) shows the per-folder breakdown of the bundle by code, resources, native libraries, and assets.
- Bundletool generates the device-specific APKs Google Play would actually serve, so you measure the install size a real user receives rather than the upload size.
A rough comparison of where bytes typically go in a large media-heavy app:
|
Component |
Share of total size |
Optimization target |
|
Native libraries (ABI splits) |
20–35% |
AAB ABI splits, NDK strip |
|
Image and video assets |
20–40% |
WebP/AVIF, asset delivery |
|
Java/Kotlin bytecode |
10–20% |
R8 shrink + obfuscation |
|
Resources (XML, strings) |
5–15% |
Density splits, resource shrinking |
|
Third-party SDKs |
10–25% |
Audit, replace, lazy-load |
The exact distribution varies by app type, but the table makes the optimization order obvious: target the largest contributor first.
A Casino App as a Working Example
Real-money gambling apps illustrate the pattern well because they balance a content-heavy catalog with regulatory metadata, payment SDKs, and live-stream integration. A page like nv casino mobile app shows the public surface — a single download with a stated version number. The engineering behind it typically keeps the base APK under 50 MB through aggressive ABI and density splits, compresses game thumbnails and delivers them via fast-follow asset packs, and loads the live dealer module only when a player enters that section. The pattern generalizes to any large mobile app where the catalog grows over time.
Keeping the App Lean After Launch
Storage optimization isn’t a one-time project. Every release adds dependencies, every new feature ships assets, and every third-party SDK update tends to grow rather than shrink. Teams that hold the line treat install size as a tracked CI metric with a hard ceiling that fails the build, audit dependencies quarterly to remove or replace the largest contributors, and re-measure with Bundletool before every release so size regressions get caught before users notice. The discipline is unglamorous but compounds — every megabyte saved is one less reason a user uninstalls to free up space.
