In a previous project, our app crashed whenever the device was rotated because the activity was recreated and state was lost.

I needed to ensure the UI retained its state across configuration changes without memory leaks.

Implemented onSaveInstanceState/onRestoreInstanceState for lightweight data and used ViewModel with LiveData to survive configuration changes. For heavy resources, I leveraged retained fragments and set android:configChanges in the manifest where appropriate.

The app handled rotations smoothly, no crashes, and user data persisted, improving user satisfaction scores by 15%.

Our team needed a reusable component that displayed a list with header actions across multiple screens.

Decide whether to implement it as a Fragment or a custom View.

Evaluated requirements: lifecycle awareness, need for child fragments, and navigation handling. Chose a Fragment because it required its own lifecycle, could host a RecyclerView with its own ViewModel, and needed to participate in back‑stack navigation. Implemented the UI as a Fragment with a separate layout file, exposing an interface for the host activity.

The component was easily reused in three different activities, reduced code duplication by 30%, and navigation behaved consistently.

Our codebase grew to 200+ classes, making manual object creation cumbersome and hard to test.

Introduce a DI framework to manage object graphs and improve testability.

Adopted Dagger 2 (later Hilt) for its compile‑time validation. Defined @Module classes to provide dependencies, used @Inject constructors for classes, and scoped components with @Singleton and @ActivityScoped. Replaced ServiceLocator pattern with constructor injection, enabling unit tests with mock implementations.

Reduced boilerplate by 40%, eliminated runtime injection errors, and increased unit test coverage from 55% to 80%.

Our app’s cold start time exceeded 5 seconds, leading to poor user ratings.

Identify bottlenecks and reduce launch latency.

Enabled Android App Bundle to deliver only required resources, deferred initialization of heavy libraries using the SplashScreen API, moved non‑essential work to background threads with WorkManager, applied lazy loading for Dagger modules, and profiled with Android Studio’s Startup Profiler to pinpoint slow init blocks. Also optimized the Application class and removed unnecessary reflection calls.

Cold start dropped to 2.3 seconds, warm start under 800 ms, and Play Store rating improved by 0.3 stars.

When joining a legacy codebase that used MVP, I needed a more lifecycle‑aware pattern.

Advocate for MVVM and demonstrate its benefits.

Described MVVM components: View (Activity/Fragment), ViewModel (holds UI data, survives config changes), LiveData (observable data holder). Compared to MVP where Presenter manually updates the View and must handle lifecycle. Showed how ViewModel reduces boilerplate and improves testability.

Team migrated two screens to MVVM, cutting presenter code by 40% and eliminating memory leaks related to view references.

We needed a type‑safe way to represent loading, success, and error states for a network call in the UI layer.

Design a Kotlin solution that the UI could observe safely.

Created a sealed class UiState with subclasses Loading, Success<T>, and Error(val message). The ViewModel exposed LiveData<UiState>. The Fragment used when‑expression to handle each subclass, ensuring compile‑time exhaustiveness. Added data class for Success payload and used sealed class to prevent invalid states.

UI handling became concise, compile‑time safe, and bugs related to unhandled states dropped to zero in code reviews.

Our app mixed network and database logic directly in ViewModels, making testing difficult.

Introduce a clean separation of data sources.

Implemented a Repository interface that abstracts data operations. Created concrete classes: RemoteRepository (Retrofit) and LocalRepository (Room). The Repository decides whether to fetch from cache or network, exposing a Flow<Result<T>>. ViewModel depends only on the Repository, enabling unit tests with fake implementations.

Test coverage increased, code became modular, and swapping data sources required only changes in Repository implementations.

A legacy project targeted API 21 where Jetpack Navigation wasn't feasible.

Create a lightweight, maintainable navigation system.

Designed a NavigationManager singleton that holds a stack of Fragment tags. Used a sealed class NavCommand (Add, Replace, Pop). Activities called NavigationManager.navigate(command). The manager performed FragmentTransactions with custom animations and handled back‑stack updates. Integrated with ViewModel to preserve state across process death via SavedStateHandle.

Navigation logic was centralized, reduced duplicated transaction code by 70%, and passed code‑review for maintainability.

Our team needed reliable unit tests for business logic without Android dependencies.

Set up a testing approach for ViewModels.

Used JUnit5 with Kotlin Coroutines Test library. Injected a FakeRepository into the ViewModel. Leveraged LiveDataTestUtil or Turbine to collect Flow emissions. Mocked Android components with Mockito‑Kotlin where necessary. Ran tests on the JVM, not on an emulator.

Achieved 85% unit test coverage for ViewModels, catching regressions early and reducing UI‑related bugs by 30%.

A feature required clicking a list item to open a detail screen, and we needed an automated UI test.

Write an Espresso test that verifies the navigation and UI content.

Implemented a test with ActivityScenarioRule. Used onView(withId(R.id.recyclerView)).perform(RecyclerViewActions.actionOnItemAtPosition<RecyclerView.ViewHolder>(2, click())). Then asserted that the detail TextView displayed the correct title using onView(withId(R.id.detailTitle)).check(matches(withText(expectedTitle))). Added IdlingResource for asynchronous data loading.

The test reliably caught a regression where the wrong item was passed, preventing a UI bug from reaching production.

Our app’s memory usage kept growing after navigating between screens, leading to OOM crashes on low‑end devices.

Identify and fix the leak.

Connected Android Studio Profiler to capture heap dumps. Used the LeakCanary library to pinpoint a static singleton holding a reference to an Activity context via a non‑static inner class. Refactored the singleton to use Application context and made the inner class static. Added WeakReference where appropriate and removed unnecessary listeners in onDestroy.

Memory usage stabilized, leak reports disappeared, and crash rate dropped by 90% on affected devices.

Our product needed to meet accessibility standards for a government contract.

Implement and verify accessibility features across the app.

Added contentDescription to all ImageViews, used TalkBack to navigate the UI, ensured proper focus order with android:focusable, and provided scalable text via sp units. Leveraged Android Accessibility Test Framework (ATF) in CI to detect missing labels. Conducted manual testing with TalkBack and screen magnifier, and fixed contrast issues using the Material Design color guidelines.

App passed the accessibility audit, received certification, and user satisfaction scores for accessibility improved by 25%.