© Interview RuntimeThis content is copyright. Copying is disabled; you may quote a short excerpt with a link to the page.

How to prepare for an Android interview in 1 week

A 7-day Android plan built around a messaging feature. It covers a diagnostic first, coroutine ownership, an uncertain send and a retry under time pressure.

Engraving of a wooden rack holding 7 test tubes, the first few filled.

In short

  • Confirm the round formats before deciding how much of the week goes to coding and how much to design.
  • Ask who owns each coroutine and each failure before you choose an operator or a scope.
  • A ViewModel does not survive process death, so name the recovery promise before choosing storage.
  • An uncertain send needs an operation identity and a reconciliation path, not only a retry schedule.
  • End with a changed-scenario retry that shows whether the repair transfers beyond the reviewed answer.

The message appears in the conversation. The user leaves the screen. The send operation is cancelled with the screen's job.

Was that message accepted, queued, sent or lost?

That small scenario can reveal more about your preparation needs than another evening of reading definitions. It connects Kotlin ownership, Android lifecycle, persistence, UI state and the server contract.

This 7-day Android interview plan follows 1 messaging feature through those boundaries. You can substitute the feature used by your target role, but keep the discipline. Make an attempt, inspect what it established and repair the gap.

The mixed-loop plan uses 2 hours per day for 6 days and 90 minutes on Day 7, totalling 13.5 hours. It is a proposed preparation schedule for experienced engineers, not a guarantee of readiness or an employer outcome.

Confirm the round before committing the week

Ask the recruiter whether the coding round is algorithmic, Android-specific or both. Confirm the language, editor, and permitted references and tools. Ask what the design round covers and what level of project discussion is expected.

If the next event is only an algorithm screen, move most of the week towards that screen. The messaging exercise is useful app-oriented practice, but it is not a substitute for an announced algorithm assessment.

If details remain unavailable, record the assumptions and keep time for both independent coding and Android reasoning. Update the plan when the format becomes clearer.

DayQuestion for the dayOutput
1Where does my first explanation fail?Recorded diagnostic and 2 priorities
2Who owns each coroutine and failure?Ownership map and verified Kotlin example
3Can I implement a small correct data operation?Running code and controlled edge cases
4What state does the UI own and restore?State-lifetime table and UI diagnosis
5What survives an uncertain send?Durable-operation history and server assumptions
6Can I explain the work under probing?Timed rehearsal and accurate project accounts
7Did the repair transfer, and does the setup work?Fresh retry and environment check

Day 1, diagnose with a narrow feature

Use 20 minutes to confirm the format and define the feature. Record a 45-minute attempt, use 35 minutes to review it and 20 to choose priorities.

Default task. Use this prompt for the attempt. The app displays message history, lets a user draft a message and accepts Send while the connection is unreliable. Explain what the screen shows and which component owns the work.

For a coding-heavy first round, use a small operation from the feature instead. Merge incoming messages by stable ID under an explicit order policy. For an algorithm screen, choose a representative unfamiliar algorithm problem.

Keep the first attempt, including uncertainty. Note whether the difficulty was implementation, language reasoning, lifecycle, consistency or explaining decisions.

Select 2 priorities. "I confused view-model lifetime with durable work" is actionable. "Learn Android architecture" is not a usable target for the next 2 hours.

Day 2, make coroutine ownership visible

Spend 25 minutes explaining the current coroutine design, 45 checking 1 uncertain rule in a small example, 30 on a changed condition and 20 reviewing the result.

Separate fetching history for a visible screen from an accepted message that must remain recoverable beyond that screen. An in-process scope can outlive navigation while still disappearing with process death.

Explain which component starts the work, what cancels it and where expected failure is handled. Preserve cancellation rather than reporting it as an ordinary service error. A suspending API must also satisfy the relevant main-safe contract; the modifier alone does not move arbitrary blocking work away from the UI.[1]

Default task. History loads successfully but an optional presence indicator fails. Should the entire screen fail? Define the feature's requirement before choosing supervision or exception handling, then write both versions and predict the result of each.

