Skip to content
Resume Studioby M2Toolkit

12 role-specific questions

Mobile App Developer Interview Questions & Answers

Mobile interviews test platform fundamentals — the app lifecycle, permissions and privacy, push notifications, offline data and architecture — whichever stack you use.

Free, no sign-up. 75 questions in this role's practice pool, including behavioural, HR and situational questions.

Mobile development interview questions

Platform fundamentals for iOS, Android and cross-platform apps: lifecycle, permissions, UX and architecture.

  1. 1.

    Native, React Native or Flutter — how would you choose for a new app?

    BeginnerTechnical

    What the interviewer is evaluating

    Technology choice based on requirements.

    Key points a strong answer covers

    • Native strengths. Native (Swift/Kotlin) gives full platform access and the best performance.
    • Cross-platform strengths. Cross-platform shares one codebase across iOS and Android.
    • React Native vs Flutter. React Native suits JS/React teams; Flutter renders its own widgets with Dart.
    • Deciding factors. Team skills, required platform features, timeline and budget.

    Suggested answer structure

    1. Define it in one sentence.
    2. Explain how it works underneath.
    3. Give a practical example from code or a project.
    4. Close with a trade-off, pitfall or when you'd use it.

    Common mistakes

    • Claiming one option is always best.
    • Ignoring the team's existing skills.

    Likely follow-up questions

    • What kind of app would you still build natively?
    • How do you share code between web and mobile?
    Example strong answer

    I'd decide from the requirements and the team. Native Swift and Kotlin give full, immediate access to every platform API and the best performance, which matters for graphics-heavy apps, AR, complex background processing, or a team that already has strong iOS and Android engineers. Cross-platform frameworks share most code across both platforms, which usually means faster delivery and lower cost for typical business apps. Between them: React Native renders real native components and suits a team that knows React and TypeScript — you can even share logic with the web app; Flutter draws its own widgets for very consistent UI and uses Dart. For a startup with web developers, I'd usually start with React Native.

    Practise this question and get feedback
  2. 2.

    Explain the app lifecycle on mobile. What happens when an app goes to the background?

    IntermediateTechnical

    What the interviewer is evaluating

    Platform fundamentals that cause real bugs.

    Key points a strong answer covers

    • States. Apps move between active, inactive, background and suspended or terminated.
    • OS can kill the app. The OS can terminate a backgrounded app at any time to reclaim memory.
    • Save & restore state. Save important state when backgrounded and restore it.
    • Background limits. Background execution is limited; use WorkManager/background tasks and push.

    Suggested answer structure

    1. Define it in one sentence.
    2. Explain how it works underneath.
    3. Give a practical example from code or a project.
    4. Close with a trade-off, pitfall or when you'd use it.

    Common mistakes

    • Assuming the app keeps running in the background.
    • Losing user input after process death.

    Likely follow-up questions

    • How would you test process death on Android?
    • How would you upload a large file if the user leaves the app?
    Example strong answer

    A mobile app moves between states: active in the foreground, briefly inactive during interruptions like a call, then background, where it gets limited time before being suspended. While suspended or under memory pressure, the OS can terminate the process without warning. So when the app goes to the background I save anything the user would hate to lose — a draft, form input, the current screen — and restore it on launch; on Android I test this with 'don't keep activities' or by killing the process. Long-running work has to use the platform's mechanisms — WorkManager on Android, background tasks or background URLSession transfers on iOS — and timely updates come through push notifications rather than polling.

    Practise this question and get feedback
  3. 3.

    How do you handle permissions and user privacy in a mobile app?

    BeginnerTechnical

    What the interviewer is evaluating

    Respect for users and platform rules.

    Key points a strong answer covers

    • Ask in context. Ask at the moment it's needed, explaining why.
    • Handle denial. Handle denial gracefully, with a way to enable it later in Settings.
    • Minimum data. Request only what you need (e.g. approximate location).
    • Store rules. Comply with privacy labels, Data safety forms and App Tracking Transparency.

    Suggested answer structure

    1. Define it in one sentence.
    2. Explain how it works underneath.
    3. Give a practical example from code or a project.
    4. Close with a trade-off, pitfall or when you'd use it.

    Common mistakes

    • Asking for every permission at first launch.
    • Breaking the app when a permission is denied.

    Likely follow-up questions

    • What happens if a user permanently denies a permission?
    • What is App Tracking Transparency?
    Example strong answer

    I ask for a permission only at the moment the feature needs it — camera when they tap 'scan receipt' — with a short screen explaining why first, because the system prompt usually only appears once. If they decline, the feature degrades gracefully: they can still type the receipt manually, and there's a clear path to enable it later in Settings. I request the minimum — approximate rather than precise location if that's enough, photo picker access rather than the whole library. And I keep the store disclosures accurate: Apple's privacy labels and privacy manifest, Google Play's Data safety form, and App Tracking Transparency before any cross-app tracking.

    Practise this question and get feedback
  4. 4.

    How do you structure a mobile app's code so it stays maintainable?

    IntermediateTechnical

    What the interviewer is evaluating

    Architecture beyond single screens.

    Key points a strong answer covers

    • Separation of concerns. Separate UI, state/business logic and data layers.
    • Patterns. MVVM / unidirectional data flow keeps UI simple and testable.
    • Repositories / data. Repositories hide API and local storage details.
    • Modules & testing. Feature modules, DI and unit-testable logic.

    Suggested answer structure

    1. Define it in one sentence.
    2. Explain how it works underneath.
    3. Give a practical example from code or a project.
    4. Close with a trade-off, pitfall or when you'd use it.

    Common mistakes

    • Putting API calls directly inside screens.
    • One giant global state object.

    Likely follow-up questions

    • What belongs in a ViewModel and what doesn't?
    • How would you test business logic without a device?
    Example strong answer

    I separate it into layers. The UI layer — screens and components — only renders state and forwards user actions. A ViewModel or equivalent state holder turns those actions into state using unidirectional data flow, so the screen is a function of state and easy to reason about. The data layer has repositories that hide where data comes from — the API, a local database or a cache — so the rest of the app doesn't care about offline handling. Dependencies are injected, so business logic can be unit tested without a device. As the app grows, I split features into modules with clear boundaries, which also speeds up builds.

    Practise this question and get feedback
  5. 5.

    How do push notifications work end to end?

    IntermediateTechnical

    What the interviewer is evaluating

    Understanding of a cross-system feature.

    Key points a strong answer covers

    • Device token. The app registers with APNs/FCM and receives a device token.
    • Server stores token. The app sends the token to your server, linked to the user.
    • Provider sends. Your server sends the message via APNs (iOS) or FCM (Android).
    • Handling & permission. Request permission, handle taps with deep links, use channels on Android.
    • Token refresh / cleanup. Tokens change — refresh and remove invalid ones.

    Suggested answer structure

    1. Define it in one sentence.
    2. Explain how it works underneath.
    3. Give a practical example from code or a project.
    4. Close with a trade-off, pitfall or when you'd use it.

    Common mistakes

    • Never removing invalid tokens.
    • Notifications that open the home screen instead of the relevant content.

    Likely follow-up questions

    • What's the difference between a notification and a data message?
    • How do you avoid notification fatigue?
    Example strong answer

    The app asks for permission, then registers with the platform's push service — APNs on iOS, Firebase Cloud Messaging on Android — and gets a device token, which it sends to our backend with the user's id. When something happens, the backend sends a request to APNs or FCM with that token and the payload, and the platform delivers it even if the app isn't running. Tapping it should deep-link to the relevant screen. On Android I use notification channels so users can control categories. Tokens rotate, so the app re-sends them on launch, and the server deletes tokens the provider reports as invalid. I keep notifications relevant and let users choose what they receive.

    Practise this question and get feedback
  6. 6.

    How do you test a mobile app?

    IntermediateTechnical

    What the interviewer is evaluating

    Quality strategy across devices.

    Key points a strong answer covers

    • Unit tests. Unit tests for logic.
    • UI / component tests. Component/UI tests for screens.
    • E2E. End-to-end tests with Detox, Maestro or Appium.
    • Device coverage. Test on real devices: OS versions, screen sizes, low-end phones.
    • Beta / monitoring. Beta testers and crash monitoring.

    Suggested answer structure

    1. Define it in one sentence.
    2. Explain how it works underneath.
    3. Give a practical example from code or a project.
    4. Close with a trade-off, pitfall or when you'd use it.

    Common mistakes

    • Only testing on the latest flagship phone.
    • No automated tests for critical flows.

    Likely follow-up questions

    • What would you cover with E2E tests and what with unit tests?
    • How do you test poor network conditions?
    Example strong answer

    I use a pyramid. Unit tests cover business logic and state handling — fast and run on every commit. Component tests render screens with mocked data and check behaviour. A small set of end-to-end tests with Maestro or Detox covers critical journeys like sign-up, login and checkout on simulators in CI. Because devices vary so much, I also test on real devices — a range of OS versions, small screens and at least one low-end Android phone — using a device farm, and simulate slow or no network. Before release, TestFlight and Play internal testing builds go to testers, and production crash monitoring catches what slipped through.

    Practise this question and get feedback

