Speed Up Your Builds: Mastering Feature Modules and Dynamic Delivery in Android

Hook

Your CI pipeline stalls at 15 minutes, and every new feature adds another minute to local builds. Split the monolith, let Google Play deliver code on demand, and watch build times collapse.

Context

I’ve spent the last 13 years turning QA checklists into production‑ready apps, and the one constant pain is build latency. A single‑module Gradle project forces the compiler to reprocess every source file, even when you touch a tiny UI tweak. The solution is Android App Modularization: isolate features into Gradle modules, configure dynamic delivery, and let the build system do its job.

In this post I’ll show:

• How to create a feature module with Hilt and Compose.
• How to configure Gradle settings for incremental builds.
• How to enable Play Feature Delivery for on‑demand modules.
• Real‑world performance numbers from my own projects.

1. Setting Up a Feature Module

1.1 Create the module

./gradlew :app:createFeatureModule --type=android-library \
  --module-name=feature_profile

[!NOTE] The

code Copy

createFeatureModule

task is a custom wrapper around

code Copy

gradle init

that applies the Android library plugin and sets up Hilt, Compose, and Kotlin DSL automatically.

1.2 Gradle configuration

feature_profile/build.gradle.kts

plugins {
    id("com.android.library")
    kotlin("android")
    kotlin("kapt")
    id("dagger.hilt.android.plugin")
}

android {
    namespace = "com.sudarshantechlabs.feature.profile"
    compileSdk = 34

    defaultConfig {
        minSdk = 21
        targetSdk = 34
        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    }

    buildFeatures {
        compose = true
    }

    composeOptions {
        kotlinCompilerExtensionVersion = "1.5.3"
    }

    // Enable incremental compilation for this module
    kotlinOptions {
        incremental = true
        jvmTarget = "17"
    }
}

dependencies {
    implementation(project(":app"))
    implementation(libs.androidx.core.ktx)
    implementation(libs.compose.ui)
    implementation(libs.hilt.android)
    kapt(libs.hilt.compiler)
}

[!IMPORTANT] Keep

code Copy

incremental = true

and avoid

code Copy

kapt

options that disable it, otherwise you lose the biggest build‑time win.

1.3 Wire the feature into the base app

app/src/main/java/com/sudarshantechlabs/MainActivity.kt

@AndroidEntryPoint
class MainActivity : ComponentActivity() {
    private val navController by lazy { rememberNavController() }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            NavHost(navController, startDestination = "home") {
                composable("home") { HomeScreen(navController) }
                // Feature module destination
                composable("profile") { 
                    // The profile feature is a separate module
                    FeatureProfileScreen()
                }
            }
        }
    }
}

The

FeatureProfileScreen

feature_profile

2. Measuring Build Speed Gains

[!TIP] Run

code Copy

./gradlew :app:assembleDebug --scan

and look at the Configuration time section to see the exact impact of each module.

Why the drop?

• Parallel compilation – Gradle can compile each library module on a separate worker.
• Reduced source set – Hilt’s generated code is limited to the module that declares the injection points.
• Cache friendliness – Unchanged modules are pulled from the Gradle build cache instantly.

3. Dynamic Feature Delivery with Play Feature Delivery

3.1 Declare a dynamic feature

Add a

feature_profile

com.android.dynamic-feature

plugins {
    id("com.android.dynamic-feature")
    kotlin("android")
    kotlin("kapt")
    id("dagger.hilt.android.plugin")
}

Update

settings.gradle.kts

include(":app", ":feature_profile")

3.2 Configure delivery mode

feature_profile/build.gradle.kts

android {
    // Existing config ...

    dynamicFeatures = mutableSetOf(":feature_profile")

    // Delivery options
    bundle {
        language {
            enableSplit = false
        }
    }

    // On‑demand delivery
    dynamicDelivery {
        onDemand = true
    }
}

3.3 Request the module at runtime

class ProfileNavigator @Inject constructor(
    private val context: Context,
    private val navController: NavController
) {
    fun openProfile() {
        // Trigger Play Core to download the module if not present
        SplitInstallManagerFactory.create(context).let { manager ->
            val request = SplitInstallRequest.newBuilder()
                .addModule("feature_profile")
                .build()

            manager.startInstall(request)
                .addOnSuccessListener {
                    navController.navigate("profile")
                }
                .addOnFailureListener { e ->
                    Log.e("ProfileNavigator", "Install failed", e)
                }
        }
    }
}

[!WARNING] Do not call

code Copy

navigate("profile")

before the install succeeds; the class loader will throw

code Copy

ClassNotFoundException

.

3.4 Verify module size reduction

The profile feature, which includes heavy image processing libraries, is offloaded to an on‑demand download of ~5 MB.

4. Best Practices for a Solo Developer

1. Start small – Convert the biggest, most frequently changed screen into a feature module first. You’ll see the build‑time win instantly.
2. Keep dependencies local – Do not pull
   code Copy

   implementation(project(":app"))

   unless you truly need shared code. Prefer a
   code Copy

   :core

   library that houses only constants and data models.
3. Automate module validation – Add a Gradle task that runs
   code Copy

   ./gradlew :feature_profile:lintRelease

   as part of your CI pipeline. It catches missing
   code Copy

   @AndroidEntryPoint

   annotations before they break the Play store release.

# .github/workflows/android.yml snippet
- name: Lint feature modules
  run: ./gradlew :feature_*:lintRelease

4. Monitor download metrics – In Play Console, enable the On‑Demand module download report. If a module never downloads, consider merging it back to avoid unnecessary complexity.

5. Debugging Common Pitfalls

ClassNotFoundException

SplitInstallManager

kapt

correctErrorTypes = true

-Xuse-ir

-keep class dagger.hilt.** { *; }

proguard-rules.pro

[!NOTE] The

code Copy

androidx.hilt:hilt-navigation-compose

artifact automatically adds the required keep rules for Compose navigation.

Key Takeaways

• Split large screens into feature modules; enable
  code Copy

  incremental = true

  to cut compile time by up to 50 %.
• Use Play Feature Delivery (
  code Copy

  onDemand = true

  ) to keep the base APK small and download heavy code only when needed.
• Automate linting and download‑metric monitoring to keep the modular architecture maintainable as a solo developer.