The right Android interview questions help solve one of the biggest challenges for companies that want technical excellence: finding the right person to build their apps. Native Android developers who specialize in Kotlin and Java are key to building apps that are well optimized, stable, and fully integrated with the Android ecosystem. A structured interview helps you spot not only technical skills but also the ability to solve problems and create experiences that meet user needs.
This article gives you a script of questions organized by experience level (junior, mid-level, and senior) so recruiters and engineering managers can run sharper interviews. The goal is a complete assessment that covers command of the technologies, good practices, software architecture, and performance. That raises your odds of hiring developers who ship robust, scalable apps in line with modern Android development.
Junior Android interview questions
When interviewing a junior Android developer, focus on the basics of native development, especially Kotlin and Java, and on the fundamentals of the Android ecosystem. At this stage, more than extensive hands-on experience, you want a solid grasp of core concepts, curiosity, eagerness to learn, and the ability to apply good practices to UI, navigation, and API calls. A well-run interview shows whether the candidate has the foundation to grow quickly and contribute quality work from their first projects.
1. What is an Activity in Android?
It is a component that represents a single screen with a UI. Each Activity manages user interaction with one part of the app.
What to look for: that they tell it apart from other components such as Service or BroadcastReceiver.
2. Explain what a Fragment is.
A Fragment is a reusable component that represents part of the UI or behavior inside an Activity, which allows flexible interfaces.
What to look for: an example, such as a list-detail view on tablets.
3. What is the difference between an Activity and a Fragment?
An Activity is a full screen, while a Fragment is part of one. A Fragment needs an Activity to exist.
What to look for: whether they know many apps now use a single Activity with several navigation destinations.
4. What is the AndroidManifest.xml file for?
It declares the app’s components (Activities, Services, BroadcastReceivers), permissions, and settings the Android system needs.
What to look for: a mention of permissions and intent filters.
5. What is the Activity lifecycle?
It is the set of states an Activity goes through, with methods such as onCreate(), onStart(), onResume(), onPause(), onStop(), and onDestroy(), which control how it is created and destroyed.
What to look for: that they can describe the order without hesitation.
6. Name two Activity lifecycle methods and what they do.
onCreate() initializes the Activity and loads layouts. onPause() is called when the Activity loses focus and is a good moment to save temporary data.
What to look for: whether they explain what to avoid in onPause(), such as heavy work.
7. What is a ViewModel, and what is its benefit?
A ViewModel stores and manages UI-related data and survives configuration changes such as screen rotation.
What to look for: that they connect it to separating UI from logic.
8. What is a RecyclerView, and what is it for?
It is a list component that displays large data sets efficiently, with optimized scrolling and view recycling.
What to look for: whether they know LazyColumn as the Jetpack Compose equivalent.
9. Briefly explain what an Adapter is.
An Adapter connects the data to the RecyclerView and turns each item into a view to display.
What to look for: a mention of the ViewHolder and why it exists.
10. What is an Intent in Android?
It is an object that lets components communicate, for example to open an Activity or send data to another app.
What to look for: whether they separate explicit and implicit intents.
11. What are permissions for in Android?
They control access to sensitive resources such as the camera, location, or storage, protecting user privacy.
What to look for: whether they know many permissions are requested at runtime and how to handle a denial.
12. What are resources in Android?
They are external files such as strings, images, colors, and layouts that help organize the app and translate it into other languages.
What to look for: whether they know alternative resources per language, such as values-es.
13. Name one advantage of using Kotlin for Android development.
Kotlin has a more concise syntax, cuts boilerplate, and offers modern features such as null safety that prevent bugs. It is also Google’s recommended language for Android.
What to look for: that they mention Kotlin is the platform’s preferred language.
14. Explain null safety in Kotlin.
It is a way to avoid null reference errors: it forces the developer to handle cases where a variable can be null.
What to look for: that they explain the ?. and ?: operators and why !! should be used carefully.
15. What is Gradle, and what does it do in Android?
It is a build automation tool. It manages dependencies and configuration and produces the app’s APKs or App Bundles.
What to look for: whether they know Google Play requires the App Bundle format for new apps.
16. How does Android handle different screens and device sizes?
Through alternative resources in folders (layout-sw600dp, drawable-hdpi, and so on), components such as ConstraintLayout and, in Jetpack Compose, adaptive layouts that respond to the available space.
What to look for: a mention of Compose and adaptive layouts.
17. Do you know how to call an API in Android? How?
Yes, with libraries such as Retrofit or with HttpURLConnection you make HTTP requests and handle the responses to show data in the app.
What to look for: that they mention doing it off the main thread.
These questions cover the basics you should expect from a junior. Now on to the next level.
Mid-level Android interview questions
When interviewing a mid-level Android developer, assess not only command of the fundamentals but also the ability to build more robust apps, understand architecture, fix performance issues, and apply good practices.
You should expect hands-on experience with APIs, library integration, version control, and patterns such as MVVM, plus some autonomy on projects. Here are the most useful questions.
18. How would you implement navigation in an Android app with the Jetpack Navigation Component?
I use a Navigation Graph to map destinations and actions, the NavController to drive navigation, and the NavHostFragment (or NavHost in Compose) as the container. That makes the back stack and transitions easier to manage.
What to look for: whether they know how to pass arguments safely between destinations.
19. How do you consume REST APIs in an Android app? Name libraries such as Retrofit or Volley.
I mainly use Retrofit because it is simple and efficient, with Gson, Moshi, or kotlinx.serialization to convert JSON. I also configure OkHttp for interceptors, logging, and error handling.
What to look for: whether they explain what an interceptor does, for example adding an auth token.
20. What is Jetpack Compose, and how does it differ from XML views?
Compose is Android’s modern toolkit for building UIs declaratively with Kotlin functions. Instead of inflating XML layouts and changing views, you describe what the UI should look like for a given state, and Compose updates it when that state changes.
What to look for: real Compose experience. It is now the standard for new projects.
21. Explain the MVVM pattern and how it applies to Android.
MVVM splits responsibilities into Model (data), View (UI), and ViewModel (presentation logic), which makes code more scalable, testable, and organized.
What to look for: that they explain what a ViewModel should not hold, such as references to views or Context.
22. What is LiveData, and how does it work?
It is a lifecycle-aware observable: it only notifies active observers, such as Activities or Fragments, which prevents memory leaks and crashes.
What to look for: whether they compare LiveData with StateFlow, which comes up later.
23. When do you use coroutines in Android?
I use coroutines for asynchronous work such as network calls, database access, and heavy processing, with cleaner and more efficient code.
What to look for: a mention of scopes such as viewModelScope and lifecycleScope.
24. What is Room, and why use it?
Room is a persistence library that wraps SQLite in a safer API, based on annotations, with compile-time checks and integration with LiveData, Flow, and coroutines.
What to look for: whether they know how Room handles schema migrations.
25. How do you handle errors in API calls?
I use try-catch with coroutines, check HTTP status codes in Retrofit, use interceptors, and represent errors with response objects or sealed classes.
What to look for: whether they separate network, server, and data errors and how each is shown to the user.
26. What is a sealed class, and how is it useful in Android?
A sealed class represents a limited, known set of states, such as Success, Error, and Loading, which is very useful for managing UI state.
What to look for: an example with when and why the compiler forces every case to be covered.
27. How do you keep RecyclerView lists fast?
I use the ViewHolder properly, DiffUtil for efficient updates, pagination when needed, and avoid creating unnecessary objects in onBindViewHolder.
What to look for: whether they know the Paging library.
28. Explain the difference between a Service and WorkManager.
A Service runs background work that is usually active and short-lived. WorkManager is recommended for persistent or scheduled work that must survive restarts.
What to look for: whether they know Android’s background execution limits.
29. What is dependency injection, and how do you apply it in Android?
It is a pattern that supplies dependencies from outside and reduces coupling. In Android, libraries such as Hilt or Dagger manage it.
What to look for: whether they explain why it makes testing easier.
30. What is the difference between StateFlow and LiveData?
StateFlow is a hot, state-oriented flow better suited to logic that does not depend on Android. LiveData is lifecycle-aware and focused on the UI. StateFlow is more modern and more common in Kotlin and Compose projects.
What to look for: whether they know how to collect flows in a lifecycle-aware way.
31. How do you handle configuration changes such as screen rotation?
I keep data in a ViewModel, rely on the Navigation Component to preserve the back stack, and save transient state with onSaveInstanceState or SavedStateHandle when needed.
What to look for: whether they know SavedStateHandle survives process death.
32. What is ProGuard, and what does it do in Android?
ProGuard obfuscates, shrinks, and optimizes code, which makes the APK smaller and harder to decompile. Android now uses R8, which does the same job and is the default.
What to look for: whether they know R8 replaced ProGuard and how to write keep rules.
33. What security best practices do you follow in an Android app?
Obfuscation with R8, secure storage of sensitive data with the Keystore or encryption libraries, SSL validation on API calls, and no secrets in the code.
What to look for: that they mention never storing API keys in source code.
34. How do you work with multiple modules in an Android project?
I split the project into modules such as app, data, domain, and features, which improves organization, enables code reuse, and speeds up builds.
What to look for: whether they explain how they avoid circular dependencies between modules.
Validate Android skills with a hands-on challenge first
Questions show how a candidate thinks, but a mobile challenge shows how they work: how they structure the architecture, manage state, and write tests. Running a technical assessment before the interview lets you walk in with evidence.
Try Coodesh technical assessments free
Senior Android interview questions
With a senior Android developer, the focus goes beyond basic and intermediate skills. You should expect deep command of the platform, software architecture, clean code, testing, security, and performance.
It is also essential to assess their ability to make technical decisions, lead teams, propose scalable solutions, and help design robust architectures, while keeping up with mobile development trends.
35. How would you implement a local database with Room?
I define entities with @Entity, create DAOs for CRUD operations with @Dao, and initialize the RoomDatabase as a singleton. I integrate it with coroutines, Flow, or LiveData for asynchronous work.
What to look for: whether they cover migrations, indexes, and testing the data layer.
36. Explain how you would structure an Android app with MVVM or Clean Architecture.
With MVVM, I separate View, ViewModel, and Model. With Clean Architecture, I use layers (data, domain, and presentation) to isolate business rules, abstractions, and frameworks, for code that is scalable, testable, and easy to maintain.
What to look for: that they know when Clean Architecture adds unnecessary complexity.
37. What is WorkManager, and when should you use it?
WorkManager runs asynchronous work that must be guaranteed to finish, even if the app closes or the device restarts. It is ideal for background syncs, uploads, and backups.
What to look for: whether they know network and battery constraints.
38. How do you run unit and UI tests in an Android project?
For unit tests, I use JUnit with MockK or Mockito to mock dependencies and validate business rules. For UI tests, I use Espresso or Compose testing tools to simulate interactions and check UI behavior.
What to look for: what they choose to test and how they keep tests stable.
39. What are Kotlin coroutines, and how do you use them for async work in Android?
Coroutines let you write asynchronous code sequentially. I use suspend functions, viewModelScope for UI-bound work, and Dispatchers.IO for I/O such as network or database calls.
What to look for: whether they understand structured concurrency and cancellation.
40. How do you manage state in Jetpack Compose?
With remember and mutableStateOf for local state, and state hoisting to move state up to the component that owns it. Screen state lives in the ViewModel, exposed through StateFlow, and the UI recomposes when it changes.
What to look for: whether they understand recomposition and how to avoid unnecessary recompositions.
41. Explain how DataBinding and ViewBinding work.
ViewBinding generates type-safe classes to access views and removes the need for findViewById. DataBinding binds data straight to the UI in XML, cutting boilerplate and supporting MVVM.
What to look for: whether they know these tools are unnecessary in Compose projects.
42. How do you secure communication with APIs?
Mandatory HTTPS, certificate pinning, secure authentication (OAuth2, JWT), encryption of sensitive data on the device, and strict validation of responses and errors.
What to look for: whether they know the risks of certificate pinning, such as locking users out when certificates rotate.
43. What are Flow and StateFlow, and when do you use them?
Flow is a cold asynchronous data stream: it starts when someone collects it. StateFlow is hot, keeps the latest value, and is ideal for UI state. I use both with coroutines.
What to look for: whether they know SharedFlow for one-off events.
44. Which practices do you use to optimize Android app performance?
I analyze memory and CPU with the Profiler, use tools such as LeakCanary, optimize layouts, avoid overdraw, apply lazy loading, and use DiffUtil in lists. In Compose, I keep parameters stable to reduce recompositions.
What to look for: that they start by measuring and know Baseline Profiles.
45. Explain the Fragment lifecycle and its challenges.
A Fragment goes through states such as onAttach, onCreate, onCreateView, through to onDestroyView and onDetach. The challenge is managing state and avoiding leaks when the view is destroyed but the Fragment is still alive.
What to look for: whether they know viewLifecycleOwner and why it matters.
46. How do you implement biometric authentication in Android?
With the BiometricPrompt API, which supports fingerprint, face, or other methods, with a PIN or password fallback, for both security and a better user experience.
What to look for: whether they know how to tie biometrics to Keystore keys.
47. What are the main challenges of building for different screen sizes and densities?
I adapt layouts with ConstraintLayout and guidelines, use density-specific dimensions and, in Compose, adaptive layouts and window size classes. I also test on emulators and a range of devices, including foldables and tablets.
What to look for: a mention of foldables and window size classes.
48. How do you manage dependencies in Android?
I use Hilt, a simplified layer over Dagger, for dependency injection, which reduces coupling, improves testability, and handles lifecycles well. For libraries, I use Gradle version catalogs.
What to look for: whether they know Gradle version catalogs.
49. How do you handle concurrency and synchronization in Android?
I use coroutines with the right dispatchers and, when I need synchronization, Mutex or Channel, to avoid race conditions and deadlocks.
What to look for: a real race condition they solved.
50. Explain your approach to publishing and maintaining an app on Google Play.
I follow a release checklist (testing, performance, security), set up signing, prepare the store listing and policies, and monitor crashes and metrics with Firebase Crashlytics and the Play Console. I use staged rollouts to reduce risk.
What to look for: whether they know staged rollouts and how to react to a spike in crashes.
How to use these Android interview questions
To use these questions well, match the level of difficulty to the candidate. For junior roles, choose questions that check the basics and the ability to learn and adapt.
At mid and senior levels, prioritize questions about hands-on experience, architecture, good practices, and solving complex problems. That keeps the questions aligned with the role and makes the assessment fairer and more accurate.
During the interview, look beyond the technical content to how clearly the candidate explains concepts. Clear explanations show real command of the subject and good communication, which matters on collaborative teams.
As a follow-up, propose practical scenarios or challenges based on their first answers to test critical thinking and how they apply knowledge in real Android work. You will get a fuller picture of each candidate’s potential.
Related reading
- Java Interview Questions: 30 Questions to Hire Developers
- React Interview Questions: 50 Questions and Answers
- Online Coding Tests: A Strategic Way to Assess Developers
- Coodesh technical assessments: coding challenges, SQL, QA, and more
Conclusion
Well-crafted questions combined with hands-on challenges are key to finding the right native Android developer, someone who ships efficient solutions that fit the team’s needs. A structured interview lets you assess not only technical knowledge but also the ability to solve real problems and adapt to the work environment. For technical detail, the official Android documentation is the reference.
Assess Android developers on evidence
Coodesh lets you run detailed, customized technical assessments so you can pick the best mobile candidates quickly and accurately.
Try Coodesh technical assessments free
Large company or custom needs? Book a demo with our team.

