How to Reduce Your Mobile App's Download Size
To reduce your app's size, start by measuring what is actually inside it, then deal with the biggest items first. Most of the savings usually come from four places: heavy images, fonts and media, third-party SDKs you no longer need, the packaging format you publish in, and framework-specific extras in Flutter or React Native apps. Run the audit checklist below before each major release, so size problems get caught early instead of piling up.
Why does download size matter to a product owner?
Users decide whether to install while looking at a store listing, often on a limited data plan or a phone that is nearly full. A smaller download is quicker to install, less likely to be abandoned partway through, and less likely to be the first app deleted when storage runs low. Every update downloads again too, so extra size costs your existing users something each time you ship.
You do not need to know how the build is configured to manage this. You need a habit of asking what each part of the app costs in size, and whether it is worth that cost.
What should you measure before changing anything?
Look at the size users actually get, not the size of the file your team uploads. The two can be quite different, because stores can optimise what each device receives. Ask your developers where each store reports the download and install size for your releases. Also ask your developers for a breakdown by category: code, images, fonts, other media, native libraries and framework runtime.
Record the figure for every release. A size trend across versions tells you far more than one number, and it shows you which release added the weight.
Which assets usually take up the most space?
Assets are often the easiest win, because they can be fixed without touching how the app behaves.
- Images. Large photos and illustrations exported at full resolution are a common cause. Use modern compressed formats where your target devices support them, and export at the sizes the app really displays.
- Icons. Replace sets of image icons with vector icons or an icon font where the design allows.
- Fonts. Each font weight is a separate file. Ship only the weights and character sets you use, while still covering every language you support. Our guide to designing for multiple languages explains why cutting character sets carelessly can break translated screens.
- Video, audio and animations. Bundled onboarding videos and large animation files add up quickly. Ask whether they can be shorter, compressed or downloaded later.
- Leftovers. Old screens get removed but their images often stay behind. Look for files that nothing references any more.
A good rule: if content is only needed by some users, or only after first launch, consider downloading it on demand from your server instead of bundling it. Weigh this against offline use. If the content has to work without a connection, the approach in planning offline data sync is relevant.
How do unused SDKs make an app bigger?
Every analytics tool, ad network, chat widget, payments library or crash reporter you add brings its own code, and sometimes its own native libraries and assets. Apps tend to collect SDKs over time: a tool trialled for a month, an analytics product replaced but never removed, two libraries doing the same job.
Make a list of every SDK in the app and, for each one, ask:
- Is it still in use, and who owns the decision to keep it?
- Does another SDK in the app already do the same thing?
- Are we including the whole package when we only use one module?
- Could this work be done on the server instead?
Removing an SDK also reduces privacy disclosures, permissions and maintenance work, so the benefit goes beyond size. When adding something new, check its size cost before you commit, alongside the other criteria in our guide to evaluating third-party mobile app SDKs. If you remove an SDK that collected data, check whether your Google Play data safety answers need updating.
How do app bundles and splits help?
The old approach was to ship one package with everything for every device: all screen densities, all processor types, all languages. Most users downloaded a lot they would never use.
On Google Play, new apps must be published as Android App Bundles. From a bundle, Google Play generates optimised downloads for each device configuration, so each device downloads only the code and resources it needs. On iOS, ask your developers how the build is prepared so devices receive only what they need.
Two further options are worth discussing with your team:
- On-demand features. Parts of the app that only some users need, such as an advanced editor or an admin tool, can be delivered separately after install.
- Asset delivery after install. Large content packs can be fetched when needed rather than included in the first download.
These add complexity to testing and release, so use them where the size saving is meaningful, not by default.
What should you check in Flutter and React Native apps?
Both frameworks include a runtime in every app, so a cross-platform app starts with a baseline size that a minimal native app does not have. That is usually an acceptable trade-off for one shared codebase; our comparison of Flutter and React Native for a first app and the main blog's article on native versus hybrid apps discuss it. The focus is on what you add on top.
| Area | Flutter | React Native |
|---|---|---|
| Size analysis | Use the framework's built-in size analysis tooling to see which packages and assets contribute most | Inspect the JavaScript bundle and native libraries to see which dependencies are largest |
| Packages | Review packages from the package registry; some pull in large native dependencies | Review npm dependencies; a small feature can bring in a large library |
| Assets | Check declared asset folders for unused images and fonts | Check bundled images and font files linked into the app |
| Icons | Check icon fonts and icon packages for sets you do not use | Avoid bundling complete icon libraries when you use a handful of icons |
| Debug code | Make sure measurements come from release builds, never debug builds | Same, and confirm developer-only tools are excluded from release |
The most common mistake on both is measuring a debug build, which is much larger than what users download, and drawing the wrong conclusion.
What does a size audit checklist look like?
Use this before each major release or every few releases:
- Record the user-facing download and install size and compare it with the previous release.
- Get a breakdown by category and identify the three largest contributors.
- List images, videos and animations above an agreed size and decide on each one.
- Remove assets that no screen references.
- Confirm only the font weights and character sets you need are included.
- List every SDK, its owner and whether it is still used.
- Remove duplicate or abandoned SDKs and update privacy disclosures if needed.
- Confirm the app is published in a format that allows device-specific downloads.
- Identify content that could be downloaded on demand without hurting core use.
- For Flutter or React Native, run size analysis on a release build and review the largest packages.
- Retest affected screens, including on slow connections, before release.
For an illustrative example: a team finds that one onboarding video, two retired analytics SDKs and four unused font weights account for most of the growth over three releases. Removing them is a single focused piece of work, with no change to features. The figures will be different in every app, which is why measuring comes first.
What common mistakes should you avoid?
Optimising before measuring. Compressing small icons while a large video sits untouched wastes effort.
Moving everything to on-demand downloads. Core features should work straight after install, including offline where users expect it. Testing with slow networks shows what a delayed download feels like.
Over-compressing images. Blurry product photos or screenshots harm trust more than a slightly larger download.
Removing an SDK without checking dependencies. Something else may rely on it. Test thoroughly, following our guide to testing an Android app before release.
Treating size as a one-off project. Without a per-release check, the app grows back.
When does this not apply?
If your app is already small for its category and users are not dropping off at install, chasing further savings may not be worth the testing effort. Some apps are large for legitimate reasons, such as offline maps, games or reference content. There, the goal is to deliver the big content sensibly rather than shrink it. Low-level build configuration is also out of scope here; discuss it with your development team.
What questions do founders often ask?
Is there a size I should stay under?
There is no single right number. Compare your app with others in your category and watch the trend between releases.
Does a smaller app also start faster?
Sometimes, but not always. Startup speed depends more on what the app does at launch. See our guide to diagnosing slow app startup.
Will reducing size change how the app looks or works?
It should not if done carefully. Asset and SDK clean-up should be invisible to users, apart from a quicker download.
Who should own app size?
Assign it to whoever owns releases. Add the size check to your Google Play release checklist so it happens every time.