Cross-platform work used to be judged by how close an app could get to native. That argument has mostly faded, because both frameworks have matured: the New Architecture is now the only option in current React Native, Expo has become the recommended way to start, and Flutter’s Impeller renderer has dealt with much of the old shader stutter. The hard parts have moved. Store rules and operating system changes arrive every year, dependencies can hold a whole app back, and AI assistants write screens so quickly that typing widgets is no longer what you are hiring for. React Native and Flutter developer skills now show most clearly in what happens outside the UI layer.
This post lists eight core skills with checks for each framework, then the working habits, what has changed in weight, a matrix by level and an assessment approach. The two frameworks are separate skills, so run the framework-specific parts of each check for the one you use.
Core technical skills for cross-platform mobile developers
Language depth and concurrency
React Native developers need asynchronous JavaScript and strict TypeScript. Flutter developers need Dart’s null safety, sealed classes and pattern matching, and an understanding of isolates. The two languages handle heavy work differently, and both punish blocking the wrong thread. How to check it: say parsing a large JSON response makes the screen freeze for a moment. In Flutter, ask how they would move that work off the main isolate. In React Native, ask what is blocked and what their options are. Good answers cover streaming or paging the data as well as moving it.
Threading and animation
Smooth motion depends on where the animation runs. In React Native, Reanimated worklets run on the UI thread, so a busy JavaScript thread does not stall them. In Flutter, developers need to know how widget, element and render trees relate, and when RepaintBoundary helps. How to check it: describe a bottom sheet animation that stutters at the moment a network response arrives. Ask what is competing for time and how they would confirm it, using the Flutter performance view or React Native’s profiling tools.
Navigation and deep links
Routing looks easy until a link arrives from outside the app. Universal Links, Android App Links and push notifications must all land on the right screen with sensible back behaviour, and payment apps add UPI return flows on top. How to check it: say a notification opens an order detail page while the app is closed and the session has expired. Ask them to walk through what should happen from launch to the correct screen. Strong candidates cover the pending destination, the login detour and what the back gesture does afterwards.
Startup time and app size
Many users in India are on budget phones with limited storage, so a heavy app costs installs. Good developers measure cold start on such devices and know the levers: Hermes bytecode on React Native, deferred loading on Flutter, Android App Bundles, trimmed assets and lazy initialisation of SDKs. How to check it: say the app takes far too long to show its first screen on a budget phone, with several analytics and payment SDKs starting up. Ask how they would measure each part, and what they would delay until after the first frame.
Background work and operating system limits
Both platforms restrict what an app can do when it is not on screen, and some Android manufacturers kill background work more aggressively than the standard OS does. Developers need to know what WorkManager and iOS background tasks can and cannot promise. How to check it: say a delivery app’s location updates stop on certain Android phones after the screen has been off for a while. Ask why, and what the honest fix is. Good answers mention foreground services, manufacturer battery settings and telling the product team what cannot be relied on.
Dependency health
Every package links an app to someone else’s maintenance schedule, across two operating systems. Careful developers check a library before adopting it and have a plan for one that gets abandoned. How to check it: show a package.json or pubspec.yaml containing a camera library with no release in a long time, and no support for the New Architecture or the current Flutter version. Ask for their options. Look for checking the alternatives, forking with care, or writing a small Turbo Native Module or plugin, with some sense of what each will cost later.
Builds, signing and CI
A surprising number of app developers have never owned a build. Good ones can read Gradle and Xcode errors, understand provisioning profiles and keystores, and automate delivery with Fastlane, EAS or Codemagic. How to check it: say a build works on the developer’s laptop and fails on CI with a signing error, and ask how they would trace it. Then ask where the Android signing key should live and what happens if it is lost. Candidates should know about Play App Signing, and should treat credentials as something the company owns.
Mobile security and privacy
App bundles can be unpacked, so anything shipped in one should be treated as readable. Tokens belong in Keychain or Android Keystore, usually through a secure storage library. Apple’s privacy manifests and Google Play’s Data safety form also make developers answerable for what their SDKs collect. How to check it: find an API key hard-coded in a sample app and ask what an attacker could do with it, then where a refresh token should live. Ask too how they would find out what data a third-party SDK sends before filling in the store declarations.
Working skills that separate good from average
- Defending platform conventions. Android and iOS users expect different back behaviour, sheets and gestures. Strong developers raise this with designers early, instead of building one design that feels wrong on both.
- Ranking crashes by harm. Good developers look at affected users and the journey involved, so a rare crash at checkout goes ahead of a common one on a settings screen.
- Setting expectations about release. Store review, staged rollouts and users who never update all shape how quickly a fix reaches people. Good developers explain this to product managers ahead of launch day.
- Working with native colleagues. On teams with Kotlin or Swift developers, the best cross-platform people ask for help early, and they write interfaces that a native developer can pick up.
How the skill mix has shifted in 2026
Mattering more. Keeping up with platform policy is now steady work: Google Play raises its target API level each year and will block updates to apps targeting Android 15 or higher that lack 16 KB memory page support, Android has enforced edge-to-edge layouts for newer targets, and Apple keeps tightening privacy requirements. Reading native code matters more because AI assistants handle shared screens well and struggle at the boundary with Kotlin and Swift. Over-the-air update discipline has grown as teams rely on EAS Update or Shorebird for Flutter, within what store rules permit.
Mattering less. Knowledge of the old React Native bridge is now mainly useful for rescuing legacy apps. Workarounds for shader compilation jank matter far less on Impeller. Hand-writing repetitive widget code or Redux boilerplate counts for less, as assistants and lighter state libraries such as Zustand and Riverpod reduce it.
React Native and Flutter skills matrix by level
| Skill area | Junior | Mid-level | Senior |
|---|---|---|---|
| Language | Sound TypeScript or Dart basics | Handles async work and isolates or threads | Sets language and code standards |
| Performance | Avoids obvious rebuilds and re-renders | Profiles on budget devices and fixes causes | Sets startup and size budgets |
| Navigation | Adds screens to existing routes | Handles deep links and auth redirects | Designs routing for the whole app |
| Native boundary | Uses existing plugins | Writes a simple module or plugin | Decides what stays native |
| Dependencies | Installs packages with review | Vets libraries and handles upgrades | Plans major version moves |
| Build and release | Runs builds and follows the checklist | Owns CI, signing and staged rollouts | Owns release policy and recovery plans |
| Security and privacy | Keeps secrets out of code | Uses secure storage and completes declarations | Audits SDKs and data flows |
How to assess these skills in a hiring process
Shipped apps are the best evidence, though a store listing cannot tell you who did what. Be clear on the framework in your React Native and Flutter developer job description, then have a developer who writes that framework run these steps.
- Read a real crash report. Share a stack trace from Crashlytics or Sentry that appears only on one OS version. Ask what it suggests and what they would do next, including whether the release should be halted.
- Draw the hotfix path. Ask them to map how a critical fix reached users on their last app, from branch to rollout, on both stores. Include the point at which over-the-air delivery stops being allowed.
- Ask who held the accounts. People who have owned releases can describe the Apple Developer and Play Console setup, certificates and roles. Those who only built screens will be vague.
Red flags on a CV: equal claims on both frameworks with no app to show for either; apps with no update in a long time; “cross-platform” experience tested on Android only; only demo projects that never left the simulator; and no mention of crashes, ratings or releases.
Frequently asked questions
Can a Flutter developer take over a React Native app?
They can, but treat it as learning a new stack. Mobile knowledge such as release handling, navigation patterns and native limits transfers. Language, rendering model and tooling do not, so plan for a slower start and pair them with someone who knows the codebase.
Do these developers need a Mac for iOS work?
Building for iOS requires Xcode, which runs only on macOS, though cloud services such as EAS and Codemagic can produce builds remotely. Debugging iOS issues is far easier with a Mac and a real iPhone, so budget for both if iOS matters.
Is Expo acceptable for serious production apps?
Yes. The React Native team recommends a framework such as Expo for new apps, and development builds allow custom native code. Older opinions that Expo locks you in are out of date. Ask candidates how they handled native needs within it.
How much Kotlin and Swift is enough?
For mid-level developers, enough to read a stack trace, change a plugin and write a small bridge with help. Seniors should be comfortable shipping native modules on both platforms.
Whichever framework your app uses, contract, contract-to-hire and permanent terms are all open when you hire React Native and Flutter developers in India through Zilo AI. Native mobile, QA and backend roles for the same product are covered through our IT hiring service. Let us know the framework, the state of the app and your next release.