import kotlinx.coroutines.*

data class Screen(val messages: List<String>, val online: Boolean?)

// Presence is optional, so its failure must not take the history down with it.
suspend fun loadScreen(
    history: suspend () -> List<String>,
    presence: suspend () -> Boolean,
): Screen = supervisorScope {
    val messages = async { history() }
    val online = async { presence() }
    val presenceResult = try {
        online.await()
    } catch (e: CancellationException) {
        throw e
    } catch (e: Exception) {
        null
    }
    Screen(messages.await(), presenceResult)
}

// With coroutineScope the failed child cancels the scope, so history is lost as well.
suspend fun loadScreenStrict(
    history: suspend () -> List<String>,
    presence: suspend () -> Boolean,
): Screen = coroutineScope {
    val messages = async { history() }
    val online = async { presence() }
    Screen(messages.await(), online.await())
}

When presence throws an IOException, loadScreen returns the messages with online set to null. loadScreenStrict throws the same exception and returns no messages, even if you wrap the await in a try block, because the failed child has already cancelled its scope. The rethrown CancellationException matters. Without it, the catch would treat cancellation as a missing presence value, and only the next suspension point would stop the function.

Use Kotlin coroutines interview questions during repair. Your output should name 1 corrected guarantee and 1 example that supports it, not a larger vocabulary list.

Day 3, code a small operation with an explicit order policy

Use 45 minutes for implementation, 25 for review, 30 for repair and 20 for a changed-input retry.

Default task. Combine stored and incoming message records. Repeated IDs should update payloads rather than create duplicates. Decide whether server sequence, timestamp or incoming position determines order. State how equal values and messages awaiting a server identity are handled.

Make the baseline small. You do not need to build transport, a Room schema and a Compose screen to demonstrate the merge rule. Use fixtures that check payload and order separately.

Add the important follow-up

A refresh replaces the conversation history while an older page is still in flight. The older page arrives afterwards.

Deduplicating IDs does not establish whether that page belongs to the current conversation session. Explain the identity used to accept or reject it at the commit boundary.

For asynchronous checks, control the relevant order using injected dependencies and a suitable shared coroutine test scheduler.[2] Avoid relying on a guessed real-time delay to produce the history you want.

Android Interview Training includes Guided Practice for this kind of retry, where you answer realistic prompts, inspect weaknesses, revise your answer, handle changed constraints and compare attempts. If the employer announced algorithms, replace today's messaging task with algorithm coding in the permitted language and keep the same review discipline.

Day 4, connect Compose or Views to the state lifetime

Use 20 minutes to predict the behaviour, 50 for a reproduction or focused code review, 30 for the follow-up and 20 for notes.

Default task. Build a LazyColumn of messages where each row keeps a draft reply in remember. Type a draft in the second row, delete the first message and predict where the draft ends up. With the default position key the draft stays at its position and now sits under a different message. With key = { it.id } it moves with its message. For a Compose role, also inspect the effect lifetime. Which input should restart an operation? Which changing callback should an ongoing operation read without restarting? Which data should be hoisted?

For a Views-heavy role, inspect the equivalent screen owner, collection lifecycle and recreation behaviour. Match the exercise to the stack named in the role rather than forcing every position into a Compose curriculum.

Make a lifetime table

Distinguish a temporary menu state, a filter or selected conversation used for reconstruction, a local draft and an accepted pending message. The product may require some of those values to survive longer than others.

A ViewModel does not survive process death. Saved-state mechanisms and persistent data address different recovery requirements.[3] Record what the product promises before choosing storage.

If you test recreation, say which boundary you exercised. Rotation and process recreation are not interchangeable proofs of durability. A UI input restored successfully does not prove that an accepted message remains recoverable.

Day 5, walk through a send that the server accepted

Spend 40 minutes designing the send path, 30 on interruption, 30 on protocol questions and 20 giving a concise recap.

Default task. Design the send path and walk it through 1 lost response. Define when the app can claim local acceptance. Then identify the durable record, its operation identity and the component that discovers pending work later.

