How to assess · For hiring teams

How to Assess React Native Skills When Hiring

The test formats that actually work for React Native, what a strong answer looks like, sample questions and a scoring rubric you can use as-is.

The short answer

Assess React Native with a task, not a conversation: fix a janky screen, build a screen from a spec, ai-scored assessment (e.g. cohesyve) or architecture conversation. Score it against written criteria you fix before you see any submissions, and weight the criteria that the role actually depends on.

Understands the architecture: the JavaScript thread, the native side, and what crosses between them
Keeps lists and animations smooth: FlatList discipline, memoisation with reasons, animations on the native driver
Manages navigation and state so screens survive background, deep links and back navigation
Knows when a native module is needed and can read or write one

Build a React Native assessment →Read the full article ↓

Paste a job description; Cohesyve generates a role-specific assessment and rubric. Ten candidates free, no card.

React Native promises one codebase for two platforms, and the developers who deliver on it are the ones who understand where the promise breaks: performance on the JavaScript thread, native modules when the framework does not reach far enough, and the differences between iOS and Android that no abstraction hides. A strong React developer is not automatically a strong React Native developer. This page covers how to assess React Native for mobile roles: React fundamentals, mobile performance, navigation and state, native integration, and the practical work of shipping to two stores.

Why React Native is worth testing

React Native apps fail in ways web apps do not: a list that stutters, a gesture that lags, an animation that drops frames, a native crash the JavaScript never sees. They come from running heavy work on the JavaScript thread, re-rendering carelessly, and not knowing when to drop to native. Testing shows whether a candidate has mobile judgement or only web judgement, and the difference is visible to every user of the app.

What strong React Native looks like

Understands the architecture: the JavaScript thread, the native side, and what crosses between them
Keeps lists and animations smooth: FlatList discipline, memoisation with reasons, animations on the native driver
Manages navigation and state so screens survive background, deep links and back navigation
Knows when a native module is needed and can read or write one
Handles platform differences explicitly rather than hoping the abstraction covers them
Tests components and logic, and can profile a slow screen
Has shipped: builds, signing, over-the-air updates and store submission on both platforms

Ways to assess React Native

Fix a janky screen

Provide a small app with a stuttering list (inline functions, no keys, heavy render), an animation running on the JavaScript thread, and a re-render storm from context misuse. Ask the candidate to diagnose and fix.

Pros

The performance defects users feel; scoreable with a profiler.

Cons

Needs a runnable project and a device or simulator.

Best for Mid and senior React Native roles.

Build a screen from a spec

Ask for a list-and-detail flow with navigation, loading and error states, and one gesture, in a capped take-home.

Pros

Shows React fundamentals, mobile handling and structure.

Cons

Take-home verification.

Best for Any level; scale via the spec.

AI-scored assessment (e.g. Cohesyve)

Generate a React Native task from the job description — a performance review, a state design, a native-module scenario — with a rubric. Each candidate receives a different variant; reasoning is scored with the code.

Pros

Asynchronous and consistent; unique per candidate; the reasoning about threads and rendering is what scores.

Cons

Cannot run on a device; have finalists demo.

Best for Screening before pairing.

Architecture conversation

Describe a feature needing a native capability the framework lacks and ask how they would approach it.

Pros

Reveals whether they know the boundary of the framework.

Cons

Talk-based; verify hands-on.

Best for Senior mobile engineers.

Cohesyve

Run a React Native assessment on your next opening

Cohesyve generates a unique React Native task per candidate from your job description, with the scoring rubric attached. Questions are different for every applicant, so they cannot be shared or looked up.

Try it free →Book a 30-min demo

What to test

Performance

Whether the app stays smooth on a real device.

Fix a FlatList that drops framesMove an animation to the native driverFind the cause of a re-render storm

State and navigation

Whether the app behaves across screens and lifecycles.

Design state for a multi-step flow that survives backgroundingHandle a deep link into a nested screenExplain where global state should and should not live

Native integration

Whether they know where the framework ends.

Explain when a native module is necessaryRead a small native module and describe what it doesHandle a platform-specific permission flow

Testing and shipping

Whether the app is verifiable and releasable.

Write a component test with a mocked APIExplain the release path on both storesDescribe how an over-the-air update is rolled back

Sample React Native questions

Why might a FlatList stutter, and what are the first three things you check?

Entry

Look for Inline render functions, missing keys, heavy items; memoisation, `getItemLayout`, window size.

What is the JavaScript thread, and what happens when it is busy?

Entry

Look for Runs the app logic; when blocked, UI driven by it lags; animations should run on the native side.

A screen re-renders on every keystroke in an unrelated input. What is likely happening?

Mid

Look for Context or parent state changes causing child re-renders; fix with memoisation, splitting context or moving state down.

You need a capability the framework does not provide. What are your options?

Mid

Look for Community library first, then a native module; how to write and bridge one; cost of maintaining it.

How do you keep an app smooth as it grows to fifty screens?

Senior

Look for Profiling as habit, lazy screens, disciplined state, native driver for animations, and measuring on low-end devices.

Red flags

Cannot explain the JavaScript thread
Has never profiled a screen
Treats React Native as "React on a phone" with no mobile-specific knowledge
Has never touched a native module
Has not shipped to both stores

Scoring rubric

Criterion	Weight	What strong looks like
Performance	30%	Lists and animations are smooth; causes are diagnosed with tools.
State and navigation	25%	State survives lifecycles; navigation is robust.
Native awareness	20%	Knows the boundary and can cross it.
React fundamentals	15%	Rendering is understood and controlled.
Shipping	10%	Knows both stores and OTA updates.

Mistakes hiring teams make

Testing web React and assuming mobile transfers
Not planting a performance defect — the defining React Native problem
Ignoring native integration entirely
Accepting a screen that looks fine on a simulator and stutters on a device
Skipping the two-store shipping question

Roles that need React Native

React Native DeveloperMobile EngineerCross-Platform DeveloperFrontend DeveloperSenior Mobile EngineerMobile Lead

Common questions

Can a React developer do React Native?

They can start. The React part transfers; the mobile part — performance on a device, lifecycles, native modules, two stores — does not. Test it specifically rather than assuming.

What is the best single React Native screening question?

Show a stuttering FlatList and ask what they check first. It reveals whether they think about rendering and threads or only about components.

Do React Native developers need native iOS or Android skills?

Enough to read a native module, handle platform-specific setup and debug a native crash. Deep native skill is a bonus, not a requirement, for most roles.

How do I assess without a device?

Architecture and performance reasoning work on paper; code review of a janky component tests the same judgement. Confirm on a device with finalists.

Cohesyve · Skill assessments for hiring

Test React Native before the first interview

Generate a role-specific React Native assessment from your job description and see who can do the work before you spend interview time on them.

1,500+

assessments completed

50%

faster time-to-hire

90%

completion rate

5 min

from JD to assessment

No credit card · 10 free candidates · Plans sized to your hiring volume

From the blog

Related skill guides