React Native interview questions

The React Native architecture, performance, navigation, native modules and shipping apps.

  1. 1.

    How does React Native render native UI? Explain the new architecture.

    IntermediateTechnical

    What the interviewer is evaluating

    Understanding what runs where in an RN app.

    Key points a strong answer covers

    • JS drives native views. JavaScript describes the UI; React Native renders real native views — not a WebView.
    • Old bridge. The old architecture sent serialised messages over an async bridge.
    • JSI / new architecture. The new architecture uses JSI for direct calls, Fabric for rendering and TurboModules.
    • Hermes. Hermes is the default JS engine, optimised for startup.

    Suggested answer structure

    1. Define it in one sentence.
    2. Explain how it works underneath.
    3. Give a practical example from code or a project.
    4. Close with a trade-off, pitfall or when you'd use it.

    Common mistakes

    • Saying React Native runs in a WebView.
    • Not knowing what JSI changes.

    Likely follow-up questions

    • What does Fabric improve over the old renderer?
    • Why does Hermes improve startup time?
    Example strong answer

    React Native runs your JavaScript — on the Hermes engine by default — and React describes the UI as a tree of components, but they're rendered as real native views, UIViews on iOS and Views on Android, not HTML in a WebView. In the old architecture, JavaScript and native code talked over an asynchronous bridge by serialising JSON messages, which added latency and made some interactions janky. The new architecture replaces that with JSI, a C++ interface that lets JavaScript hold references to native objects and call them directly, even synchronously. Fabric is the new renderer built on it, and TurboModules load native modules lazily with type-safe Codegen bindings. Hermes precompiles JS to bytecode, which speeds startup.

    Practise this question and get feedback
  2. 2.

    How do you diagnose and fix performance problems in a React Native app?

    AdvancedTechnical

    What the interviewer is evaluating

    Practical mobile performance work.

    Key points a strong answer covers

    • Measure. Measure with the performance monitor, React DevTools profiler and native profilers.
    • Lists. Use FlatList/FlashList properly for long lists.
    • Re-renders. Avoid unnecessary re-renders.
    • UI thread animations. Run animations on the UI thread (Reanimated / native driver).
    • Images & startup. Optimise images, lazy-load screens, reduce startup work.

    Suggested answer structure

    1. Define it in one sentence.
    2. Explain how it works underneath.
    3. Give a practical example from code or a project.
    4. Close with a trade-off, pitfall or when you'd use it.

    Common mistakes

    • Rendering long lists with ScrollView and map.
    • Animating with JS-driven state updates.

    Likely follow-up questions

    • Why do animations stutter when the JS thread is busy?
    • What does getItemLayout give FlatList?
    Example strong answer

    First I measure: the in-app performance monitor shows whether the JS thread or the UI thread is dropping frames, React DevTools' profiler shows which components re-render, and Xcode Instruments or Android Studio profilers cover native work. Common fixes: long lists use FlatList — or FlashList — with stable keys, memoised row components and getItemLayout for fixed heights, never a ScrollView with .map. Animations run on the UI thread with Reanimated or useNativeDriver, so they stay smooth even when JavaScript is busy. I cut unnecessary re-renders with memoisation and better state placement, resize and cache images, and speed up startup by deferring work and lazy-loading screens.

    Practise this question and get feedback
  3. 3.

    How do you handle navigation in a React Native app?

    BeginnerTechnical

    What the interviewer is evaluating

    Familiarity with the standard navigation stack.

    Key points a strong answer covers

    • React Navigation / Expo Router. React Navigation or Expo Router (file-based).
    • Navigator types. Stack, tab and drawer navigators, nested.
    • Params & deep links. Pass params, and configure deep linking.
    • Native feel. Native stack navigator for native transitions and gestures.

    Suggested answer structure

    1. Define it in one sentence.
    2. Explain how it works underneath.
    3. Give a practical example from code or a project.
    4. Close with a trade-off, pitfall or when you'd use it.

    Common mistakes

    • Passing large objects as route params.
    • Ignoring Android back button behaviour.

    Likely follow-up questions

    • How would you protect screens that need a logged-in user?
    • How do you test deep links?
    Example strong answer

    I use React Navigation, or Expo Router in Expo projects, which builds on it with file-based routes. A typical app nests navigators: a bottom tab navigator for the main sections, each tab with its own native stack, plus modal screens on top. The native stack uses the platform's own transitions and gestures, so it feels right on both iOS and Android, including the Android back button. Screens receive small params like an id rather than whole objects, and fetch what they need. I configure deep linking so URLs and notifications open the right screen, and for authentication I render different navigator groups depending on whether the user is signed in.

    Practise this question and get feedback
  4. 4.

    When would you write a native module, and how?

    AdvancedTechnical

    What the interviewer is evaluating

    Ability to go beyond JavaScript when needed.

    Key points a strong answer covers

    • When needed. When a platform API or SDK isn't available through an existing library, or for heavy native work.
    • Check libraries first. Check existing libraries and Expo modules first.
    • How. Write Swift/Kotlin code exposed as a TurboModule or with the Expo Modules API.
    • Threading / async. Expose async methods returning promises; emit events; mind the threads.

    Suggested answer structure

    1. Define it in one sentence.
    2. Explain how it works underneath.
    3. Give a practical example from code or a project.
    4. Close with a trade-off, pitfall or when you'd use it.

    Common mistakes

    • Writing native code for something a maintained library already does.
    • Blocking the main thread in native code.

    Likely follow-up questions

    • How do native modules send events back to JavaScript?
    • How would you share the module across iOS and Android?
    Example strong answer

    Only when JavaScript can't do it: a platform API or vendor SDK with no maintained library — say a payment terminal SDK — or performance-critical work like image processing. First I check for an existing library or Expo module. If I write one, the Expo Modules API is the quickest route: Swift on iOS and Kotlin on Android with a shared, typed JavaScript interface. Without Expo, I'd write a TurboModule with a TypeScript spec that Codegen turns into native bindings. Methods are asynchronous and return promises, events are emitted back to JavaScript for things like progress, and heavy work stays off the main thread.

    Practise this question and get feedback
  5. 5.

    How would you store data and support offline use in a React Native app?

    IntermediateTechnical

    What the interviewer is evaluating

    Mobile data architecture.

    Key points a strong answer covers

    • Storage options. AsyncStorage/MMKV for small values, SQLite/WatermelonDB for structured data, Keychain/SecureStore for secrets.
    • Secrets securely. Tokens go in the Keychain/Keystore, not plain storage.
    • Offline queue / sync. Queue changes offline and sync, handling conflicts.
    • Cache server data. Cache server data (e.g. persisted TanStack Query).

    Suggested answer structure

    1. Define it in one sentence.
    2. Explain how it works underneath.
    3. Give a practical example from code or a project.
    4. Close with a trade-off, pitfall or when you'd use it.

    Common mistakes

    • Storing auth tokens in AsyncStorage.
    • No conflict strategy when syncing.

    Likely follow-up questions

    • How would you resolve a conflict when the same record changed on two devices?
    • How do you detect connectivity changes?
    Example strong answer

    It depends on the data. Small preferences go in MMKV or AsyncStorage; tokens and secrets go in the iOS Keychain or Android Keystore via a secure storage library, never plain storage. Structured data the user works with offline goes in SQLite, or WatermelonDB for larger datasets. For server data I use TanStack Query with persistence, so screens show cached data instantly. For edits made offline I write locally first, show them optimistically, and queue the changes; when NetInfo reports connectivity, a sync process sends them with retries. Conflicts need a rule — last-write-wins with timestamps for simple fields, or server-side merging and asking the user for important records.

    Practise this question and get feedback
  6. 6.

    How do you build, release and update a React Native app?

    IntermediateTechnical

    What the interviewer is evaluating

    Real shipping experience: builds, signing, store review, updates and rollbacks.

    Key points a strong answer covers

    • Build pipeline. Automated builds with EAS Build or Fastlane in CI.
    • Signing & stores. Code signing, TestFlight/internal testing, store review.
    • OTA updates. Over-the-air updates for JS-only changes, within store rules.
    • Staged rollout & monitoring. Phased rollouts and crash monitoring.

    Suggested answer structure

    1. Define it in one sentence.
    2. Explain how it works underneath.
    3. Give a practical example from code or a project.
    4. Close with a trade-off, pitfall or when you'd use it.

    Common mistakes

    • Shipping native changes via OTA updates.
    • No crash reporting.

    Likely follow-up questions

    • What can't you change with an OTA update?
    • How would you roll back a bad release?
    Example strong answer

    Builds are automated in CI — EAS Build for Expo projects or Fastlane otherwise — with signing credentials stored securely, never on a laptop. Each release goes to TestFlight and Google Play's internal testing track for QA, then through store review with a phased rollout so a bad build reaches a small percentage first. Crash and error monitoring with Sentry or Crashlytics, tagged by app version, tells me whether to continue the rollout. For JavaScript-only fixes, over-the-air updates through EAS Update deliver a new bundle without a store release — within the stores' rules — but anything touching native code or permissions needs a full build. Versioning ties OTA updates to compatible native builds.

    Practise this question and get feedback

