Android Developer Interview Questions & Answers

Typical Android Developer Interview Process

Kotlin, Lifecycle & Core Android

Core competencies in Kotlin syntax, Activity/Fragment lifecycle, coroutines, and Jetpack essentials.

• Explain the Activity lifecycle. At which point should you register/unregister a BroadcastReceiver and why?

  Interviewer Insight: Lifecycle questions aren't testing memorisation — they're testing whether you've debugged a real crash caused by a configuration change or process death. We want to hear about a specific bug: 'I once had a BroadcastReceiver that persisted after the Activity died because I registered it in onCreate without unregistering, causing unexpected callbacks.' That tells us you've struggled with the platform and learned.

  How to Structure an Android Lifecycle Answer:

  1. List the lifecycle methods in order: onCreate → onStart → onResume → onPause → onStop → onDestroy
  2. Explain that BroadcastReceivers should be registered in onResume and unregistered in onPause to avoid receiving broadcasts when the activity is backgrounded
  3. Discuss the difference between onStop (user can't see it) and onDestroy (resources are freed)
  4. Mention common mistakes: registering in onCreate without unregistering, or registering in onStart without unregistering in onStop
  5. Optionally reference LocalBroadcastManager as deprecated, or context.registerReceiver() alternatives
• What is the difference between Fragment.onCreateView() and Fragment.onViewCreated()? Which should you use for initial setup?

  Context: Candidates should clarify that onCreateView() inflates the view hierarchy, whilst onViewCreated() receives the inflated view for safe initialisation with findViewById or binding. Setup should happen in onViewCreated().
• Explain Kotlin coroutines and how they differ from traditional threading. Why are they preferred in Android development?

  Context: Look for understanding that coroutines are lightweight, suspendable (not blocking threads), and structured concurrency. Mention viewModelScope and lifecycleScope as Android-specific bindings.

  Sample Answer Guidance: Coroutines are suspendable functions that don't block threads; when a coroutine suspends (e.g., during a network call via Retrofit's suspend functions), the thread is freed to handle other work, unlike blocking threads which consume OS resources continuously. In Android, viewModelScope and lifecycleScope automatically cancel coroutines when the ViewModel or Activity is destroyed, preventing leaks—I replaced Thread-based services with coroutines in viewModelScope and reduced memory overhead significantly.
• What is the Room database library? How does it differ from SQLite directly?

  Context: Room provides type-safe database access, compile-time SQL validation, and integration with Kotlin Flow for reactive queries. Candidates should mention DAOs and entities.
• Describe the relationship between ViewModel, LiveData, and the UI layer. Why shouldn't ViewModels hold Context references?

  Context: ViewModel survives configuration changes and holds state; LiveData observes state changes reactively. Context references prevent garbage collection when ViewModel outlives the Activity.

  Sample Answer Guidance: ViewModel outlives Activity rotation and holds app state via LiveData/StateFlow; the UI observes and reacts to state changes, keeping ViewModel decoupled from Android components. Storing Context in ViewModel creates a memory leak because the ViewModel persists across configuration changes, keeping the old Activity alive even after it's destroyed. I use application context only when absolutely necessary, but prefer passing state downward and events upward instead.
• What is DataStore and when would you use it instead of SharedPreferences?

  Context: DataStore is the modern replacement for SharedPreferences, offering Kotlin Flow support, type-safe access, and atomic writes. Better for small user preferences and settings.
• Explain the concept of 'composition over inheritance' in Jetpack. How does Compose change this paradigm?

  Context: Traditional Android encouraged inheritance (custom Views extending View). Jetpack Compose favours small, reusable composable functions that combine, reducing boilerplate and improving testability.
