App Launch Time Monitoring Setup (Cold, Warm, Hot)

Cold launch time is the first metric users notice. If your cold launch exceeds 2 seconds, 5% of users may close the app. Apple recommends cold launch under 20 seconds, but the real tolerance threshold is lower. Without monitoring, you won't know that P95 hits 5 seconds. Tracking percentiles (P50, P95) gives the full picture: averages hide the tail that ruins user experience. Setting up regression alerts helps catch degradation between releases. We set up launch monitoring for iOS and Android using MetricKit and Firebase Performance – backed by years of experience and dozens of integrations. With our help, you can get a transparent metrics system within two days and stop guessing what's slowing down the launch. Setup includes SDK integration, dashboard creation, and alert configuration in Slack or Telegram. This can save up to 40% of debugging time for regressions and increase retention by 5-10%.

Monitoring Launch Speed: What We Measure and How

Cold launch — the app is not in memory; the process is created from scratch. The slowest and most critical to monitor. Warm launch (iOS) — the app was in memory but suspended in background. The process lives, but viewDidLoad runs again. Hot launch — returning from background. Nearly instantaneous. Monitor cold and warm. Hot is not indicative.

Why Cold Launch Is the Key Metric

Cold launch is the user's first impression. If it exceeds 3 seconds, 5% of users may close the app. Apple's performance recommendations require cold launch under 20 seconds, but the real tolerance is around 2 seconds. Monitoring P95 reveals the worst-case scenario that averages hide.

Which Monitoring Tool to Choose for Your Project

Choosing between MetricKit and Firebase Performance depends on platform and real-time data requirements. MetricKit is ideal for iOS-only projects needing aggregated statistics from all users without an SDK. Firebase Performance suits cross-platform apps and provides real-time data with device breakdown. Learn more in Firebase Performance documentation.

How to Set Up Launch Monitoring

1. Choose your tool: MetricKit or Firebase Performance.
2. Integrate the SDK into the project.
3. Add custom markers for pre-main time (iOS) or initialization (Android).
4. Create a metrics dashboard (P50, P95, version distribution).
5. Configure regression alerts: notify if P95 cold launch increases by 20% compared to the previous version.
6. Verify data collection on real devices via TestFlight or Firebase App Distribution.

Built-in Platform Tools

iOS — MetricKit. Since iOS 13, the system aggregates diagnostics from real users and delivers them via MXMetricManager:

class AppDelegate: MXMetricManagerSubscriber { func applicationDidFinishLaunching() { MXMetricManager.shared.add(self) } func didReceive(_ payloads: [MXMetricPayload]) { for payload in payloads { if let launchMetric = payload.applicationLaunchMetrics { let coldLaunchP50 = launchMetric.histogrammedTimeToFirstDrawKey .histogram(for: .applicationLaunchTimeToFirstDraw) Analytics.track("cold_launch_p50", value: coldLaunchP50) } } } } 

MetricKit delivers data once per day, aggregated over the previous 24 hours. Not real-time, but a real sample from all users.

Android — Firebase Performance Monitoring. app_start trace is collected automatically when the SDK is connected. It separates app_start_cold and app_start_warm. Available in Firebase Console with breakdown by device, OS version, and app version.

For custom markers on Android — FirebasePerformance.getInstance().newTrace("custom_init") + start() / stop(). Helps identify which initialization is slowing things down.

How to Measure Pre-Main Time on iOS

Pre-main time (dynamic linker loading, Objective-C runtime initialization) is not covered by standard measurements in AppDelegate. The only way to see it is to enable the DYLD_PRINT_STATISTICS environment variable in the Xcode scheme. For automated collection, use instrumentation via MetricKit and specialized libraries.

Instrumentation in Code

Even without external SDKs, you can measure launch manually. iOS:

// In AppDelegate or @main static let appLaunchTimestamp = Date() // In viewDidAppear of the first screen let launchDuration = Date().timeIntervalSince(AppDelegate.appLaunchTimestamp) Analytics.track("cold_launch_duration", value: launchDuration) 

But this method is imprecise — it doesn't account for pre-main time (dynamic libraries, runtime). For pre-main: use the DYLD_PRINT_STATISTICS environment variable in the Xcode scheme.

Android:

class App : Application() { override fun onCreate() { val start = SystemClock.elapsedRealtime() super.onCreate() // ... initializations val initDuration = SystemClock.elapsedRealtime() - start FirebaseAnalytics.getInstance(this).logEvent("app_init_duration") { param("duration_ms", initDuration) } } } 

SystemClock.elapsedRealtime() is more accurate than System.currentTimeMillis() for measuring intervals.

Dashboard and Alerts

Minimum set of metrics for monitoring:

An alert on P95 increase between versions is more important than absolute values. A regression of 500 ms between two releases is a signal to investigate the diff.

In Grafana or Firebase Alerts, configure notification: if P95 cold launch in the current version exceeds the previous version's P95 by 20% — send alert to Slack.