300 Android Developer Interview Questions & Answers
1. Android Fundamentals — 1–30
1. What is Android? Android is a Linux-based mobile operating system and application platform primarily developed by Google. Android apps are commonly written in Kotlin or Java and run on the Android Runtime (ART).
2. What is an Android Activity? An Activity represents a screen or entry point into an Android application. It owns a window and participates in the Activity lifecycle.
3. What is the Activity lifecycle? The main callbacks are onCreate(), onStart(), onResume(), onPause(), onStop(), and onDestroy().
4. What is onCreate() used for? It is used for initial setup such as inflating UI, initializing dependencies, configuring observers, and restoring state.
5. What is onStart()? It means the Activity has become visible to the user but may not yet be interactive.
6. What is onResume()? The Activity is in the foreground and ready for user interaction.
7. What is onPause()? The Activity is losing focus. It should perform lightweight work because the callback should return quickly.
8. What is onStop()? The Activity is no longer visible.
9. What is onDestroy()? The Activity is being destroyed, either because it is finishing or because the system is recreating it.
10. What is an Activity recreation? Android can destroy and recreate an Activity, for example after configuration changes such as rotation.
11. What is a Fragment? A Fragment is a reusable UI/controller component hosted inside an Activity or another Fragment.
12. Why use Fragments? They can provide reusable screens, navigation destinations, lifecycle-aware UI components, and modular UI.
13. What is a Fragment lifecycle? It has both a Fragment lifecycle and a separate view lifecycle. Important callbacks include onCreate, onCreateView, onViewCreated, onStart, onResume, onPause, onStop, and onDestroyView.
14. Why is onDestroyView() important? A Fragment can remain alive after its view is destroyed. View references should be cleared there to prevent memory leaks.
15. What is a Context? Context provides access to application resources, system services, package information, and application-level operations.
16. Difference between Activity Context and Application Context? An Activity Context is tied to an Activity lifecycle and UI. Application Context lives as long as the application process and is appropriate for long-lived objects.
17. What is an Intent? An Intent is a messaging object used to request an action from another Android component.
18. Explicit vs implicit Intent? An explicit Intent identifies a specific component. An implicit Intent describes an action and lets Android find a compatible component.
19. What is a BroadcastReceiver? It receives broadcast messages from Android or applications.
20. What is a Service? A Service is an Android component for work that can continue without a traditional UI, although modern Android places significant restrictions on background execution.
21. What is a foreground service? A foreground service performs user-visible ongoing work and must normally display a notification.
22. What is a ContentProvider? A ContentProvider exposes structured data to other applications through a standardized API.
23. What is AndroidManifest.xml? It declares application components, permissions, services, receivers, providers, and other application metadata.
24. What is an APK? An APK is an Android application package containing compiled code, resources, and metadata.
25. What is an AAB? Android App Bundle is a publishing format from which Google Play can generate optimized APKs for users’ devices.
26. What is Android Runtime (ART)? ART executes Android application bytecode and provides features such as garbage collection and runtime optimization.
27. What is a DEX file? DEX contains Android executable bytecode optimized for the Android runtime.
28. What is the Android main thread? It is the UI thread responsible for processing UI events, drawing, and many framework callbacks.
29. Why shouldn’t expensive work run on the main thread? It can block UI processing and cause dropped frames, ANRs, and poor user experience.
30. What is an ANR? ANR means Application Not Responding. It occurs when an application fails to respond to important system events within required time limits.
2. Kotlin — 31–70
31. Why is Kotlin popular for Android? It provides concise syntax, null safety, coroutines, extension functions, smart casts, sealed classes, and strong Java interoperability.
32. val vs var? val is read-only after initialization. var can be reassigned.
33. What is null safety? Kotlin’s type system distinguishes nullable and non-nullable types to reduce null pointer exceptions.
34. What does String? mean? It means the variable may contain a String or null.
35. What is the safe-call operator ?.? It executes an operation only when the receiver isn’t null.
36. What does !! do? It asserts that a nullable value isn’t null. If it is null, Kotlin throws NullPointerException.
37. What is the Elvis operator? ?: provides a fallback when an expression is null.
38. What is a data class? A class designed primarily to hold data. Kotlin automatically generates methods such as equals, hashCode, toString, and copy.
39. What is a sealed class? A restricted class hierarchy useful for representing a fixed set of states or outcomes.
40. Why use sealed classes in UI state? They make states explicit and allow exhaustive when handling.
41. What is an extension function? It allows adding callable functionality to an existing type without modifying the type itself.
42. What is a higher-order function? A function that accepts another function as an argument or returns one.
43. What is a lambda? An anonymous function that can be passed as a value.
44. What is let? A scope function commonly used for nullable values or transforming an object within a scoped block.
45. What is apply? It executes a block with the receiver as this and returns the receiver.
46. What is also? It executes a block with the receiver as it and returns the receiver, commonly useful for side effects.
47. What is run? It executes a block with the receiver as this and returns the block result.
48. What is with? It executes a block against an object and returns the block result.
49. What is an object declaration? It creates a singleton object.
50. What is a companion object? It provides class-associated members similar to Java static members.
51. What is delegation? Kotlin allows behavior to be delegated to another object using the by keyword.
52. What is lateinit? It allows a non-null mutable property to be initialized later.
53. When shouldn’t lateinit be used? Avoid it when a property can naturally be nullable or initialized immediately.
54. What is lazy initialization? A property is initialized only when it is first accessed.
55. == vs ===? == checks structural equality. === checks reference identity.
56. What is smart casting? Kotlin automatically treats a value as a more specific type after successful type checks when safe.
57. What is an inline function? The compiler can insert the function body at the call site, reducing some lambda/object allocation overhead.
58. What is a reified type parameter? A type parameter available at runtime inside an inline function.
59. What is an enum class? A type representing a fixed set of named constants.
60. What is destructuring? It allows extracting multiple values from an object into separate variables.
61. What is copy() in a data class? It creates a new instance while allowing selected properties to change.
62. What is immutability? An immutable object cannot be modified after creation.
63. Why prefer immutable data? It reduces unexpected state changes and makes concurrent code easier to reason about.
64. What is a Sequence? A lazily evaluated collection-processing abstraction useful when chaining operations over potentially large datasets.
65. List vs Set? A List preserves order and can contain duplicates. A Set represents unique elements.
66. MutableList vs List? List exposes read-only operations; MutableList allows modification.
67. What is exception handling in Kotlin? Use try, catch, and finally.
68. Does Kotlin have checked exceptions? No. Kotlin does not enforce checked exceptions.
69. What is a value class? A lightweight type wrapper that can provide stronger type safety with potentially reduced runtime overhead.
70. What is structured concurrency? It ensures coroutines have defined lifetimes and parent-child relationships, making cancellation and failure propagation manageable.
3. Coroutines & Flow — 71–105
71. What is a coroutine? A coroutine is a lightweight unit of asynchronous work that can suspend without blocking a thread.
72. What is suspend? It marks a function that can suspend execution and resume later.
73. Does suspend automatically create a background thread? No. A suspend function can execute on whatever dispatcher/thread context invokes it.
74. What is CoroutineScope? It defines the lifecycle within which coroutines execute.
75. What is Dispatchers.Main? Used for UI-related work.
76. What is Dispatchers.IO? Designed for blocking I/O operations such as file and database access.
77. What is Dispatchers.Default? Designed primarily for CPU-intensive work.
78. What is launch? Starts a coroutine and returns a Job.
79. What is async? Starts a coroutine that produces a result represented by Deferred.
80. launch vs async? Use launch for fire-and-forget work and async when you need a result.
81. What is await()? It suspends until a Deferred result is available.
82. What is coroutine cancellation? Cancellation requests a coroutine to stop executing.
83. Why is cooperative cancellation important? Coroutines need to reach suspension points or explicitly check cancellation to respond promptly.
84. What is isActive? A property used to determine whether the coroutine is still active.
85. What does withContext() do? Temporarily changes the coroutine context, commonly to switch dispatchers.
86. What is supervisorScope? It allows child coroutines to fail independently without automatically cancelling sibling coroutines.
87. What is SupervisorJob? A Job where failure of one child doesn’t automatically cancel other children.
88. What is a Flow? A Flow represents an asynchronous stream of values.
89. Cold Flow vs hot Flow? A cold Flow starts producing when collected. Hot streams exist independently of collectors.
90. What is StateFlow? A hot observable state holder that always has a current value.
91. What is SharedFlow? A hot stream designed for broadcasting events or values to multiple collectors.
92. StateFlow vs SharedFlow? StateFlow represents current state; SharedFlow is better suited to events or broadcasts.
93. What is collect? It starts collecting values emitted by a Flow.
94. What is collectLatest? It cancels processing of the previous value when a newer value arrives.
95. What is map in Flow? Transforms emitted values.
96. What is filter? Allows only values satisfying a condition.
97. What is debounce? It delays emissions until there has been no new value for a specified period.
98. Why use debounce for search? It prevents making a network request for every individual keystroke.
99. What is flatMapLatest? It switches to a new Flow and cancels collection of the previous one when a new value arrives.
100. What is flowOn? It changes the upstream execution context.
101. What is StateFlow replay behavior? A new collector immediately receives the current state value.
102. What is repeatOnLifecycle? It starts collecting when the lifecycle reaches a specified state and cancels collection when it falls below it.
103. Why use viewModelScope? It automatically cancels coroutines when the ViewModel is cleared.
104. Why use lifecycleScope? It ties coroutines to an Activity or Fragment lifecycle.
105. How would you prevent duplicate API calls? Use debouncing, caching, request deduplication, state management, and appropriate coroutine/Flow operators.
4. Architecture — 106–145
106. What is MVVM? Model-View-ViewModel separates UI rendering from UI state and business/data logic.
107. What is the ViewModel responsible for? Managing UI-related state and coordinating application logic while surviving configuration changes.
108. Should ViewModel contain Android Views? Generally no. ViewModels should not hold references to Activities, Fragments, Views, or other short-lived UI objects.
109. What is Clean Architecture? An architectural approach that separates concerns into layers and makes business rules independent of UI and infrastructure.
110. Typical Clean Architecture layers? Presentation, domain, and data.
111. What is the domain layer? It contains business rules and use cases.
112. What is the data layer? It manages repositories, remote APIs, databases, caches, and data sources.
113. What is a Repository? It provides a clean abstraction over data sources.
114. Why use repositories? They hide data-source details from higher layers and make testing easier.
115. What is dependency injection? Providing dependencies to an object instead of having that object construct them itself.
116. Why use dependency injection? It improves modularity, testability, maintainability, and configuration.
117. What is Hilt? A dependency injection framework built on Dagger and designed for Android.
118. What is Dagger? A compile-time dependency injection framework.
119. What is a use case? A class/function representing a specific business operation.
120. Why use use cases? They centralize business rules and make application operations easier to test and reuse.
121. What is Single Responsibility Principle? A class should have one primary reason to change.
122. What is Open/Closed Principle? Software should be open for extension but closed for modification.
123. What is Liskov Substitution Principle? Subtypes should be usable wherever their base types are expected without breaking correctness.
124. What is Interface Segregation Principle? Clients shouldn’t be forced to depend on interfaces they don’t use.
125. What is Dependency Inversion Principle? High-level modules should depend on abstractions rather than concrete implementations.
126. What is unidirectional data flow? State flows toward the UI, while user actions/events flow back toward the state owner.
127. Why is UDF useful? It makes state transitions predictable and easier to debug.
128. What is UI state? A representation of everything the UI needs to render at a given moment.
129. What is state hoisting? Moving state ownership to a higher-level component so it can be shared or controlled.
130. What is separation of concerns? Dividing software into components with distinct responsibilities.
131. What is modularization? Splitting an application into independent Gradle modules.
132. Why modularize Android apps? It can improve build performance, ownership boundaries, reuse, and dependency management.
133. What is feature-based architecture? Organizing modules or packages around product features rather than technical layers alone.
134. What is dependency inversion in Android? For example, a ViewModel can depend on a repository interface instead of directly depending on Retrofit.
135. Where should mapping occur? Typically at boundaries between layers, such as API DTO → domain model and domain model → UI model.
136. Why shouldn’t API DTOs be used everywhere? It couples the application to the backend representation.
137. What is a DTO? A Data Transfer Object represents data exchanged with an external system.
138. What is a domain model? A model representing business concepts independently of infrastructure.
139. What is a UI model? A model optimized for presentation.
140. What is MVI? A unidirectional architecture commonly built around Intent/Event → State → UI.
141. MVVM vs MVI? Both can use unidirectional flow; MVI generally emphasizes a single state model and explicit events/reducers.
142. What causes architecture to become over-engineered? Too many abstractions, layers, interfaces, and patterns without meaningful complexity to justify them.
143. How do you choose architecture? Based on product complexity, team size, scalability requirements, testability, and expected evolution.
144. What is state restoration? Restoring UI state after process death or configuration changes.
145. What should survive configuration changes? Important UI/business state should normally live in a ViewModel or saved-state mechanism rather than only in an Activity.
5. Jetpack Compose — 146–185
146. What is Jetpack Compose? Android’s modern declarative UI toolkit.
147. What is a Composable? A function annotated with @Composable that describes part of the UI.
148. What is recomposition? Compose re-executes affected composable functions when observed state changes.
149. Is recomposition the same as recreating the Activity? No. Recomposition updates Compose UI and is much more granular.
150. What is remember? It stores a value across recompositions.
151. What is rememberSaveable? It stores values that can survive configuration changes and certain state restoration scenarios when the value is saveable.
152. What is state hoisting in Compose? Moving state from a composable into its caller.
153. Why hoist state? To make composables reusable, testable, and easier to control.
154. What is mutableStateOf? Creates observable Compose state.
155. What is LaunchedEffect? Runs a coroutine tied to the lifecycle of a composition and restarts when its keys change.
156. What is DisposableEffect? Runs setup code and provides cleanup when keys change or the composable leaves composition.
Get Yodgorbek Komilov’s stories in your inbox
Join Medium for free to get updates from this writer.
157. What is SideEffect? Publishes Compose state to non-Compose code after successful recomposition.
158. What is derivedStateOf? Creates state derived from other state and can avoid unnecessary recalculations when dependencies haven’t meaningfully changed.
159. What is snapshotFlow? Converts Compose snapshot state reads into a Flow.
160. What is key() used for? It provides identity for composable content, helping Compose correctly track items across changes.
161. Why provide keys in LazyColumn? Stable keys help Compose maintain item identity when list items are inserted, removed, or reordered.
162. What is LazyColumn? A vertically scrolling list that composes items lazily.
163. LazyColumn vs Column? LazyColumn only composes visible/needed items; Column composes all its children.
164. What is Modifier? A composable abstraction used to decorate or configure UI elements.
165. Why is Modifier order important? Modifiers are applied sequentially, so changing their order can change layout, drawing, and interaction behavior.
166. What is MaterialTheme? Provides Material design colors, typography, shapes, and related theming.
167. What is CompositionLocal? A mechanism for providing values implicitly through the Compose tree.
168. What is rememberUpdatedState? Allows long-lived effects to access the latest value without restarting the effect.
169. What is derivedStateOf useful for? For example, computing whether a scroll position indicates a button should be shown.
170. How do you avoid unnecessary recomposition? Use stable state, stable keys, appropriate state ownership, remember, immutable models, and avoid expensive work inside composables.
171. Should composables perform network calls directly? Generally no. Network work belongs in ViewModels/use cases/data layers.
172. How should Compose observe ViewModel state? Commonly through lifecycle-aware Flow collection such as collectAsStateWithLifecycle().
173. What is stateless UI? A composable receives state and callbacks rather than owning business state itself.
174. Why prefer stateless composables? They are easier to preview, test, reuse, and reason about.
175. What is a Preview? A development-time mechanism for rendering composables inside Android Studio.
176. What is recomposition skipping? Compose can skip recomposing certain composables when inputs are known to remain unchanged.
177. What is stability in Compose? A property describing whether Compose can safely reason about changes to a type.
178. Why can mutable collections cause Compose issues? Mutating a collection without observable state changes may not notify Compose that UI needs updating.
179. How should you represent UI states? For example: Loading, Success, Empty, and Error, often using sealed types or state models.
180. What is rememberCoroutineScope()? Provides a coroutine scope tied to the composable’s composition.
181. When should you use rememberCoroutineScope()? For event-driven coroutine actions such as showing a Snackbar.
182. What is AnimatedVisibility? A Compose API for animating content appearing and disappearing.
183. What is LazyRow? A horizontally scrolling lazy list.
184. What is Box? A layout composable that stacks children on top of each other.
185. What is ConstraintLayout in Compose? A constraint-based layout library useful for complex relative positioning.
6. Networking — 186–215
186. What is Retrofit? A type-safe HTTP client abstraction commonly used with OkHttp.
187. What is OkHttp? An HTTP client providing connections, requests, responses, interceptors, caching, and more.
188. What is an interceptor? A component that can inspect or modify requests/responses.
189. Application vs network interceptor in OkHttp? They differ in where they operate in the request/response chain and how they interact with redirects, retries, and caching.
190. How do you add authentication headers? Typically with an OkHttp interceptor or an authentication mechanism such as an Authenticator, depending on the requirement.
191. Interceptor vs Authenticator? An interceptor can add headers to requests; an Authenticator is designed to react to authentication challenges such as HTTP 401.
192. How do you handle token expiration? Detect authentication failure, refresh the token safely, retry the request when appropriate, and prevent multiple simultaneous refreshes.
193. What is REST? An architectural style commonly used for HTTP APIs around resources and standard HTTP semantics.
194. GET vs POST? GET generally retrieves data. POST generally submits data or requests creation/processing.
195. PUT vs PATCH? PUT commonly represents replacement/update semantics; PATCH represents partial modification.
196. What is HTTP 200? Successful request.
197. What is HTTP 201? Resource successfully created.
198. What is HTTP 204? Successful request with no response body.
199. What is HTTP 400? Bad request.
200. What is HTTP 401? Authentication is required or credentials are invalid.
201. What is HTTP 403? The server understood the request but refuses authorization.
202. What is HTTP 404? Resource not found.
203. What is HTTP 409? Conflict with the current state of the resource.
204. What is HTTP 429? Too many requests/rate limiting.
205. What is HTTP 500? Internal server error.
206. How should API errors be modeled? Translate transport/API errors into application-level error types rather than exposing Retrofit/OkHttp details throughout the UI.
207. What is serialization? Converting objects into a format suitable for transmission or storage.
208. What is JSON? A lightweight text format commonly used for structured API data.
209. What is pagination? Retrieving large datasets in smaller chunks.
210. Offset vs cursor pagination? Offset pagination uses positions/pages. Cursor pagination uses a server-provided position/token and is often more robust for changing datasets.
211. What is retry with exponential backoff? Increasing the delay between repeated attempts to reduce load and improve resilience.
212. When should you retry? Usually for transient failures, not for permanent client errors such as invalid input.
213. What is idempotency? An operation is idempotent when repeating it has the same intended effect as performing it once.
214. How do you handle offline networking? Use local caching, connectivity-aware behavior, synchronization, and clear UI states.
215. How do you secure API communication? Use HTTPS, secure credential storage, appropriate authentication, certificate validation, and avoid logging sensitive information.
7. Room & Data — 216–240
216. What is Room? Android’s Jetpack persistence library providing an abstraction over SQLite.
217. What are the main Room components? Database, Entity, and DAO.
218. What is an Entity? A class representing a database table.
219. What is a DAO? Data Access Object containing database operations.
220. Why use Room instead of raw SQLite? Room provides compile-time SQL validation, convenient mapping, coroutine/Flow integration, and less boilerplate.
221. What is a primary key? A column or set of columns uniquely identifying a row.
222. What is a foreign key? A constraint connecting a row to a record in another table.
223. What is a database migration? A controlled schema change from one database version to another.
224. Why are migrations important? Users already have installed databases; changing schema without migration can cause crashes or data loss.
225. What is a transaction? A group of operations executed atomically.
226. What does ACID mean? Atomicity, Consistency, Isolation, Durability.
227. Can Room return Flow? Yes. Room can expose observable queries using Flow.
228. What happens when observed Room data changes? The Flow can emit updated data and the UI can react.
229. What is DataStore? A modern storage solution for small amounts of key-value or typed application data.
230. DataStore vs Room? DataStore is suited to preferences or small typed state; Room is suited to relational structured datasets.
231. SharedPreferences vs DataStore? DataStore provides asynchronous, coroutine-friendly APIs and stronger consistency guarantees for its intended usage.
232. Where should database models be mapped? Prefer mapping at architectural boundaries so database schema doesn’t leak through the application.
233. What is caching? Storing previously retrieved data for faster access and/or offline availability.
234. Cache-first strategy? Return local data quickly and refresh it from the network when appropriate.
235. Network-first strategy? Try the network first and fall back to local data when necessary.
236. What is stale-while-revalidate? Show cached data immediately while asynchronously refreshing it from the network.
237. How do you prevent stale UI? Use observable state, cache invalidation rules, timestamps/versioning, and explicit refresh behavior.
238. What is cache invalidation? Determining when stored data is no longer considered valid.
239. Why is cache invalidation difficult? Because multiple sources and concurrent updates can create consistency problems.
240. How would you design offline-first Android? Treat the local database as the primary UI source, synchronize with the server, queue writes when offline, and reconcile conflicts.
8. Android Lifecycle & State — 241–255
241. What happens during screen rotation? Typically the Activity is recreated, while ViewModel instances survive as long as their associated scope survives.
242. What is process death? Android can kill an application’s process when resources are needed. The app may later be recreated.
243. Does ViewModel survive process death? No. ViewModel survives configuration changes but not complete process death.
244. How can state survive process death? Use mechanisms such as SavedStateHandle, persistent storage, or server/local data.
245. What is SavedStateHandle? A key-value mechanism available to ViewModels for saving/restoring small pieces of state.
246. Why shouldn’t large objects go into saved instance state? Saved state is intended for small amounts of state and can cause transaction/binder size problems.
247. What is lifecycle-aware observation? Observing data only while the UI lifecycle is in an appropriate state.
248. Why is lifecycle awareness important? It prevents unnecessary work, leaks, and updates to inactive UI.
249. What is a memory leak? When objects remain reachable even though they are no longer needed.
250. Common Android memory leak? A long-lived object holding a reference to an Activity, Fragment, View, or Context.
251. How can you detect leaks? Tools such as LeakCanary and Android Studio Memory Profiler can help.
252. What is configuration state? State affected by changes such as orientation, screen size, locale, or UI mode.
253. Should network responses be stored in Activities? No. Activities should render state; persistent UI/business state belongs elsewhere.
254. What is lifecycle-aware Flow collection? Collecting Flow only while the lifecycle is active, commonly with repeatOnLifecycle.
255. Why can collecting Flow directly in a Fragment be dangerous? If not lifecycle-aware, collection may continue while the view is inactive or destroyed.
9. Testing — 256–275
256. What is unit testing? Testing small pieces of code independently, usually without Android framework dependencies.
257. What is instrumentation testing? Tests that execute on an Android device or emulator.
258. What is UI testing? Testing UI behavior and interaction.
259. What is a test double? A replacement for a real dependency during testing.
260. Mock vs fake? A mock is generally configured to verify interactions; a fake is a working simplified implementation.
261. Why inject dependencies in tests? It allows production dependencies to be replaced with test implementations.
262. How do you test a ViewModel? Inject fake repositories/use cases and verify emitted state and behavior.
263. How do you test Flow? Collect it in a controlled test environment and assert emitted values.
264. How do you test coroutines? Use coroutine testing utilities and controlled dispatchers/schedulers.
265. What is a repository fake? An in-memory implementation that behaves similarly to a repository but avoids real networking/database access.
266. What should unit tests avoid? Real network calls, unpredictable timing, external services, and unnecessary Android dependencies.
267. What is test isolation? Each test should be independent and should not rely on another test’s state.
268. What is code coverage? A measurement of how much code is exercised by tests.
269. Does high coverage guarantee quality? No. Tests must verify meaningful behavior, not merely execute lines.
270. What is regression testing? Testing existing functionality after changes to ensure previously working behavior remains correct.
271. What is Espresso? An Android UI testing framework.
272. What is Compose UI testing? Testing Compose semantics and UI interactions through Compose testing APIs.
273. What is screenshot testing? Comparing rendered UI output against expected images.
274. What is contract testing? Testing that communication between components/services follows an agreed contract.
275. What makes a good Android test? It should be deterministic, isolated, readable, fast, and focused on observable behavior.
10. Performance — 276–290
276. How do you improve Android startup time? Reduce initialization work, defer nonessential initialization, optimize dependency setup, and profile startup.
277. What is jank? Visible stuttering caused by frames missing their rendering deadlines.
278. How do you investigate jank? Use profiling tools such as Perfetto, Android Studio profiling, Macrobenchmark, and frame/rendering metrics.
279. What causes UI jank? Expensive work on the main thread, excessive layout/recomposition, rendering complexity, GC pressure, or inefficient scrolling.
280. How do you optimize RecyclerView? Use efficient item layouts, DiffUtil/ListAdapter, stable data handling, view recycling correctly, and avoid expensive binding work.
281. How do you optimize LazyColumn? Use stable keys, avoid expensive computations during composition, use appropriate item content, and minimize unnecessary state changes.
282. What is overdraw? Drawing the same screen pixels multiple times unnecessarily.
283. How do you reduce overdraw? Remove unnecessary backgrounds/layers and simplify UI hierarchy.
284. What is memory pressure? When the application consumes significant memory and approaches system limits.
285. What causes OutOfMemoryError? Large allocations, memory leaks, oversized bitmaps, excessive caches, or retained objects.
286. How should images be loaded? Use an image-loading library with appropriate sizing, caching, lifecycle handling, and memory management.
287. Why resize images before displaying them? Loading a huge bitmap when only a small display size is needed wastes memory.
288. What is baseline profiling? Providing runtime optimization information that can improve application performance, especially startup and common code paths.
289. What is Macrobenchmark? A Jetpack benchmarking tool for measuring larger user journeys and app-level performance.
290. How do you verify a performance fix? Measure a baseline, reproduce the problem, apply the change, repeat the same benchmark, and compare statistically meaningful results.
11. Security — 291–300
291. How do you securely store authentication tokens? Avoid plain-text storage and use appropriate Android-provided cryptographic/security mechanisms. Prefer short-lived tokens where appropriate.
292. Should API keys be hardcoded in an APK? No. Anything embedded in an APK should be considered potentially discoverable.
293. Is HTTPS enough for mobile security? No. HTTPS protects transport but doesn’t eliminate insecure storage, authentication, authorization, logging, reverse engineering, or compromised-device risks.
294. What is certificate pinning? Restricting accepted certificates/public keys for a service to reduce certain man-in-the-middle risks.
295. What is encryption at rest? Protecting stored data so it isn’t directly readable without appropriate decryption/access controls.
296. How should sensitive data be logged? It generally shouldn’t be logged. Production logs should avoid tokens, passwords, personal data, and other secrets.
297. What is biometric authentication? Using device-supported biometric authentication to verify a user.
298. What is least privilege? Granting only the permissions and access necessary to perform a task.
299. How do you protect exported Android components? Explicitly configure component exposure and permissions, and avoid exporting components unnecessarily.
300. What is your overall approach to building a production Android application? I would start with clear requirements and architecture, define UI and domain states, establish a reliable data layer, use lifecycle-aware asynchronous processing, implement offline/error handling, add automated tests, profile performance, secure sensitive data, and continuously validate the system with monitoring and production feedback.
Conclusion
Preparing for an Android Developer interview is not simply about memorizing technical definitions. A strong Android engineer understands how different technologies work together and, more importantly, knows when, why, and how to use them to solve real-world problems.
The 300 questions and answers in this guide cover the core areas expected from modern Android developers, including Kotlin, Android fundamentals, Coroutines, Flow, Jetpack Compose, MVVM, Clean Architecture, dependency injection, networking, Room, testing, performance, security, and system design.
For mid-level and senior positions, interviewers will often go beyond theoretical questions. They may ask you to explain a previous technical decision, debug a production issue, design an application architecture, improve performance, handle unreliable networks, prevent memory leaks, or explain how you would test and verify a solution.
A strong answer should therefore demonstrate more than knowledge. It should show your engineering thought process:
Understand the problem → Analyze the constraints → Identify the root cause → Design a solution → Explain trade-offs → Implement the solution → Test it → Measure and verify the result.
The best way to use this guide is to practice answering each question without looking at the answer first. Then compare your response with the reference answer and expand it with examples from your own professional experience.
For senior Android interviews especially, focus on explaining real engineering decisions and measurable outcomes. Be prepared to discuss architecture, scalability, maintainability, performance, reliability, testing, security, and the trade-offs behind your choices.
Technology will continue to evolve, but the fundamental skills remain the same: write reliable code, understand the platform, solve problems systematically, communicate clearly, and continuously improve the product.
With consistent practice and hands-on experience, these questions can become more than interview preparation — they can serve as a foundation for becoming a stronger and more effective Android engineer.
Good luck with your Android engineering interviews!
Yodgorbek Komilov
