A video app can lose attention in seconds. If the feed takes too long to open or scrolling stutters, it is easier for users to close the app and move to another service. The problem is even sharper for audiences on older and low-end phones: every extra hundred milliseconds at startup is multiplied by a slow CPU, limited RAM and crowded storage.
The case study of Josh, an Indian short-video platform, published on Android Developers, shows how systematic startup work turns into a product result. Below we break down what the team actually did, which lessons are worth carrying into your own project, and how we at the studio organise this kind of optimisation, from the first trace to post-release monitoring.
What we know about the Josh case
Josh is a short-video app launched in August 2020. When the case study was published, it had more than 124 million monthly active users and around 60 million daily users. Its audience used a very wide range of devices, from flagships to inexpensive models, and video was the main format. Any stutter in the feed or pause in an interaction quickly made people lose interest.
The team monitored Android vitals and identified an opportunity to improve startup. They prioritised cold start, the heaviest scenario, when the app process does not exist yet. The reasoning is simple: speed up cold start and warm and hot starts usually improve as well.
According to the case study, average startup time improved by 30%, and the app became three times faster for roughly 10% of users on older and low-end phones. Better bounce rates and retention helped Josh retain more than 1 million users compared with the baseline, and Play Store ratings trended upward after the release.
What exactly changed in startup
The most valuable part of the case is not the percentages but the list of actions. The team used custom traces, Systrace, Perfetto, dumpsys and Android Studio Profiler, and found that most of the time was spent in Application.onCreate and other synchronous methods at startup.
- They profiled every block of code executed during startup.
- They investigated the impact of third-party SDKs and disabled auto-initialisation for some of them.
- They removed legacy libraries.
- They deferred some modules and moved them to background execution.
- They reduced the size of splash screen drawables and optimised them for different screen sizes.
Each change was validated in isolation by emulating cold starts and using the Jetpack Macrobenchmark library. That detail matters: without isolated measurement you cannot tell which change produced the effect and which only added complexity.
Why the average hides the problem
Average startup time is a convenient number for a report, but it masks the worst experience. If 90% of the audience opens the app in one second and 10% in five, the average looks acceptable even though the product is effectively broken for one user in ten. That is why the Josh result of "three times faster for 10% of users" matters more than "30% on average": it shows the team worked on the tail of the distribution.
In our projects we see the same pattern: p90 and p95 percentiles split by device class almost always reveal problems that are invisible in the average. Android vitals defines the reference points directly.
| Startup type | What happens | "Slow" threshold in Android vitals |
|---|---|---|
| Cold | The process is created from scratch; Application and the first Activity are initialised | 5 s or more |
| Warm | The process exists, but the Activity is recreated | 2 s or more |
| Hot | The Activity returns from the background | 1.5 s or more |
These thresholds mark where the experience is considered bad; they are not a goal. For our own budgets we usually set much stricter p90 values on low-end devices and track time to the first rendered frame of the feed separately.
How to repeat the approach in your app
- Capture a baseline. Record cold, warm and hot start on three device classes: a flagship, a mid-range phone and a three- to four-year-old budget phone. Use Macrobenchmark with several iterations rather than a single manual launch.
- Take a system trace. In Perfetto, look at what happens between process creation and the first frame: SDK initialisation, dependency injection, disk reads, network calls on the main thread.
- Build an initialisation register. For every SDK and module, record whether it is needed before the first screen, who owns it and how many milliseconds it takes.
- Defer everything non-critical. Initialise analytics, ads and features that appear later lazily or on a background thread after the first frame.
- Lighten the first screen. Shrink splash graphics, simplify the layout and load only the first feed items rather than the whole feed.
- Measure every change separately. One pull request, one optimisation, one measurement. That way you know the real contribution of each step.
- Lock in the result. Add Macrobenchmark to CI with a startup budget that blocks a release when exceeded. Also consider Baseline Profiles, a tool that helps critical code run faster from the very first launch.
Typical mistakes that eat the gains
- Testing only on the team's phones. Developers usually have new devices and simply do not see problems in the budget segment.
- Measuring debug builds. A debug build behaves differently from a release build with R8 and optimisations; its numbers are misleading.
- Moving work "to the background" without control. If deferred initialisation competes with the first frame for CPU, users still feel the slowdown.
- Trading stability for decorative smoothness. Aggressive optimisations that raise crash or ANR rates cancel out the speed gain.
- One-off optimisation. Without a budget in CI, new features push startup back to where it was within a few releases.
We covered how to choose a test device fleet in our article on testing on inexpensive devices, and startup metrics in the piece on app startup speed.
What performance work gives the product
The Josh case shows that startup optimisation is audience work, not only technical-debt work. When an app becomes usable on modest devices, the team returns access to people who would otherwise have left. For Josh this showed up in bounce rate, retention and ratings; a similar link between speed and business metrics is described in the Zomato case.
Another effect highlighted in the case is organisational. Working on vitals brought the team together, and the learnings were later applied to other apps in the company. When performance becomes a shared metric rather than the job of a single "performance engineer", it is much easier to sustain.
Checklist before your next release
- There is a baseline for cold, warm and hot start on three device classes.
- Startup metrics are reviewed at p50, p90 and p95, not only as an average.
- Every SDK in the startup path has an owner and a reason it is needed before the first frame.
- Non-critical initialisation is deferred and does not compete with rendering the first screen.
- Splash and first-screen graphics are optimised for display size.
- Macrobenchmark runs in CI, and exceeding the startup budget stops the release.
- After release, the team watches Android vitals, crash rate, ANR and retention in the low-end device segment.
Sources: Android Developers: Josh startup performance case study; Android Developers: App startup time; Android Developers: Macrobenchmark; Android Developers: Baseline Profiles.



