Paytm, Synechron, JioHotstar, Virtusa and more real interview topics, short interview-ready answers, and where to prepare next.

Preparing for an Android interview can feel overwhelming.

There are thousands of questions online. Hundreds of YouTube videos. Dozens of courses.

But one question matters more:

What are companies actually asking in interviews?

That is where real interview experiences become valuable.

InterviewGo collects candidate-shared interview experiences and turns them into practical preparation material. Below are 50 Android interview questions covering Kotlin, Coroutines, Android fundamentals, Architecture, Jetpack Compose, DSA, security, testing and system design.

These questions are based on topics found across company interview experiences shared on InterviewGo, including companies such as Paytm, Synechron, JioHotstar and Virtusa.

The answers are intentionally short.

Use them to test whether you can explain the concept yourself. For deeper explanations, code examples, company-specific preparation and hundreds of additional questions, explore InterviewGo.

Paytm

1. How does a ViewModel survive configuration changes? A ViewModel is stored in a ViewModelStore. During a configuration change such as screen rotation, the Activity is recreated but the ViewModelStore can be retained, allowing the new Activity to retrieve the existing ViewModel.

However, ViewModels don't survive process death, so persistent or saved state requires mechanisms such as SavedStateHandle.

1. Does Job.cancel() immediately stop a coroutine? No.

Coroutine cancellation is cooperative. Suspending functions such as delay() check cancellation automatically, but CPU-heavy or blocking code can continue unless it reaches a cancellation point.

Use mechanisms such as ensureActive() when appropriate.

1. What is the difference between a Hilt component and a subcomponent? A component represents a dependency graph with a defined lifecycle.

A subcomponent is associated with a parent graph and can access dependencies from that parent while adding its own bindings.

The important concept is matching dependency scope with object lifetime.

1. How would you improve Android application startup? First measure startup instead of guessing.

Identify expensive operations performed during application initialization, keep only critical work on the startup path, and defer non-essential SDK initialization.

Tools such as startup tracing and Macrobenchmark can help identify the actual bottlenecks.

1. What happens when an Activity is recreated? The Activity instance is destroyed and a new instance is created.

Depending on the reason for recreation, Android restores appropriate state from saved instance state, while ViewModels can retain state across configuration changes.

1. What is the difference between configuration change and process death? A configuration change recreates UI components while the application process generally remains alive.

Process death means the operating system terminates the application process. When the app returns, objects such as ViewModels may need to be recreated.

Persistent state should therefore not rely only on ViewModels.

1. What is the Android Activity lifecycle? The commonly discussed lifecycle is:

onCreate → onStart → onResume → onPause → onStop → onDestroy

The exact callbacks depend on what happens to the Activity, such as navigation, rotation or process termination.

1. Why should you avoid doing heavy work on the main thread? The main thread is responsible for UI operations.

Long-running CPU or blocking I/O operations can prevent rendering and user interaction, resulting in dropped frames and potentially an Application Not Responding error.

Move appropriate work to background dispatchers.

1. What causes an Android memory leak? A memory leak occurs when an object remains reachable even though it should no longer be used.

Common examples include long-lived objects holding Activity references, incorrectly scoped callbacks, listeners that aren't removed, and inappropriate coroutine lifetimes.

1. What is ANR? ANR stands for Application Not Responding.

It generally occurs when the application doesn't respond to system input within the expected time, often because the main thread is blocked for too long.

Synechron

1. LiveData vs a regular observer? LiveData is lifecycle-aware.

It only delivers updates when its observer is in an appropriate lifecycle state and automatically stops observing when the lifecycle owner is destroyed.

Regular callbacks require manual lifecycle management.

1. MVP vs MVVM? MVP generally uses a Presenter that communicates with a View interface.

MVVM separates UI from state/business logic through a ViewModel, with the UI observing state.

Modern Android applications commonly use MVVM-style architectures combined with StateFlow or other reactive state mechanisms.

1. What is a sealed class in Kotlin? A sealed class represents a restricted hierarchy of types.

It is particularly useful for modelling finite states such as:

Loading, Success, and Error.

It also enables exhaustive when expressions.

1. How do Kotlin Coroutines handle multithreading? Coroutines provide lightweight asynchronous execution.

They don't automatically create threads. Dispatchers determine where work executes:

Main → UI
IO → I/O operations
Default → CPU-intensive operations

1. Serializable vs Parcelable? Parcelable is designed specifically for Android data transfer and is generally more efficient.

With Kotlin, @Parcelize makes Parcelable implementation much easier.

For Android Intent or Bundle arguments, Parcelable is normally preferred.

1. What is a coroutine scope? A CoroutineScope defines the lifecycle and context in which coroutines execute.

Examples include viewModelScope and lifecycleScope.

