In a service app, a delay is more than an inconvenience. For a driver waiting for a request or plotting a route, slow startup can mean a missed opportunity, a late arrival or lost income. Here, speed is part of the work tool, not a "nice bonus".

The Lyft case described on Android Developers is interesting not only for its result but also for how the team convinced leadership to invest in performance at a company where every project competes for resources. We break down what exactly they did, what numbers they got, and how we apply this approach when justifying performance work for our own products.

The Lyft case: how the task came about

Lyft is a ridesharing service used every day by millions of drivers and riders. The team kept an eye on performance and noticed that the Lyft Driver app on Android started slowly. But developers' impressions aren't an argument for leadership, so the first step was to show the scale of the problem.

Android vitals in Google Play Console helped here. A comparison with ten other apps in the category showed that Lyft Driver's startup time was 15–20% worse. The team then estimated the cost: one developer working for one month could make a significant improvement. The combination of "a clearly measured problem and a bounded investment" made the decision obvious for leadership.

Four startup phases and where the bottleneck was

The team chose time to interact as its main metric — that is, time to full display (TTFD), not just the first frame. Startup was broken down into four phases.

PhaseWhat happensAnalysis result
1. Process startthe system creates the app processno issues
2. ActivityUI rendering kicks offno issues
3. Bootstrapnetwork requests for the data the home screen needsthe bottleneck
4. Displaythe driver interface openswaits for bootstrap to finish

Profiling showed that time was lost in the third phase: the app waited on network responses before showing the working screen. The fixes were relatively simple:

  • after decomposing backend services, some network calls were removed from the critical launch path entirely;
  • calls that could run asynchronously were made asynchronous;
  • data needed later rather than at launch stopped blocking startup;
  • blocking calls were moved to the background;
  • data started being cached between sessions.

Note that there are no "magic" compiler optimisations here. The main gain came from reviewing what the first screen really needs. In our experience, network bootstrap is the most common cause of slow TTFD in service and e-commerce apps.

The result: from milliseconds to sessions

The changes delivered an average 21% reduction in startup time and a 5% increase in driver sessions. The second number matters more than the first: it translates a technical improvement into business language. Seeing the result, Lyft leadership expanded the app excellence initiative and took on other areas, including stability.

An important caveat: 5% more sessions is the result for a specific product with a specific audience. It can't be mechanically transferred to another app. But the logic — tying speed to the user's key action — is always worth transferring.

Why context matters more than the average

What you should measure is not an abstract startup but a critical business scenario. In a driver app that might be going online, accepting a ride, the map or confirming completion. For a store — the catalogue and cart; for a bank — the balance and a transfer.

  • Define the moment after which the user can actually work, and mark it with reportFullyDrawn(), as Lyft did with time to interact.
  • Measure cold, warm and hot starts separately. A driver switching between a navigation app and yours experiences mostly warm and hot starts.
  • Segment data by device class and network conditions. The average hides drivers on old phones and in areas with weak coverage.
  • Check that optimisation doesn't hurt stability. Caching and asynchrony add new states that need testing.

How to build a business case for performance

  1. Gather a market comparison. Android vitals shows startup time against a peer group; Xcode Organizer shows trends by version on iOS.
  2. Pick one product metric that speed can influence: sessions, conversion to the key action, day-one retention.
  3. Scope the investment tightly: "one developer, four weeks" is more convincing than "a big optimisation".
  4. Break startup into phases and find the one that takes the most time.
  5. Start with the simplest changes: remove unnecessary requests, cache, defer what isn't important.
  6. Ship changes as a controlled release and compare the technical and product metrics against a control group.
  7. Show the result to leadership and propose the next step — as the Lyft team did.

We covered the more engineering-heavy side — what to do once network bootstrap is optimised but startup is still slow — using the examples of Gmail Wear OS and Android Calendar with Baseline Profiles.

Typical mistakes

  • Optimising TTID while the user is actually waiting for network data after the first frame.
  • Sequential requests at startup, each waiting for the previous one.
  • No cache between sessions: the app starts from an empty screen every time.
  • Justifying performance work with impressions rather than a market comparison and a product metric.
  • Prioritising the performance backlog separately from product and operations teams.
  • Not checking whether cached data has become so stale that it misleads the user.

Action plan

  1. Define the key action users open the app for, and mark the moment the app is ready for it.
  2. Compare your startup time with peers in Android vitals.
  3. Break startup into phases and measure each.
  4. Remove from the critical path every network request the first screen can do without.
  5. Add caching between sessions with honest indication of data freshness.
  6. Ship changes in a controlled release and compare technical and product metrics.
  7. Add the startup metric to the product team's regular report.

Speed becomes a business advantage when it supports a user's specific job. That's why the performance backlog must be prioritised together with product and operations teams. You'll find the general framework of startup metrics in our article on app startup speed.

Sources: Android Developers: Lyft improves Android app startup time; Android Developers Blog: How a single Android developer improved Lyft's Drivers app startup time by 21% in one month; Android Developers: App startup time; Android vitals: App startup time.