• How do you manage dependencies in a large Android project? Discuss Hilt dependency injection.

  Context: Hilt reduces boilerplate around Dagger, providing scoped containers (Application, Activity, Fragment, ViewModel). Candidates should discuss avoiding tight coupling and testability benefits.

  Sample Answer Guidance: Hilt provides automatic scope-based container management; I use @HiltViewModel to inject dependencies directly into ViewModels, @Inject for constructor injection, and custom @Modules for third-party libraries like Retrofit. This eliminates tight coupling—swapping implementations (e.g., real network client vs. mock) becomes trivial in tests. I've seen Hilt reduce boilerplate by ~70% versus manual Dagger setup in multi-module projects.

Performance, Testing & Release

Production-grade Android: profiling, optimisation, testing strategies, and Play Store deployment.

• How do you identify and fix memory leaks in Android apps? Walk me through using Android Studio Profiler.

  Context: Candidates should discuss heap dumps, object retention traces, and common culprits: static references, long-lived listeners, and context leaks. Mention LeakCanary for automated detection.

  Interviewer Insight: Performance questions reveal whether you've profiled a real app or just read best practices. Interviewers want tool names and specific metrics. Strong candidates say: 'I used Android Profiler to capture a heap dump, looked for retained objects in the Retain Set, and found a static reference to an Activity. I measured before/after: heap went from 200 MB to 120 MB.' Weak answers are generic: 'You should avoid memory leaks by not holding Context' without concrete tool experience.

  Sample Answer Guidance: I use Android Profiler's Memory tab to capture a heap dump (Dump Heap button), then filter by the suspected Activity class to find retained instances; the Retain Set column shows which objects prevent garbage collection. I once found a static reference to an Activity in a listener registry—changing it to WeakReference fixed the leak. I also integrate LeakCanary in debug builds for automated detection; it emails reports when leaks persist across rotations.
• What is ProGuard and R8? Why are they important for release builds?

  Context: ProGuard (older) and R8 (modern replacement) perform code shrinking, obfuscation, and optimisation. They reduce APK size and prevent reverse-engineering of production code.
• Explain the difference between unit tests, integration tests, and UI (Espresso) tests. What's your strategy for balancing coverage?

  Context: Unit tests are fast and isolated; integration tests verify component interactions; UI tests are slow but test real user workflows. Aim for pyramid: many unit, fewer integration, minimal UI.
• What is Espresso and how do you write a basic test? Discuss idling resources.

  Context: Espresso is Google's testing framework for UI automation. Idling resources tell Espresso when async operations (network, database) are complete, preventing flaky tests.
• How do you structure a Gradle build for a multi-module Android project? Discuss build variants and product flavours.

  Context: Modules separate concerns (app, common, network). Build variants (debug/release) change settings. Product flavours allow multiple APK variants (free/paid, regional).

  Sample Answer Guidance: I structure projects into feature modules (`:feature:login`, `:feature:shop`) and shared modules (`:core:network`, `:core:database`) to parallel-build and isolate concerns. Product flavours differentiate APK variants: `flavorDimensions = ['environment']` with `production` and `staging` flavours pointing to different API endpoints. Build variants automatically combine flavour + buildType; I use buildConfigField to inject secrets securely. This structure reduced build time by 40% and simplified testing and feature flagging.
• Describe the process of releasing an app to the Play Store. What are the key checks?

  Context: Increment version code/name, test on multiple devices, prepare store listing, check crashes via Crashlytics, monitor ANRs (Application Not Responding), and use staged rollout to catch issues early.
• What is APK size and why does it matter? How do you analyse and reduce it?

  Context: Larger APKs have higher install friction and storage cost. Use Android Studio's APK Analyzer to identify culprits: resources, DEX files, native libraries. Use resource shrinking and WebP compression.

  Sample Answer Guidance: I use Android Studio's APK Analyzer (Build > Analyze APK) to identify size culprits: unused resources, oversized images, and duplicate dependencies. I enable shrinkResources = true and minifyEnabled = true in release builds to let R8 remove unused code and resources. Converting PNGs to WebP halved our assets; bundling via Google Play's App Bundle instead of monolithic APK lets Play deliver only assets matching each device's configuration. This optimisation effort reduced install size from 45 MB to 18 MB.

How Interviewers Evaluate Android Developers