Mobile app size — why it grows and how to reduce it

The app grew from 25 MB to 180 MB, although nobody planned it. How size affects installs and uninstalls, what the store limits are, where the extra weight in old apps comes from, how to measure it, and what slimming it down costs.

Zespół Mobilesoft· Engineering team· 22 listopada 2026· 8 min czytania

The first version of the app was 25 MB. Four years and three teams later, it's 180 MB. Nobody decided to make it bigger. Everyone added something small: another analytics SDK, an animation on the welcome screen, a font family, a library for a single feature that was later removed — while the library stayed.

App size is rarely a priority, because it doesn't show up in bug reports. Yet it affects how many people install the app and how many delete it when their phone runs out of space. In this article we describe how to check what makes up the size of an existing app, what can usually be removed safely, and how much it costs.

Why size matters

  • Install conversion. Google published an analysis showing that for every extra 6 MB of app size, the share of people who complete the install from the store page drops by 1% on average. That's 2017 data and an average across all apps, not a promise for yours, but the direction is clear. Users on slow connections and cheap phones feel it most.
  • Downloading over mobile data. On Google Play, users on mobile data see a notice about the app's size when it's larger than 200 MB. On iOS, the default "Ask If Over 200 MB" setting does the same. Some people then postpone the install "until later".
  • No space left on the phone. When storage runs low, the system and the user look for something to delete. Phone settings list apps sorted by the space they take up, so the biggest go first. Play Console even shows what share of your users have less than 2 GB of free space.
  • Updates. A bigger app means bigger updates and more people staying on an old version — which then makes API changes harder and forces you to keep old backend versions running.

Download size vs installed size

These are two different numbers, and it's worth keeping them apart:

What it means Where to check Download size How much data the user downloads from the store (compressed, tailored to the specific device) Play Console: Android vitals → App size and the app bundle explorer; App Store Connect: file sizes for a TestFlight build Installed size How much space the app takes up once unpacked The same tools, plus the App Thinning Size Report from Xcode App data Cache, downloaded files, the local database — grow over time Phone settings, testing on a device after a few weeks of use

The third row is often overlooked. An app can weigh 40 MB and take up 2 GB six months later, because the image cache has no limit or downloaded files are never deleted. For the user, it's the same "heavy app". If you're adding offline mode, plan limits and cleanup of local data from the start.

Store limits

As of November 2026:

Store Limit Notes Google Play — base module 500 MB (compressed size) Above 200 MB, a notice for users on mobile data Google Play — all install-time content 4 GB Larger assets via Play Asset Delivery (packs downloaded later or on demand) Google Play — publishing as APK 100 MB The legacy publishing method; new apps have had to use Android App Bundles since 2021 App Store — download over mobile data 200 MB Above that, a prompt for consent (default setting, the user can change it)

The limits are rarely a problem for typical business apps. The problem starts much earlier: at 80–150 MB the app is simply heavier than its competitors, and nothing flags it.

Where the extra size in old apps comes from

What we most often find in taken-over projects:

Source Typical example How to fix Code shrinking disabled on Android R8 and shrinkResources turned off "because something broke" Turn them on, add keep rules, test Unused SDKs Three analytics tools, an ad SDK after ads were switched off, a chat library with no chat Remove from the code and dependencies Images and video in the package Full-resolution PNGs, a video on the welcome screen, illustrations in several copies WebP/AVIF, vector graphics, video downloaded from the server Fonts and animations Full font families with a dozen weights, large Lottie files Keep only the weights in use, simplify animations Translations from libraries Resources in 80 languages, although the app supports two Limit languages in the build configuration Native libraries Large C/C++ libraries (e.g. for PDF, imaging, ML) for every architecture Android App Bundle instead of a universal APK, lighter alternatives Models and offline data An ML model, a map, a product database in the install package Download after install, only when needed

The first row requires care. R8 removes unused classes and shortens class names — and in older apps some code is called indirectly, for example by reflection-based JSON parsers. After turning R8 on without keep rules, the app may build fine and only crash on a specific screen. That's why it's a change for a separate release, with the whole app tested. The mapping file (mapping.txt) then has to be uploaded to your monitoring tool, otherwise crash reports become unreadable.

The second row ties into other maintenance topics. Every SDK means not just megabytes, but also updates and deprecation deadlines, licences and data sent to third parties that has to be declared in the stores. Before you remove an analytics tool, check whether anyone actually uses its data — we write about which data is really needed in our article on app analytics.

How to measure it

Before you remove anything, check what takes up the space. Tools per platform:

  • Android: APK Analyzer in Android Studio (opens a built package and shows the size of every directory, library and resource) and the app bundle explorer in Play Console, which shows the download size for different devices.
  • iOS: the App Thinning Size Report generated when exporting an archive in Xcode, and after uploading a build — the size table in App Store Connect for different device models.
  • Flutter: flutter build apk --analyze-size (and its iOS equivalent), visualised in DevTools.
  • React Native: the same native tools plus an analysis of the JavaScript bundle. Hermes, the default engine since version 0.70, usually reduces size on Android compared with the older JavaScriptCore — for an app that hasn't been updated in years, that's one more argument for updating the framework.

The result of the analysis is usually a list of five to ten items that account for most of the size. That's where the work starts.

Order of work

  1. Measurement and a list of the biggest components. Without it, it's easy to spend a day compressing icons that take up 300 KB.
  2. Quick, safe changes. Compressing images, removing unused resources, limiting languages, moving to Android App Bundles if the app doesn't use them yet.
  3. Removing unnecessary SDKs. Needs agreement with the business side, but often gives the most.
  4. Turning on R8 and resource shrinking — as a separate release, with regression tests and a staged rollout.
  5. Moving large assets out of the package. Downloading from your server or using the stores' mechanisms: Play Asset Delivery on Android and Background Assets on iOS. Apple has announced that the older On-Demand Resources mechanism will be deprecated, so new solutions are best built on Background Assets.
  6. A check in CI. The pipeline records the size of every build and warns when it grows by more than an agreed threshold. It's a few hours of work if releases are already automated, and the only way not to end up back where you started two years from now.

A smaller app often also starts faster, because it loads less code and initialises fewer SDKs. If that's your main problem, see our article on why an app is slow.

How much it costs

Scope Estimated effort At PLN 180 net per hour Measuring and analysing size, a list of the biggest components 4–8 h approx. PLN 0.7k–1.4k Quick fixes: images, resources, languages, App Bundle 8–24 h approx. PLN 1.4k–4.3k Removing or replacing unnecessary SDKs 16–40 h approx. PLN 2.9k–7.2k Turning on R8 in an old app, with rules and tests 16–40 h approx. PLN 2.9k–7.2k Moving large assets to post-install download 24–80 h approx. PLN 4.3k–14.4k Size check in CI 4–8 h approx. PLN 0.7k–1.4k

The figures are estimates and depend on the state of the code, the number of dependencies and whether the app has tests. The rate is an example — we set the actual cost after reviewing the project. In practice, the first three rows usually deliver most of the effect.

Summary

App size grows quietly, with every SDK and every image added "for now". Start by measuring and listing the few biggest components, then make the quick fixes and remove SDKs nobody uses. Ship risky changes, such as turning on R8, separately and with tests. Finally, add a size check to CI so the problem doesn't come back. And don't forget the data the app accumulates on the phone — what matters to the user is the total space taken, not the size shown in the store.

We put app size and dependencies in order as part of our mobile app maintenance service, and during a mobile app takeover it's one of the items in the first review. If you want to know which libraries and SDKs your app contains and which are out of date, order a free app analysis or contact us.