Android Developer Interview Questions and Answers

What drew you to Android development specifically?

I like that Android puts a huge, diverse device base in people's hands, so the work I do reaches users on everything from budget phones to foldables. I started building small utility apps in college and got hooked on the feedback loop of shipping to the Play Store and watching real usage come back. Over time I moved deeper into the platform, from the activity lifecycle to Jetpack, because I enjoy solving the constraints that come with limited memory and battery. That mix of craft and reach is what keeps me in this ecosystem.

Walk me through an Android app you shipped end to end.

I built a field-service app that let technicians log jobs offline and sync when connectivity returned. I owned it from architecture through release, choosing an MVVM structure with Room for local persistence and WorkManager for background sync. The hardest part was conflict resolution when two devices edited the same record, which I solved with a last-write-wins plus audit-log approach. It went from prototype to production in about four months and cut paperwork time for the field team noticeably.

How do you keep up with changes in the Android platform?

I follow the official Android Developers blog and release notes closely because the platform shifts fast, especially around background execution limits and privacy. I watch the key Google I/O sessions each year and read the Now in Android updates to catch API deprecations early. When something like a new permission model lands, I build a small test project to feel how it behaves before committing it to production code. That habit has saved me from surprise breakages when targeting new API levels.

What kind of team and codebase do you work best in?

I do my best work in a team that reviews code seriously and treats the app architecture as a shared asset rather than one person's territory. I like a codebase with a clear module structure, real test coverage, and CI that catches regressions before they reach a device. I am comfortable in fast-moving product teams as long as we agree on conventions up front. What I want to avoid is a codebase where every screen reinvents its own patterns.

How do you decide between an MVVM, MVI, or MVP architecture for an app?

I default to MVVM with Jetpack ViewModel because it maps cleanly to lifecycle-aware state and is well supported across the ecosystem. I reach for MVI when a screen has complex, interdependent state and I want a single immutable state object and a predictable event flow, which makes bugs easier to reproduce. MVP I mostly see in older codebases and would only keep for consistency. The real driver is state complexity and team familiarity, not chasing the newest pattern.

How do you handle background work given modern Android execution limits?

I match the tool to the guarantee I need: WorkManager for deferrable, guaranteed work like syncing, coroutines with a foreground service for user-visible ongoing tasks, and AlarmManager only for exact-time triggers. I assume the system can kill my process at any time, so I make work idempotent and persist state before starting it. I also test under Doze and background restrictions on real devices because emulators hide a lot of that behavior. This keeps sync reliable without draining battery or getting the app flagged.

How do you approach memory leaks and performance profiling on Android?

I use the Android Studio Profiler and LeakCanary in debug builds to catch leaks early, and the usual culprits are retained context references, unregistered listeners, and static holders. For jank I capture a systrace or use the Profiler's frame timeline to find work happening on the main thread. Once I find a hotspot I move heavy work off the UI thread with coroutines and cache expensive results. On one app this took a scrolling list from dropping frames to a consistently smooth experience.

What is your experience with Jetpack Compose versus the older View system?

I have shipped production screens in both and now prefer Compose for new work because declarative UI removes a whole class of state-sync bugs I used to hit with findViewById and manual updates. I am comfortable with state hoisting, remember, and side-effect APIs like LaunchedEffect, and I know how to avoid unnecessary recomposition by keeping state stable. That said, I am pragmatic about interop in a large legacy app and will embed Compose in existing View hierarchies rather than force a big-bang rewrite. Understanding the old system also helps me debug why a migrated screen behaves differently.

How do you manage dependency injection in an Android project?

I use Hilt on most projects because it is built on Dagger but removes a lot of the boilerplate and integrates cleanly with ViewModels and WorkManager. I scope dependencies deliberately, keeping things like the Retrofit client as singletons while scoping feature-specific objects to their component. This keeps the object graph clear and makes it easy to swap fakes in tests. On a smaller module I would consider a lighter option like Koin, but for a large multi-module app Hilt's compile-time safety is worth it.

How do you handle supporting a wide range of screen sizes and API levels?

I design layouts with ConstraintLayout or Compose adaptive APIs so they respond to width rather than hardcoding dimensions, and I test on phone, tablet, and foldable configurations. For API levels I set a sensible minSdk based on our analytics and guard newer APIs with version checks or compat libraries like AppCompat and the AndroidX equivalents. I keep the target SDK current to stay compliant with Play requirements. Testing on real low-end devices, not just flagships, is where I catch the issues that matter most.

