Instant App: The Essence of Google Play Instant and Apps Without Installation

What is an Instant App?

Android Instant App is a native Android application that launches immediately after clicking a link or the "Try Now" button, without installation. Introduced by Google in 2017, the technology downloads only the module needed for the current scenario (placing an order, a game level, hotel booking) and runs it as a full native process with access to all device capabilities.

The concept solves a fundamental problem of the mobile market: the discovery barrier. Research shows that 60–80% of users who view an app page never install it, and 25% of installed apps are never opened. Instant apps eliminate this barrier by providing a native experience immediately. At the same time, a single codebase serves both the instant and the full version, reducing development costs.

By 2026, Google Play Instant supports games, e-commerce, travel booking, ticket purchasing, and utilities. Major adopters include Skyscanner (+25% bookings), NYTimes Crossword (+15% subscriptions), and Red Bull (+30% engagement). The technology is especially effective in "try before you buy" scenarios where users want to evaluate an app before installing it.

Google Play Instant Architecture

Google Play Instant is built on the Android App Bundle format and the Dynamic Delivery mechanism. When a user initiates an instant experience, Google Play downloads the base module and the specific feature-module, verifies the digital signature, and launches the activity within seconds. The entire process happens without an installation dialog — the app simply appears on the screen.

// build.gradle.kts — instant module configuration
plugins {
    id("com.android.application")
    id("org.jetbrains.kotlin.android")
    id("com.google.android.instantapps")
}

android {
    namespace = "com.example.instantapp"
    compileSdk = 35

    defaultConfig {
        applicationId = "com.example.instantapp"
        minSdk = 26
        targetSdk = 35
        versionCode = 1
        versionName = "1.0"
    }

    dynamicFeatures = setOf(
        ":feature_checkout",
        ":feature_catalog"
    )
}

// AndroidManifest.xml for instant-app — "dist:module dist:instant="true"" flag
// <dist:module dist:instant="true" />

// Feature module — order placement screen for instant
class CheckoutActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_checkout)

        // Instant app: feature-module size must not exceed 4 MB
        // Load thumbnails first, then load full images
        // Use minimum dependencies in feature-module
    }

    fun upgradeToInstalledApp() {
        // Prompt the user to install the full version
        InstantApps.showInstallPrompt(this, "com.example.instantapp", 123)
    }
}

A key configuration requirement is the instant manifest flag: each feature-module participating in the instant experience must include <dist:module dist:instant="true" /> in its manifest. The base module also requires the Play Instant SDK dependency. Google Play Console requires a separate configuration for instant releases, and the app itself must be published in the Android App Bundle (.aab) format.

Modular Development with Feature Modules

Feature modules are the building blocks of instant apps. Each feature-module represents a separate user scenario — placing an order, search, product card, game level — and can be loaded independently. The base module contains shared code, resources, and navigation infrastructure, while feature-modules implement specific functionality. This architecture benefits both the instant and the installed version.

// settings.gradle.kts — project structure with feature-modules
pluginManagement {
    repositories {
        google()
        mavenCentral()
        gradlePluginPortal()
    }
}

rootProject.name = "InstantAppExample"

include(":app")                    // Base module
include(":feature_checkout")     // Order placement (instant-ready)
include(":feature_catalog")      // Product catalog (instant-ready)
include(":feature_profile")      // User profile (installed version only)

// build.gradle.kts (feature module) — instant-enabled
plugins {
    id("com.android.dynamic-feature")
    id("org.jetbrains.kotlin.android")
}

android {
    namespace = "com.example.feature.checkout"
}

dependencies {
    implementation(project(":app"))
    implementation("androidx.appcompat:appcompat:1.7.0")
}

Feature-modules interact with the base module through the Navigation Component and shared interfaces. The navigation component supports deep links directly into feature-modules, allowing instant apps to handle URLs. For data exchange, feature-modules can use shared ViewModels, service locators (Dagger/Hilt), or event buses. The base module declares the navigation graph, and each feature-module registers its destinations.

Size Limits and Optimization

Instant app size limits are the most critical technical constraint. The total download size (base module + required feature-modules) must not exceed 10 MB. For the first launch, one feature-module together with the base module should not exceed 4 MB to ensure startup in under 2 seconds. Exceeding the limits leads to download failures and user loss.

Size analysis tools: APK Analyzer in Android Studio (for .apk) and bundletool (for .aab). Google Play Console provides an "Instant App Size Report" with download sizes for each device configuration. In CI, you should add a size budget check — the build should fail if the initial bundle exceeds 8 MB.

Deep Links and Instant App URLs

Instant app deep links are HTTP/HTTPS URLs that launch the instant app directly. When a user clicks a link on a website, in an ad, or on social media, Android checks whether the instant app handles the given URL pattern. If so, the instant app module is downloaded and launched, and the user sees native content instead of a mobile web page.

// AndroidManifest.xml — deep link handling in feature-module
<activity
    android:name=".CatalogActivity"
    android:excludeFromRecents="true">

    <intent-filter
        android:autoVerify="true">
        <action
            android:name="android.intent.action.VIEW" />
        <category
            android:name="android.intent.category.DEFAULT" />
        <category
            android:name="android.intent.category.BROWSABLE" />

        <data
            android:scheme="https"
            android:host="www.example.com"
            android:pathPrefix="/catalog" />
    </intent-filter>

    <!-- Required for instant apps -->
    <meta-data
        android:name="default-url"
        android:value="https://www.example.com/catalog" />
</activity>

Deep link verification is done through Digital Asset Links — a JSON file published at https://yoursite/.well-known/assetlinks.json. It confirms that the website owner controls the Android app. Without verification, links will open in the browser instead of the instant app. Google Search Console helps test and verify deep link configuration for instant app indexing.

When to Use Instant Apps

Instant apps are most effective in scenarios where the user wants immediate value without commitment: shopping (browse the catalog instantly), travel (search for flights without installing), games (try a level), tickets (buy in 3 taps), food delivery (browse the menu and order), and utilities (calculator, translator, barcode scanner). The common pattern is a focused, targeted experience that converts to installation for full functionality.

Not suitable for: apps with background services (messengers, fitness trackers), apps with complex onboarding (banking, medical records), or cases where an instant version cannot provide meaningful value (video editors, office suites). Google data shows that games, e-commerce, and travel have the highest instant-to-install conversion rates — often exceeding 30%.