Mobile Developer Test Example Questions: What to Ask

Why example questions matter

Most mobile developer assessments are built wrong. They either lean into trivia (what's the lifecycle method name in Android 11?) or they're so open-ended they collapse under their own weight. The right example questions sit in the middle: specific enough to be graded, broad enough to reveal judgment.

If you're building a mobile assessment from scratch, knowing what kinds of questions work is half the battle. Here are the patterns that actually predict job performance.

iOS-specific questions

1. View controller lifecycle with state

"A login screen loads. On first render, it fetches the auth session from the keychain. If the session is invalid, it refreshes the token from the server. Write the code for viewDidLoad and viewWillAppear that handles this without duplicate API calls."

This tests: understanding of ViewController lifecycle, state management, networking, and defensive programming. It's not trivia. A junior writes it differently than a senior, and both versions are learnable.

2. Memory leak in delegation

"Here's a view controller that holds a strong reference to a delegate. The delegate (a manager object) holds a strong reference back to the view controller. Write a test that catches this retain cycle."

This moves beyond static knowledge. It requires understanding the problem, designing a test, and fixing it. Real work.

3. SwiftUI + async-await navigation

"You have a navigation stack. When a button is tapped, you need to fetch data, show a loading state, then navigate to a detail screen. Write the code using async-await and @State."

This is current. It eliminates candidates who haven't kept up and prioritizes people who understand modern concurrency patterns.

Android-specific questions

1. Fragment lifecycle with saved state

"A fragment displays a list of items. The list is fetched from the network. If the user rotates the device, the list should persist without re-fetching. Write the code using ViewModel and SavedInstanceState."

Tests: lifecycle, state persistence, and modern architecture patterns. Not trivial, not impossible.

2. Dependency injection in tests

"You have a repository that depends on an API service. Write the test setup code that mocks the service and ensures the repository handles a 500 error correctly."

This reveals whether they think about testability at design time.

3. Custom permissions with a callback

"Request camera permission at runtime. If denied, show a dialog explaining why. If granted, open the camera. Write the code."

Practical, modern Android. Not about memorizing API names.

React Native (cross-platform)

1. Navigation state leak

"You have two screens in a navigation stack. Screen A fetches data when it mounts. When the user navigates to Screen B and back to A, the data should be re-fetched, not cached. Write the code using React Navigation and hooks."

This tests state lifecycle understanding and a common source of bugs.

2. Performance: FlatList with images

"You have a FlatList rendering 1000 image items. It's slow. Write the code that fixes it (keyExtractor, getItemLayout, or image resizing)."

Practical debugging. The candidate either knows the problem or doesn't.

3. Bridge to native module

"You need to call a native function from JavaScript. Write the bridge code for iOS or Android, including error handling."

This tests whether they understand the boundary and can work across it.

General mobile questions (all platforms)

1. API versioning trade-off

"Your API changed a response schema. Old clients are still in the wild. Write the code in the mobile client that handles both versions."

Tests: pragmatism, defensive programming, and backward compatibility thinking.

2. Offline-first state sync

"The user edits an item while offline. How do you queue that edit and sync it when the connection returns? Write the pseudocode."

This is architecture-level. The answer reveals design maturity.

3. App startup performance

"Your app takes 4 seconds to launch. What are three things you'd check and why? Write the code for one of them."

Open-ended enough to reveal thinking. Specific enough to ground it.

How to grade these questions

Don't grade on polish. Grade on:

• Does it work? Does the code do what was asked?
• Would you deploy it? Are there edge cases unhandled?
• Can they explain it? In a walk-through, can they reason about their choices?

For mobile work specifically, a live coding interview with these kinds of questions reveals more than artifact alone because the candidate has to navigate the tools and their own uncertainty in real time.

What to avoid

Don't ask:

• "What's the difference between Strong and Weak references?" (trivia)
• "Implement an entire chat app" (too broad, ungraded)
• "What does this obscure flag do?" (meaningless)

Do ask:

• Problems with clear success criteria
• Problems that show judgment (trade-offs, not just correctness)
• Problems that look like work

These example questions anchor your assessment to the job. Start with them, add your own domain-specific variants, and validate the assessment once you're live.

Next steps

If you're assessing mobile developers at scale, having a consistent set of examples across your team prevents drift. Use these as a template, customize for your stack, and iterate based on what you learn from hired candidates.