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

Why senior mobile engineers fail interviews despite knowing the answers

Replay a short stretch of your own round, find the first thing you could have shown, and choose the exercise that matches the symptom.

Engraving of a cracked gauge glass on a pressure dial, the needle still reading.

In short

  • A rejection rarely says which part of the round failed, so reconstruct a short stretch of your own performance.
  • Match the symptom to the exercise, whether it is unclarified assumptions, answers without ownership, no prioritisation, unverified code or weak adaptation.
  • A correct concept can still answer the wrong question, as with a retry that cannot prove whether the server committed.
  • 1 attempt does not establish a weakness. Repeat the smallest suspicious interval on a different task.
  • End a rehearsal with 1 sentence holding a time, an action and a consequence.

The interviewer asks for a sort button. You know how to sort an array. You can explain stable ordering, pagination and how to keep work off the UI thread. 8 minutes later, the interviewer still hasn't seen a single row move.

What went wrong? Maybe the requirement was unclear. Maybe you spent the time designing a solution for an entire catalogue when the exercise supplied 3 records. Maybe you got the order right and updated a collection the screen never reads. Each problem calls for a different practice session. “Do more interview prep” gives all 3 candidates the same homework.

The scenes in this article are hypothetical. A rejection email rarely tells you which explanation is true. What you can do is reconstruct a short stretch of your own performance, find the first thing you could have demonstrated and try it again under a changed requirement.

Replay the sort button

Try this original exercise with a colleague. The screen shows 3 records, in this order Cedar, Birch, Alder. Each record has a unique ID. The user can press Sort by name. For the first pass, all records are loaded and the names contain only plain English letters in title case. Ask the candidate to keep the original selection attached to the same record as rows move.

Before touching the code, ask 1 question that changes the design. “Are we sorting the records on this device, or the whole result set on the server?” For this first pass the answer is “the records on this device”. Now state an observable promise. After the tap the screen reads Alder, Birch, Cedar. If Cedar was selected, Cedar stays selected in the last row.

That gives you 2 separate checks. Reordering tests the collection the UI consumes. Selection tests identity. Sorting a temporary array can pass a unit test and leave the screen unchanged. Tracking selection by row index can produce a correctly sorted screen with the wrong item selected.

Once both behaviours work, the interviewer adds a constraint. The endpoint now returns 20 records per page and the business wants alphabetical order across the entire catalogue. Sorting the 20 loaded records still implements the first contract. It cannot deliver the new promise when an unloaded record belongs before them. Ask what ordering and pagination guarantees the endpoint provides. If the server has no such capability, describe the partial behaviour the client can deliver and the contract change the full requirement needs.

A candidate who spots that last problem deserves credit for the reasoning. A candidate who spots it in minute 1 and never delivers the local version has left a different question unanswered. Your practice should expose both abilities.

If you want follow-ups like this one scored and repeated, iOS Interview Training and Android Interview Training include Guided Practice on changed constraints.

Find the first missing piece

Each row is a symptom, what to check in a replay and an exercise you can run on this page or on an analogous problem.

SymptomWhat to check in a replayA matching exercise
Unclarified assumptions (“I kept asking questions” or “I never asked”)Which answer would have changed your first implementation?Ask the device-or-server question from the sort button, state 1 provisional assumption and build against it.
Answers without ownership (“we did”, “the team decided”)Can the interviewer tell which decision was yours and what you would change?Retell your last answer using only “I decided”, “I built” and “I would change”. See the worked version below.
No prioritisation (“I ran out of time”)Where did the first 5 minutes go?Repeat that interval with a timer. See the worked version below.
Unverified code (“I explained the algorithm” or “it worked on the example”)Did the user-visible behaviour ever run, and did selection survive the move?Select the first row, sort it into last place, then inspect its ID. See the worked version below.
Weak adaptation (“the interviewer changed the problem”)Can you identify the exact guarantee your first solution lost?The third pass below. Keep the first answer intact, name what still holds, then give 1 input your old design mishandles and propose the smallest contract change.

Use observations you can defend. If you remember the interviewer looking away, record your own last action and what was on screen. Their expression gives you no reliable account of the hiring decision.

3 symptoms, worked through

Each of these takes 10 minutes or less on the sort button.

Ownership. Take the sentence “We made sure the selection survived the sort.” Rewrite it with your own verbs. “I stored the selected ID, not the row position. I checked it by selecting Cedar and sorting. I would also test a row inserted above the selection.” Now have a partner interrupt at “I stored” and ask why not the index. If you cannot answer from your own decision, the story belongs to someone else.