Now change the sequence. The server accepts the message, but the response is lost. The process restarts. The client still sees a pending record.

Explain what the retry means. If the server deduplicates operation IDs, state the scope and retention assumptions. If it offers a status query, state what the client can learn. Scheduling and retry timing alone do not answer whether a remote side effect happened. Android system design for offline sync walks through the design behind this day.

WorkManager can provide persistent scheduling with constraints and retry policies.[4] The feature still needs a reconciliation design for accepted local work, including an interruption between local persistence and a scheduling call.

Day 6, rehearse under a time limit and prepare project evidence

Run a 60-minute attempt of the weakest relevant format. Reserve 25 minutes for review and 35 for 2 real project accounts.

Default task. Run the Day 3 merge again as a fresh variant, where incoming messages carry a server rank that decides the order, in 25 minutes. Then explain the Day 5 design aloud for 25 minutes and take 10 minutes of follow-ups.

If you have a partner, tell them the target round and ask for a changed constraint. If not, record the attempt and preserve the original answer. A paid mock is 1 option when independent feedback would add information and arrives in time to act on it.

For the project accounts, record the problem, your personal contribution, the decision, its cost and the actual observed result. Explain what you did not measure or did not own. A team achievement can remain valuable without attributing every part to yourself.

Choose 1 example about a technical decision and 1 about an incident, disagreement or rollout. Be ready to explain what changed after the first approach failed.

Narrow the session to the announced round if it is only 1 format.

Day 7, retry the gap and verify the setup

Spend 20 minutes checking the editor, language, joining instructions and permitted tools. Use 30 for a fresh version of the week's main failed prompt, 20 for an evidence sheet and 20 for final role-specific review.

Default task. Redo the Day 1 prompt with 1 changed requirement. The user taps Send and force-stops the app before the response arrives. A force-stopped app stays in the stopped state until the user launches it again, and scheduled work does not run in between.[5] Explain what the user sees on that launch and what finds the pending message. Do not rely on the scheduler alone, because a check at startup that reads the pending records works whether or not stored work is restarted for you.

Change the surface details. If you repaired message recovery, explain an offline task rename. If you repaired a merge, change the ordering rule. The retry should show whether the reasoning transfers beyond the exact answer you reviewed.

Your 1-page sheet can contain corrected rules, known failure cases, project facts and questions for the interviewer. Treat it as a review artefact, not a hidden script.

What to drop first

When the week shrinks, cut in this order and write each cut on your evidence sheet.

  1. Reading anything new. Use only material you already have.
  2. Day 4 UI work, if no UI round is announced. Replace it with a second Day 3 coding session.
  3. The second project account on Day 6.
  4. The Day 2 repair, if the Day 1 diagnostic did not point at coroutines.
  5. The written evidence sheet, down to a list of 3 corrected rules.

Never drop the first announced round, 1 repair and retry cycle, or the environment check on Day 7.

Reallocate for the first announced round

FormatWhere to move time
Algorithms onlyGive most of Days 2 to 5 to independent algorithm and Kotlin implementation work
Android codingPrioritise Days 3 to 4, including a working path and failure check
System designAdd a second design and protocol review using time from unrelated UI work
Senior/Staff project deep diveExpand real project evidence, migration and cross-team consequences

If you have 7 hours, halve the blocks and select 1 main gap. If you have additional time, add a fresh attempt and repair for an observed weakness rather than starting several broad courses.

The 14-day mobile plan is a separate option when the deadline allows it. The 7-day version deliberately reduces scope.

Use a defined route when assembling the plan is the obstacle

Android Interview Training combines reference material, companion code and Guided Practice. Read the free sample and use the relevant route rather than treating the book as a cover-to-cover assignment for the week.

Sources

  1. Android Developers, Coroutine best practices.
  2. Android Developers, Testing Kotlin coroutines.
  3. Android Developers, Save UI states.
  4. Android Developers, Define work requests.
  5. 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.

Practice the follow-up, not the first answer.

Interview Runtime is the interview book plus 90 days of Guided Practice: you answer first, see the one gap that would cost the point, then answer again when one fact changes.