In short
- Keep the first recording unchanged, then review it against the contract you stated.
- A database transaction and a separate scheduling call are not automatically atomic together.
- Rotation, process death and force-stop are different boundaries, so test each one separately.
- Explain cancellation, ownership and process-death recovery without reading the answer.
- Retry with a changed problem to see whether the reasoning transfers.
The answer says “ViewModel, Room and WorkManager”.
The recording contains no point at which the user's action became durable. There is no explanation of what happens if the process dies before scheduling. The retry policy says nothing about a request the server already accepted.
That is a useful outcome from Android interview practice. You found the missing reasoning before a real interviewer had to ask for it.
When practising alone, give yourself a problem, preserve the first attempt and inspect the history it claims to handle. Android's lifecycles make that approach especially useful. A feature can work during a normal session and fail across a boundary you never rehearsed.
Make today's round explicit
Confirm the actual interview format with the recruiter. It may be algorithm coding, Android feature work, domain discussion, system design or a past-project review. Note the permitted tools and language.
Use different solo outputs for different rounds. Coding needs an implementation and checks. Design needs clear responsibilities and a failure walkthrough. A past-project answer needs accurate personal contribution and evidence from work you did.
Choose 1 format for the main attempt. If you switch between them halfway through, record that change so you do not judge a sketch as if it were a working implementation.
The method in 6 steps
- Prompt. Select 1 prompt before opening documentation or solutions. Keep your exercise bank separate from its explanations.
- Answer without help. Use the rules of the real round. If it allows documentation, practise making accurate, bounded lookups rather than pretending every API must be recalled from memory.
- Record. Capture screen and voice, and keep the first attempt unedited.
- Score. Fill in the scoring sheet below, with evidence for every score.
- Correct. Repair 1 gap with references open. The important separation is between the answer you produced and the help you used afterwards, so keep both records.
- Retry. Change the operation and attempt it again on another day.
A worked example of the method
Take this prompt for a 45-minute attempt. A task-list app lets the user mark an item complete while offline. The item belongs to an account and appears on another device after sync. Show local acceptance, pending sync and confirmation as distinct states. You may sketch the design or use a small existing test project, but do not spend the rehearsal creating a new Android app.
Allow 5 minutes to define the contract, 8 to explain the first design aloud, 12 to walk through failures, 10 to verify 1 boundary and 10 to review. The baseline requires durable local acceptance. It does not assume that an in-memory ViewModel is sufficient or that a background job will run immediately.
Name what survives before you name a library. The selected filter, the current screen content, the pending completion intent and the last confirmed server state have different lifetimes. A ViewModel can retain state across configuration changes, but it does not survive process death. Saved state and persistent storage address different requirements.[1] A scope that outlives a screen can still disappear with the process, so say what restarts durable work later.
A possible opening is this.
“When the user marks the item complete, I will persist that intent and its pending operation together. The screen can then show local acceptance. Confirmation remains pending until I reconcile a server response.”
That is an example answer. A different implementation can be valid, but it must preserve the promise you made to the user. Next, walk through the interruptions in order and write what is durable at each point.
| Point of interruption | What should remain known after restart? |
|---|---|
| Before local acceptance | The app must not claim a durable action it never stored |
| After local transaction, before scheduling | The pending intent must be discoverable later |
| While the request is in flight | The logical operation remains identifiable |
| After server application, before response | The client treats the outcome as uncertain |
| After acknowledgement, before UI collection | The confirmed state can be reconstructed |
This exposes a common gap in design explanations. A database transaction and a separate scheduling call are not automatically 1 atomic operation, so propose a reconciliation trigger that finds pending work after interruption. Android's WorkManager guidance describes scheduling, constraints and retry configuration.[2] Those mechanisms do not define whether repeated remote execution is safe, so say which responsibility belongs to the client and which belongs to the server.
Then change the constraint. The server applies the completion, but the response is lost and the process restarts. Does the next request toggle the value or set it to a desired value? Repeating a toggle can undo the first successful operation. A desired-state operation can support a safer retry contract, but concurrent updates and ordering still need a policy. A stable operation identity can support deduplication when the server implements the corresponding contract. Adding growing delays between attempts changes when you retry, not what the retry means.
Here is a hypothetical review note for the attempt.
06:20, local acceptance is described, but the pending operation is not part of the stated transaction. 17:10, interruption before enqueue is unhandled. 21:40, retry is described as timing only, and the lost-response outcome is unresolved.
Its repair target is specific. Define and test recovery from durable intent that was never scheduled. If you want this recovery sequence with a rubric and a changed-constraint retry, Android Interview Training is the structured route.
Verify 1 boundary with controlled work
Pick the weakest part of the first attempt. You do not need to build the entire distributed system before learning something useful.
For a Kotlin state controller, inject the dependency and control when it completes. For timing logic, use coroutine test APIs with a shared scheduler where appropriate.[3] Verify the state after the relevant completion rather than waiting a guessed number of real milliseconds. For persistence, test recreation from stored records. For UI integration, use a host that exercises the lifecycle boundary you claim to handle. Label each test's scope.
Treat cancellation as a separate path
If the owning scope is cancelled, check that your code does not turn cancellation into a normal failed-operation message. Then test an ordinary operational failure separately.
Android's coroutine guidance advises preserving cancellation and assigning work an appropriate owner.[4] For language-level follow-ups, see Kotlin coroutines interview questions, and for how a broad catch can hide cancellation, read Kotlin runCatching and cancellation. Your feature also needs its own publication rule for stale results and account changes.
Write the observation precisely. “A cancelled old request could not replace the latest screen state in this controller check” does not establish that all background scheduling and network behaviour is correct.
Do not confuse recreation tests
Rotation can exercise activity recreation while retaining a ViewModel. System-initiated process death removes process memory. Force-stop puts the app in the stopped state, and on Android 15 the system also cancels the app's pending intents when that happens.[5] These are not interchangeable demonstrations of recovery.
For each test, record the action, what lifecycle or process boundary it exercises and what you expect to remain. Also distinguish restoring a filter from recovering an accepted business operation. They may look similar when broken, but they need different storage. If your environment supports only 1 of these checks today, state that limitation and design the next one. Do not present “I rotated the screen” as evidence for a claim you did not test.
Score the attempt on a sheet
Copy the sheet below into your notes and fill it in after every attempt. A row may only carry a score when its evidence cell is filled. If you cannot point to a timestamp, a test result or a code location, leave the score blank.
| Dimension | Score 0 to 3 | Evidence | Retry date |
|---|---|---|---|
| Contract, local acceptance versus confirmation | |||
| Ownership, scope or persistent owner | |||
| Recovery, a named interruption walked through | |||
| Verification, a failure controlled or reproduced | |||
| Adaptation when the remote outcome became uncertain | |||
| Cancellation, ownership and process death explained without notes | |||
| Limit, a guarantee that still depends on the backend |
Use 0 for not reached, 1 for needs repair, 2 for prompted (you needed a hint or a reference) and 3 for demonstrated. These describe your own notes and are not a hiring scale. Do not score an unattempted part as a failure, and do not score a plausible explanation as executed evidence. Set the retry date on the day you fill in the row, because a row with no date is a gap you have agreed to ignore.
Check the explanation without notes
After the repair, close the notes and record 3 explanations aloud. Why must cancellation not become a failed save? Which owner holds each state? What survives process death? Then open the answer and mark any part you could only give after reading it as needs repair, which is a 1 on the sheet. Repeat the check on another day with a different operation, because a memorised explanation of the same example proves less than an explanation of a new one.
Keep the next attempt small enough to inspect
For the repair session, create a pending record, recreate the relevant owner and demonstrate that it is discovered without relying on the old in-memory job. State the trigger that makes discovery happen.
For the retry session, change the feature from completing a task to renaming it. Now 2 devices can submit competing text. Explain which parts of the design remain and which conflict policy you need to add. The purpose of changing the operation is to inspect transfer of the reasoning. Repeating the same memorised speech can conceal that you still cannot define a new contract.
For a longer design session on offline sync, read Android offline sync at staff level during repair, then close it before the next explanation.
Use external feedback where self-review has limits
A peer or experienced interviewer can inspect habits you repeatedly miss. Bring a prompt, the first recording and the particular question you want answered. That makes the feedback session more focused than asking whether you are “good at Android interviews”.
Make your preparation route match the actual loop
If the first round is algorithms, allocate algorithm practice rather than assuming an offline design rehearsal covers it. If it is Compose, schedule a focused Compose rehearsal. For a broader timed session, run 1 round that covers cancellation, state ownership and recovery together.
If assembling a route is the obstacle, inspect Android Interview Training and its free sample. It is $99, paid once per platform, and combines the book and companion code with Guided Practice. Judge the format by the work it asks you to produce.
Sources
- Android Developers, Save UI states.
- Android Developers, Define work requests.
- Android Developers, Testing Kotlin coroutines.
- Android Developers, Coroutine best practices.
- Android 15 behaviour changes for all apps, Changes to package stopped state.
Questions readers ask
© 2026 Mike Salari, Interview Runtime. All rights reserved. Quoting a short excerpt with a link to this page is welcome; republishing the article, in full or in part, is not.