Using the appropriate scope helps ensure work is cancelled when its owner is destroyed.

1. What is Dispatchers.IO used for? Dispatchers.IO is intended for blocking I/O operations such as file access and network/database work.

CPU-intensive operations are generally better suited to Dispatchers.Default.

1. What is withContext()? withContext() switches coroutine execution to a different context or dispatcher and suspends until the block completes.

For example, a ViewModel can perform database work using Dispatchers.IO and then return to the caller's context.

1. What is a higher-order function in Kotlin? A higher-order function accepts another function as an argument, returns a function, or both.

Kotlin uses higher-order functions extensively with collection operations such as map, filter, and fold.

1. What is the difference between val and var? val represents a read-only reference that cannot be reassigned.

var allows reassignment.

Using val where possible generally makes code easier to reason about and reduces accidental mutation.

JioHotstar

1. launch vs async? launch returns a Job and is appropriate when you don't need a result.

async returns a Deferred and is used when a result is required through await().

1. StateFlow vs SharedFlow vs Channel? A useful rule:

StateFlow → current state.

SharedFlow → shared events or streams.

Channel → communication or producer-consumer style use cases.

The correct choice depends on the semantics of the data.

1. What is structured concurrency? Structured concurrency gives asynchronous work a clear parent-child relationship.

Cancellation can propagate from parent to children, and coroutine lifetimes remain tied to an appropriate scope.

This makes lifecycle management much safer.

1. What causes unnecessary Compose recomposition? Common causes include unstable parameters, creating new objects unnecessarily, collecting frequently changing state too high in the UI tree, and poor state management.

Stable data models, state hoisting and carefully scoped state collection can reduce unnecessary recomposition.

1. What is recomposition in Jetpack Compose? Recomposition is the process of re-running affected composable functions when observed state changes.

Compose attempts to recompose only the parts of the UI affected by state changes rather than rebuilding the entire UI hierarchy.

1. What is remember in Compose? remember stores a value across recompositions.

It is useful when you want to avoid recreating an object every time a composable recomposes.

1. What is rememberSaveable? rememberSaveable extends the idea of remember by allowing compatible state to survive configuration changes and other state restoration scenarios.

It is useful for small pieces of UI state such as text input or selected options.

1. What is state hoisting? State hoisting means moving state from a composable to its caller.

Instead of a composable owning all its state, the parent provides the current value and receives events through callbacks.

This improves reusability and makes state ownership clearer.

1. What is the difference between LaunchedEffect and remember? remember stores values across recompositions.

LaunchedEffect starts a coroutine tied to the composable lifecycle and restarts it when its keys change.

They solve different problems.

1. Why is GlobalScope generally discouraged? GlobalScope creates work that isn't naturally tied to a lifecycle.

This can cause operations to continue longer than required, increasing the risk of wasted work, leaks and difficult cancellation.

Lifecycle-aware scopes are usually preferable.

Virtusa

1. What is certificate pinning? Certificate pinning restricts an application to trusting specific certificates or public keys for a server.

It can provide additional protection against certain man-in-the-middle attacks, but certificate rotation must be handled carefully.

1. How would you secure sensitive information in an Android app? Avoid storing secrets directly in the APK.

Use Android Keystore-backed mechanisms for sensitive cryptographic material, encrypt sensitive local data where appropriate, use HTTPS, and keep authorization decisions on the server.

1. Is R8 encryption? No.

R8 performs shrinking, optimization and obfuscation.

Obfuscation makes reverse engineering harder but should never be treated as a mechanism for securely storing secrets.

1. How does Android Keystore help security? Android Keystore provides a secure mechanism for managing cryptographic keys.

Depending on the device and configuration, keys can be protected by hardware-backed security components.

Applications can use these keys without directly exposing the underlying key material.

1. How would you protect API keys in an Android application? First ask whether the key actually needs to exist in the application.

Anything shipped inside an APK should be considered potentially extractable. Sensitive credentials should generally be kept server-side, with the backend controlling access.

Kotlin & Android Fundamentals

1. What is the difference between == and === in Kotlin? == checks structural equality by calling the appropriate equality implementation.

=== checks referential equality — whether two references point to the same object.

1. What is a Kotlin data class? A data class is designed primarily to hold data.

Kotlin automatically generates useful methods such as equals(), hashCode(), toString() and copy() based on its properties.

1. What is a companion object? A companion object provides members associated with a class rather than with individual instances.

It is commonly used for factory methods and constants.

1. What is the difference between let, run, apply, also, and with? These are Kotlin scope functions.

The main differences involve:

How the receiver is accessed
What the lambda returns
Whether the object is referenced as this or it

Knowing when each improves readability is more important than memorizing the syntax.

1. What is null safety in Kotlin? Kotlin's type system distinguishes nullable and non-nullable types.