Behavioural & HR questions you'll also get

These come up in almost every mobile app developer interview. Story questions are best answered with STAR — Situation, Task, Action, Result.

  • Tell me about yourself.

    BeginnerHR

    What the interviewer is evaluating

    Whether you can give a concise, relevant pitch that frames your experience around this job.

    Key points a strong answer covers

    • Present. Start with your current role and what you do.
    • Relevant past. Pick the most relevant past experience.
    • Strength / achievement. Include one strength or achievement with evidence.
    • Why this role. Finish with why this role is the next step.

    Suggested answer structure

    1. Present — your current role in one or two sentences.
    2. Past — the experience most relevant to this job.
    3. Proof — one achievement or strength with evidence.
    4. Future — why this role is the logical next step.

    Common mistakes

    • Reciting your whole CV chronologically.
    • Personal life story unrelated to the job.
    • Going over two minutes.

    Likely follow-up questions

    • Why are you looking to leave your current role?
    • What would your manager say is your biggest strength?
    Example strong answer

    I'm a front-end developer with four years' experience, currently at a fintech start-up where I build the customer dashboard in React and TypeScript. Before that I spent two years at an agency building e-commerce sites, which taught me to work fast with lots of different clients. The thing I'm proudest of recently is leading our move to a shared component library, which cut the time to build new screens by about a third. I'm now looking for a role where I can work on a larger product with a strong design system, which is exactly what drew me to this position.

  • Why should we hire you?

    BeginnerHR

    What the interviewer is evaluating

    Whether you understand the role and can match your strengths to its needs with evidence.

    Key points a strong answer covers

    • Role's needs. Show you understand what the role needs.
    • Matching strengths. Match two or three strengths to those needs.
    • Evidence. Back each with evidence.
    • Enthusiasm. Close with genuine enthusiasm.

    Suggested answer structure

    1. Name the two or three things the role needs most.
    2. Match each with your experience and evidence.
    3. Add what makes you different.
    4. Finish with genuine interest.

    Common mistakes

    • Generic claims like 'I'm hardworking' with no evidence.
    • Comparing yourself to other candidates you don't know.

    Likely follow-up questions

    • What would you do in your first 90 days?
    • What's one area where you'd need support?
    Example strong answer

    From the job description and our conversation, you need someone who can take ownership of the customer onboarding process, work with sales and product, and improve the numbers. I've done exactly that for three years: at my current company I redesigned onboarding for new accounts and cut the time to first value from 14 days to 6. I'm comfortable working across teams — I run a weekly session with sales and product on customer feedback — and I'm very data-driven, so I'd measure everything from day one. I'm also genuinely excited about your product, because it solves a problem I've seen customers struggle with.

  • Tell me about a time you disagreed with a teammate. How did you handle it?

    BeginnerBehavioural

    What the interviewer is evaluating

    Handling conflict constructively and keeping relationships.

    Key points a strong answer covers

    • Listened to their view. Show you listened to understand their view.
    • Used facts / common goal. Bring it back to facts or a shared goal.
    • Resolution & relationship. Resolve it and keep the relationship.

    Suggested answer structure

    1. Situation — one or two sentences of context.
    2. Task — what you were responsible for.
    3. Action — what you did, step by step (say “I”).
    4. Result — what changed, with a number if you can back it up.
    5. Reflection — what you learned or would do differently.

    Common mistakes

    • Making the other person the villain.
    • A story where you were simply right and they gave in.

    Likely follow-up questions

    • What if you couldn't reach agreement?
    • Have you ever been wrong in a disagreement?
    Example strong answer (a fictional story — use your own)

    On a website rebuild, a senior designer wanted an animated, image-heavy homepage, and I was worried it would hurt mobile load times and SEO. As the developer responsible for performance, I needed us to agree before the sprint started. I asked her to walk me through what she was trying to achieve — she wanted the brand to feel premium. I built two quick prototypes, one with her full design and one with lighter animations, and we tested both on a mid-range phone together. Hers took nearly six seconds to load. We agreed on a version that kept the key animation but lazy-loaded the rest. The page launched loading in under two seconds, and she later asked me to review designs earlier. I learned that testing together beats debating.

  • Tell me about a mistake you made and what you learned.

    BeginnerBehavioural

    What the interviewer is evaluating

    Honesty, accountability and learning.

    Key points a strong answer covers

    • Real mistake owned. Own a real mistake.
    • Fixed it. Show how you fixed it and who you told.
    • Changed behaviour. Show what you changed afterwards.

    Suggested answer structure

    1. Situation — one or two sentences of context.
    2. Task — what you were responsible for.
    3. Action — what you did, step by step (say “I”).
    4. Result — what changed, with a number if you can back it up.
    5. Reflection — what you learned or would do differently.

    Common mistakes

    • Choosing a fake mistake like 'I work too hard'.
    • Blaming others.

    Likely follow-up questions

    • How did your manager react?
    • How do you know you haven't repeated it?
    Example strong answer (a fictional story — use your own)

    In my first year as a marketing coordinator, I sent a promotional email to our whole list with the wrong discount code — I'd tested the email but not clicked the code itself. Within an hour customers were complaining that it didn't work. I told my manager immediately, set the wrong code to apply the discount too, and sent a short correction email with an apology. We lost very little revenue, and some customers replied thanking us for the quick fix. Since then I use a pre-send checklist that includes testing every link and code as a customer would, and I asked for a second person to check any campaign to more than 10,000 people.

  • Describe a situation where you worked under pressure or to a tight deadline.

    BeginnerBehavioural

    What the interviewer is evaluating

    Prioritisation, composure and delivery.

    Key points a strong answer covers

    • The pressure. Make the pressure concrete.
    • Prioritised. Show how you prioritised.
    • Communicated. Show how you kept people informed.
    • Delivered. Show the outcome.

    Suggested answer structure

    1. Situation — one or two sentences of context.
    2. Task — what you were responsible for.
    3. Action — what you did, step by step (say “I”).
    4. Result — what changed, with a number if you can back it up.
    5. Reflection — what you learned or would do differently.

    Common mistakes

    • Glorifying working all night as the solution.
    • No mention of prioritising.

    Likely follow-up questions

    • What would you do if it was clear you couldn't make the deadline?
    • How do you stop pressure affecting quality?
    Example strong answer (a fictional story — use your own)

    Two days before a client presentation, our analyst fell ill and I had to finish the market research report she'd been leading. I listed everything left and asked the account director which sections the client cared about most — pricing and competitor comparison. I focused on those, reused verified data from our previous report, and moved the appendix to a follow-up email. I sent a short update each evening so nobody was surprised. We delivered the core report on time, the client approved the next phase, and the appendix followed two days later. I learned to ask early what matters most rather than trying to do everything equally well.

  • What would you do if you realised you were going to miss a deadline?

    BeginnerSituational

    What the interviewer is evaluating

    Transparency and problem solving.

    Key points a strong answer covers

    • Tell people early. Flag it as soon as you know.
    • Assess the gap. Work out how far off you are.
    • Options. Offer options: reduced scope, help, a new date.
    • Prevent repeats. Learn why it happened.

    Suggested answer structure

    1. Clarify the situation and what's at stake.
    2. Say what you'd do first, and why.
    3. Explain who you'd involve and how you'd communicate.
    4. Describe how you'd check the outcome and prevent a repeat.

    Common mistakes

    • Waiting until the deadline to say anything.
    • Promising you'll just work all night.

    Likely follow-up questions

    • What if your manager is unavailable?
    • Has this happened to you?
    Example strong answer

    I'd tell the person depending on it as soon as I realised, not at the deadline. Before that conversation I'd work out how far off I am and why, so I could offer options: delivering the most important part on time and the rest a few days later, getting help from a colleague, or agreeing a new date. Then I'd let them decide what works best for them, and keep them updated. Afterwards I'd look at why it slipped — usually underestimating something — so I plan better next time.

Ready to answer them out loud?

Run a timed mobile app developer mock interview, type or speak your answers, and get a score breakdown with what to improve.

Interview questions for related roles