Prioritisation. Set a 10-minute timer and say the first observable result aloud before you type. “Alder, Birch, Cedar on screen.” Hard-code the 3 records and get that result in the first 4 minutes. Spend minutes 4 to 7 on selection. Use the last 3 minutes to say what you would add next, such as pagination and errors, without writing it. Afterwards check 1 thing. Was the sorted screen visible by minute 4?

Verification. Write the test that fails under the index bug. Select Cedar, sort, and assert that the selected ID is unchanged and sits in the last row. Run it against a version that tracks the index and watch it fail, then fix the code. Finish by explaining why a unit test on a temporary sorted array passed while the screen stayed the same.

When the correct concept answers the wrong question

Here is a second exercise you can do aloud. A message has a client-generated ID. The server accepts the message, the response is lost and the app restarts. The draft answer is “persist the work and retry with backoff”.

That answer covers part of the client’s responsibility. Now draw 2 histories. In the first, the request never reached the server. In the second, it committed and the acknowledgement disappeared. The client sees an unconfirmed send in both histories. Its local state cannot establish which history occurred.

A stronger answer specifies what must be true for another attempt to be safe. The app retains the logical operation ID across restarts. The server recognises a retry of the same operation, within an agreed retention period, and can return its existing outcome. Reusing an ID for a different payload needs a defined error or conflict policy. If the service offers neither deduplication nor reconciliation, the client has to expose uncertainty or accept a duplicate risk. Increasing the delay between retries does not resolve that ambiguity.

Why use this exercise after a live-coding failure? Because it catches the opposite problem. In the sort task, writing a small amount of code can move you forward. In the send task, more client code cannot supply a missing server guarantee. Senior judgement includes knowing which kind of evidence the question needs.

Separate recall, execution and adaptation

After a difficult round, try 3 short passes on an analogous problem you are allowed to discuss. Keep confidential interview questions out of your notes.

First pass, without a timer. Explain the behaviour and give 1 counterexample. If you cannot do that with time to think, study the underlying concept. A recording habit cannot repair a misunderstanding about what an acknowledgement proves.

Second pass, with a timer. Use an editor close to the one you expect and an unfamiliar input. If the reasoning holds but you cannot get an example running, inspect the first point of friction. Was it the test entry point? Sorting syntax? Connecting the result to UI state? Practise that operation in isolation before buying a broader course.

Third pass, with an interruption. Ask a colleague to change a requirement once the baseline works. Record the first sentence of your response. “Let me start over” might be appropriate, but try naming what stays correct first. In the sort exercise, selection by stable ID still works. The source of global ordering changes. Explaining that boundary gives the interviewer a way to follow your revision. The exercise for a weak adaptation is this third pass in full. Keep the first answer intact, name what still holds, then give 1 input your old design mishandles and propose the smallest contract change.

A single attempt does not establish a personal weakness. Repeat the smallest suspicious interval on a different task. If the same difficulty returns, you have a more defensible reason to spend a preparation session on it.

Know when more rehearsal would miss the point

Sometimes the interview supplied too little information. The role may have changed, the panel may have evaluated a different scope, or another candidate may have met a particular need. Without feedback, these remain possibilities. Assigning yourself a communication problem on the strength of a generic rejection can waste a week.

If feedback is available, ask a question someone can answer from their notes. “Was there a point where you needed to see running code, a more precise explanation of a failure, or a clearer account of my contribution?” They may be unable to answer. In that case, keep the uncertainty and use your next rehearsal to collect your own evidence.

At the end of that rehearsal, write 1 sentence with a time, an action and a consequence. For example, “At minute 6 the names were in order in my test, but the selected row had changed from Cedar to Alder.” The next practice target is now small enough to finish. Preserve selection across reordering and prove it with the same 3 records. Once it works, change the input. That is progress you can inspect whether or not a recruiter replies.

To go further, read the follow-up decides the senior mobile interview and what interviewers write in the debrief. The first shows how a changed requirement is scored. The second shows what ends up in the notes, which is the written record the decision is later discussed from.

If the harder question is the career side, why a round you thought went well still ended in a rejection, I wrote about it for The Brief in your interview went well and you still got rejected.

Choose a platform and practise the replay

If you would rather not build your own follow-ups, pick the platform you interview on. iOS Interview Training and Android Interview Training are each $99, paid once per platform. You keep the book and companion code, and you get 90 days of Guided Practice with realistic prompts, a revision of your answer, changed constraints and a side-by-side comparison of your attempts. The Mobile Bundle covers both for $169. It is not a live mock interview with a person and not an AI interviewer. Each platform page has a free sample, so you can inspect the exercise format before choosing a track.

© 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.