For example:

String cannot normally hold null, while String? can.

Operators such as ?., ?:, and !! provide different ways to handle nullable values.

Architecture & Android Design

1. What is Clean Architecture? Clean Architecture separates an application into layers with clearly defined responsibilities and dependencies.

A common approach includes presentation, domain and data layers.

The goal is to reduce coupling and make the system easier to test and maintain.

1. Repository pattern — why use it? A Repository provides an abstraction over data sources.

The rest of the application can request data without knowing whether it came from a database, network or another source.

This makes changing implementations and testing easier.

1. What is dependency injection? Dependency injection means an object receives the dependencies it needs rather than creating them itself.

Tools such as Hilt and Dagger can automate dependency creation and management.

The major benefits are reduced coupling and improved testability.

1. Why use interfaces in Android architecture? Interfaces can define contracts between layers.

For example, a domain layer can depend on a repository interface rather than a concrete network implementation.

This reduces coupling and makes testing easier through fake or mock implementations.

1. What happens when the device rotates while a network request is running? The Activity or Fragment may be recreated, but the work should ideally not be tied directly to the UI instance.

A ViewModel can own the operation and expose its state to the newly recreated UI.

This prevents unnecessary duplicate work and preserves state across configuration changes.

Testing & Performance

1. Unit test vs instrumentation test? Unit tests generally run outside a real Android device environment and test isolated logic quickly.

Instrumentation tests run with Android framework components and can test UI or device-specific behavior.

A healthy project generally uses both.

1. What is the purpose of mocking? Mocking allows tests to replace real dependencies with controlled test doubles.

For example, a network repository can be replaced with a fake response so business logic can be tested without depending on an actual server.

1. How would you investigate an Android performance issue? Start with measurement.

Depending on the problem, investigate:

CPU usage
Memory
Rendering
Startup time
Network activity
Database operations
Battery usage

Profiling tools and benchmarks help identify the actual bottleneck instead of optimizing based on assumptions.

1. How would you reduce unnecessary network calls? Possible approaches include:

Caching
Request deduplication
Pagination
Debouncing user input
Local database storage
Conditional refresh
Appropriate retry strategies

The correct solution depends on the data and product requirements.

System Design

1. How would you design a scalable chat system for Android? Start by separating the Android client from backend responsibilities.

The client could use a local database for offline-first message storage, a real-time connection for incoming messages, background synchronization for pending messages, and a server responsible for authentication, message persistence and delivery.

Then consider message ordering, retries, duplicate messages, pagination, offline mode, push notifications, encryption and scalability.

The Questions Don't Stop Here
The biggest mistake candidates make is preparing only from generic question lists.

You might know:

"What is StateFlow?"
But an interviewer may continue with:

"Why StateFlow instead of LiveData?"
Then:

"What happens when the collector stops?"
Then:

"How would you handle one-time events?"
Then:

"How would you test it?"
Interview preparation isn't just about knowing definitions. It's about being ready for the follow-up questions.

That's why InterviewGo is built around real interview experiences and practical preparation.

What you'll find in InterviewGo
600+ Android interview questions
Prepare across:

Android fundamentals
Kotlin
Coroutines
Jetpack Compose
Architecture
MVVM
Clean Architecture
Hilt / Dagger
Room
Networking
Testing
Security
Performance
System Design
DSA
And more

Real company interview experiences
See how candidates describe their interview rounds, what topics came up, and what the interview process looked like.

Company-focused preparation
Instead of preparing blindly, explore experiences and questions associated with companies you're interested in.

Round-by-round preparation
Understand whether a company focused on DSA, Android fundamentals, architecture, system design, machine coding or behavioral questions.

Bookmarks and daily preparation
Save questions you need to revisit and build a consistent preparation routine.

Stop Preparing Randomly
You don't need to solve 1,000 random questions.

You need to understand the right concepts, practice explaining them, and learn from what candidates have actually experienced.

Start with 10 questions.

Then 20.

Then 50.

Keep revisiting the areas where you struggle.

The goal isn't to memorize answers.

The goal is to walk into the interview knowing you can handle the follow-up.

Start preparing with InterviewGo
📱 Download InterviewGo on Google Play

https://play.google.com/store/apps/details?id=in.interviewgo

🌐 Explore InterviewGo

If you've recently interviewed at a company, share your experience on InterviewGo — anonymously if you prefer.

Your experience could help the next Android developer prepare for exactly the question they get asked.

One interview experience can help hundreds of candidates.

Android #AndroidDeveloper #AndroidInterview #InterviewPrep #Kotlin #JetpackCompose #AndroidJobs #TechInterviews #InterviewQuestions #InterviewExperience #DSA #SystemDesign #MobileDevelopment #CareerGrowth #InterviewGo