Describe your process for publishing and rolling out a release on the Play Store.

I use staged rollouts, releasing to a small percentage first while watching crash rates and ANRs in the Play Console and our crash reporting tool. I ship internal and closed testing tracks before production so QA and stakeholders can validate on real installs. I keep release notes and versioning disciplined and use the App Bundle so Google generates optimized APKs per device. If crash-free sessions dip, I can halt the rollout before it reaches everyone, which has saved us from a bad release more than once.

How do you debug a crash that only happens on certain devices in production?

I start in the crash reporting tool, grouping by device model, OS version, and manufacturer to spot patterns, since OEM customizations often cause device-specific issues. I pull the stack trace and any breadcrumbs, then try to reproduce on a matching emulator image or a physical device from a device lab. If it is a manufacturer quirk, like an aggressive battery killer, I add defensive handling and document it. I also add more logging around the suspect path so the next occurrence gives me more to work with.

How do you secure sensitive data and API keys in an Android app?

I never store secrets in plain SharedPreferences or hardcode API keys in source, since APKs can be decompiled. For user data I use EncryptedSharedPreferences or the Keystore-backed crypto APIs, and for tokens I keep them off disk where possible. Real secrets that must be protected live server-side behind an authenticated endpoint rather than in the client. I also enable network security config to enforce TLS and certificate pinning on sensitive calls.

Tell me about a time you disagreed with a designer or product manager over an implementation.

A designer wanted a custom navigation pattern that looked great but broke the predictable back-button behavior Android users expect. I raised it early with a quick prototype showing where users would get confused, rather than just objecting in a meeting. We compromised on a design that kept the visual style but respected system navigation. The result shipped without the usability complaints I was worried about, and it taught me to bring evidence instead of opinions.

Describe a time you took ownership of a problem outside your assigned work.

Our app's cold start time had crept up and nobody owned it, so I profiled the startup path on my own time and found we were doing heavy initialization on the main thread at launch. I documented the findings, deferred non-critical init with App Startup and lazy loading, and brought a before-and-after trace to the team. Start time dropped by roughly a third. After that the team made startup metrics part of our regular monitoring so it would not silently regress again.

Tell me about a release that went wrong and how you handled it.

We once shipped an update where a serialization change corrupted locally cached data for users upgrading from an old version. Crash reports spiked within an hour, so I halted the staged rollout immediately to cap the blast radius. I wrote a migration that detected and rebuilt the bad cache, verified it against a copy of the old data, and pushed a hotfix. Afterward I added upgrade-path tests to our CI so schema changes are always validated against previous versions.

Give an example of how you grew from feedback in a code review.

Early on a senior reviewer pointed out that I was leaking coroutine scopes by launching work that outlived the screen. It stung a little, but they took time to explain structured concurrency and lifecycle-aware scopes. I reworked my approach to use viewModelScope and lifecycleScope consistently, and I started reviewing my own diffs for that pattern. It made my code more reliable and I now pass that same lesson on to newer developers.

If users reported the app draining battery overnight, how would you investigate?

I would start with Battery Historian and the Play Console's Android vitals to see whether the drain comes from wakelocks, network, or excessive background jobs. I would audit anything scheduling frequent work, like a misconfigured sync interval or a location request that never releases. Once I isolated the cause I would move the work to WorkManager with proper constraints and back off the frequency. Then I would validate the fix on a real device over a full charge cycle before rolling it out.

Suppose a new OS version breaks a core feature right after release. What do you do?

First I would confirm the scope by checking crash and vitals data filtered to that OS version to see how many users are affected. I would reproduce it on a device or emulator running that version, then check the platform release notes for behavior changes, since these breakages usually trace to a tightened permission or deprecated API. I would ship a targeted fix or graceful fallback quickly, using a staged rollout, and communicate a clear timeline to support. If it is severe, a feature flag lets me disable the affected path while I finish the proper fix.

Imagine product wants a feature that requires a permission many users will decline. How do you handle it?

I would design for the declined case first, so the app still delivers value without the permission rather than blocking users at a wall. I would request the permission in context, right when the benefit is clear, and explain why we need it in plain language. I would also add a rationale flow for users who declined once and a graceful path to settings if they change their mind. I would bring the expected grant rates to product so we set realistic goals instead of assuming everyone opts in.