All roadmaps

React.JS Developer

Think in components, ship real features.

React in depth for JavaScript developers: the component model, hooks without foot-guns, routing, server state, forms, performance and testing - the React that teams actually hire for.

Your progress0/51 topics · 0%

Progress is saved in this browser.

8 stages51 topics₹0 to follow

Filled nodes are the focus for this track; outlined ones can wait. Tap a topic to open it and mark it done, learning or skipped.

React.JS Developer in 2026Related roadmapsJavaScript roadmapTypeScript roadmapFrontend roadmapProve it as you goReading is half of it. This roadmap isbacked by a free, scored React.JSDeveloper certification with a publicverification link and a Frontend Engineerjob simulation on real tickets - evidencea recruiter can check, not a claim. Marktopics done, learning or skipped as yougo; your progress carries into theclassic view.Get certified - freeJob simulationClassic viewKnow the demand before thesyntaxReact.JS Developer in 2026What to learn in 2026React 19 andhooksNext.js anddataAI-generated ReactWhich roles use itFrontend andfull stackMobile withReact NativeFresher vs switcherWhat companies expectThe hiring barWhat interviewstestProof they verifyWhat gets you hiredA 90-day planProjects thatget readCertification and proofBuild UIs from composablepieces.Component ModelJSX & renderingProps & compositionLists & keysThinking in ReactHandle user input the Reactway.State & InteractivityuseStateControlled formsLifting & sharing stateuseReducerMaster the model everyonemisuses.Effects & Hooks DisciplineuseEffect honestlyuseContextuseRef & DOM escape hatchesCustom hooksReal apps: multiple pages,remote data.Routing & Server StateClient routingData fetching & cachingLoading, error & emptystatesMeta-frameworks (awareness)Apps that stay fast andrefactorable.Quality & PerformanceRendering & memoisationCode-splitting & lazyloadingTesting componentsTypeScript in ReactThe layer that professionalcodebases assume.Advanced Patterns & EcosystemError boundaries & portalsSuspense & concurrentfeaturesState-management librariesStyling & componentlibrariesForms & validation at scaleAnimationPortfolio piece + verifiedcredential.Prove ItCertificationFresher or experienced?Both tracks hold every topic. On the Fresher track thefoundations are filled and the later stages are outlined - dothem when a project needs them. On the Experienced track thefoundations are outlined and the later stages are filled. The2026 section at the top applies to both.Prefer a list?The classic view shows the same 7 stages as a sequentialchecklist with time estimates. Your marks are shared betweenthe two views.Open the classic view

Everything on this roadmap

Every stage and topic on the map, in reading order. Click any topic to open it.

The React.JS Developer roadmap, topic by topic

Every topic on the map in reading order, with what to learn and the resources we recommend. Main topics are open; open any subtopic to read it. Select a topic name to open it in the topic panel, where you can track your progress.

  1. 1. Know the demand before the syntax

    React.JS Developer in 2026

    2026

    React is the default user interface library of the web and, since 2025, the default output of AI app builders, which generate React with Tailwind and shadcn components unless told otherwise. The Stack Overflow 2025 survey has React use rising from 39 to 44 percent of all developers; the State of React 2025 survey of 3,760 developers found React 19 at 48 percent daily use within months of release; the State of JavaScript 2025 survey reports it used by about 84 percent of JavaScript developers. The four nodes answer what to learn in React in 2026, which roles use it, what companies expect and what gets you hired.

    What to learn in 2026

    Learn React 19 as it is written now - function components, hooks, the rendering model, server and client components - then Next.js as the meta-framework most jobs and AI builders assume, with data fetching, caching and forms done its way. Finally learn to work with generated React: reviewing it for state bugs, accessibility and performance. The sub-nodes order those three. The State of React 2025 survey shows TanStack Query as the most used data library and single-page apps still at 85 percent of respondents' work, so both the old and the new models matter.

    React 19 and hooks

    React in 2026 means React 19: function components and hooks, state and effects used sparingly, the rendering model understood well enough to explain a re-render, context and reducers for shared state, suspense, transitions and the new form actions. The State of React 2025 survey found React 19 at 48 percent daily use and single-page applications still 85 percent of work, so the classic client model and the newer server model both matter. Learn the rules of hooks by understanding why they exist, and learn the React DevTools profiler before you learn a performance library.

    Next.js and data

    Next.js is the meta-framework most React job descriptions name and the one AI builders such as v0 and Lovable generate: routing, server components, server actions, data fetching with caching, image and font handling, and deployment on Vercel. Data on the client is TanStack Query, which the State of React 2025 survey ranks the most used data-fetching library, with forms done through actions or a validated form library. Learn one data model well - when to fetch on the server, when to cache, when to mutate - and the rest of the ecosystem becomes a choice rather than a mystery.

    AI-generated React

    AI

    Most new React in 2026 is generated first: builders emit a component tree with Tailwind and shadcn, agents add features to it, and the engineer's job is the review. Generated React has characteristic faults - state duplicated across components, effects that should be derived values, missing keys, inaccessible markup, unmemoised work in a hot path. The Stack Overflow 2025 survey finds 80 percent of developers using AI tools and 46 percent distrusting their accuracy; GitHub reports 80 percent of new developers using Copilot in their first week. Knowing React's rendering model is what lets you fix the draft in minutes instead of shipping it.

    Which roles use it

    React is the frontend half of the frontend and full stack jobs, the whole of a React Native mobile job, and part of most design-engineering and product-engineering roles. The sub-nodes name the web roles, the mobile route and the fresher and switcher paths.

    Frontend and full stack

    Frontend developer and full stack developer are the two titles that hire for React most, and the Stack Overflow 2025 survey shows React use climbing to 44 percent of all developers. Product companies, SaaS, e-commerce and the global capability centres want React with TypeScript and Next.js; agencies want speed with the same stack; design-engineering roles want React plus design-system and animation skill. The Frontend roadmap holds the rest of the frontend path; the Full Stack roadmap adds the server.

    Mobile with React Native

    React Native takes the same component model to iOS and Android, usually through Expo, and is how many web developers move into mobile without learning Swift or Kotlin. The roles are mobile developer and cross-platform developer at product companies and agencies, and the hiring question is whether you understand what differs from the web: navigation, native modules, performance on real devices, app-store releases. Learn React on the web first; the State of React 2025 survey shows the ecosystem's centre of gravity is still there, and the mobile skills transfer from it.

    Fresher vs switcher

    A fresher should ship one React application that is clearly theirs - explained, deployed, typed - before applying; HackerRank's 2025 report found junior hiring the hardest hit and 74 percent of developers struggling to land a job, so an explainable project is the lever. A switcher from Angular, Vue, jQuery or from design should map what they already know onto React's model and spend the time on hooks and data. On this map, freshers get the basics filled and the later stages outlined; experienced learners get the reverse.

    What companies expect

    Companies expect React understood at the level of rendering, state and data - not just components assembled - with TypeScript, with accessibility, and with the judgement to fix what an AI builder generated. HackerRank's 2025 report says practical assessments are now the standard. The sub-nodes cover the bar, the interview and the proof that gets verified.

    The hiring bar

    The bar is a React application a senior engineer would merge: typed, accessible, fast enough, with state in the right place, effects used only for synchronisation, data fetched and cached deliberately, and forms that handle errors. The Work Trend Index found 71 percent of leaders would prefer a less experienced candidate with AI skills over a more experienced one without; React teams expect you to use the builders and agents, and to explain what you changed in what they produced.

    What interviews test

    Expect a practical build - a component or small feature from a spec, often with an AI tool allowed - plus questions on the rendering model, hooks, state management, data fetching, forms, accessibility and performance, and a walk through your project. HackerRank's 2025 report says 66 percent of developers prefer practical assessments and that they are the standard; product companies still add a JavaScript algorithms round. The interviewer wants to hear why a re-render happened and how you stopped it.

    Proof they verify

    Reviewers open the live app and read the components: are state and effects sane, are there keys and labels and focus states, does it handle loading and failure, is it typed. A deployed Next.js app with real data beats a to-do list; a readable component tree beats a clever one; OneRoadmap's free React certification with its public verification link beats a course badge. A note on what the builder generated and what you fixed is now part of the proof.

    What gets you hired

    A deployed React or Next.js application with real data, forms and error states, a repository whose components a reviewer can read, a verified certification and a clear account of what the tools generated and what you changed. The sub-nodes give the ninety-day plan, the projects that get read and the proof that counts.

    A 90-day plan

    Month one: React 19 fundamentals on small typed components - state, effects, forms, lists - deployed as you go. Month two: a Next.js application on a public or real API with TanStack Query or server data, forms with validation and error states, built with an AI tool and reviewed by you. Month three: accessibility and performance passes, tests on the critical flows, a readme with the decisions and the generated parts you changed, the React certification, and twenty targeted applications a week.

    Projects that get read

    Projects that get read exercise React's real problems: a data dashboard with filters, pagination, caching and error states; a multi-step form with validation and accessibility; a component library with documentation, tests and a theme; a small real-time feature with optimistic updates. Each needs a live link and a readme. The World Economic Forum's Future of Jobs 2025 report puts software developers among the fastest-growing roles and 39 percent of skills changing by 2030; a project on React 19 and Next.js, built with the 2026 tools and explained, is the evidence that you kept up.

    Certification and proof

    Proof is verifiable: OneRoadmap's free React certification with a public link, a GitHub profile with real commits, a deployed application and a short account of your AI workflow. Octoverse 2025 counts more than 180 million developers on GitHub with India the largest source of new ones; the React developers who get replies are the ones whose work a reviewer can open and check.

  2. 2. Build UIs from composable pieces.

    Component Model

    Build UIs from composable pieces.

    Time: about 2 weeks. Topics: JSX & rendering · Props & composition · Lists & keys · Thinking in React.

    JSX & rendering

    Optional on the Experienced track

    Markup as expressions, conditional rendering and fragments - UI as a function of state.

    Props & composition

    Optional on the Experienced track

    Data down, events up; children and slot patterns - assembling screens from small parts.

    Lists & keys

    Optional on the Experienced track

    Rendering collections, stable keys and empty states - where subtle UI bugs are born.

    Thinking in React

    Optional on the Experienced track

    Breaking a mock into a component tree and deciding where state lives - the design skill behind clean apps.

  3. 3. Handle user input the React way.

    State & Interactivity

    Handle user input the React way.

    Time: about 2 weeks. Topics: useState · Controlled forms · Lifting & sharing state · useReducer.

    useState

    State as a snapshot, updater functions and batching - why 'it's one behind' happens and how to fix it.

    Controlled forms

    Inputs bound to state, validation and submission - the highest-traffic pattern in product code.

    Lifting & sharing state

    Moving state to the closest common parent, and recognising when you actually need context.

    useReducer

    State machines for complex updates - predictable transitions instead of scattered setters.

  4. 4. Master the model everyone misuses.

    Effects & Hooks Discipline

    Master the model everyone misuses.

    Time: about 2 weeks. Topics: useEffect honestly · useContext · useRef & DOM escape hatches · Custom hooks.

    useEffect honestly

    Synchronising with external systems: dependencies, cleanup and strict-mode double-invoke - and the many effects that shouldn't exist.

    useContext

    App-wide values (theme, auth) without prop drilling - and its re-render cost.

    useRef & DOM escape hatches

    Mutable boxes and imperative DOM access (focus, scroll) - leaving the declarative world safely.

    Custom hooks

    Extracting reusable logic (useLocalStorage, useDebounce) - the composition unit of modern React.

  5. 5. Real apps: multiple pages, remote data.

    Routing & Server State

    Real apps: multiple pages, remote data.

    Time: about 2-3 weeks. Topics: Client routing · Data fetching & caching · Loading, error & empty states · Meta-frameworks (awareness).

    Client routing

    Routes, params, nested layouts and redirects with React Router - URL as application state.

    Data fetching & caching

    React Query mindset: queries, invalidation, optimistic updates - replacing useEffect-fetch spaghetti.

    Loading, error & empty states

    Suspense-ready thinking: every remote read has three extra states users will see.

    Meta-frameworks (awareness)

    Next.js: server components, file routing and when an SPA isn't the right default.

  6. 6. Apps that stay fast and refactorable.

    Quality & Performance

    Apps that stay fast and refactorable.

    Time: about 2 weeks. Topics: Rendering & memoisation · Code-splitting & lazy loading · Testing components · TypeScript in React.

    Build: Feature-complete app. A deployed React + TS app with routing, remote data, forms and tests on the critical path.

    Rendering & memoisation

    Why components re-render; memo, useMemo and useCallback - measured with the Profiler, not guessed.

    Code-splitting & lazy loading

    lazy + Suspense and route-level splitting - shipping less JavaScript to first paint.

    Testing components

    Testing Library: test behaviour users see, not implementation details.

    TypeScript in React

    Typing props, events, children and hooks - the professional default.

  7. 7. The layer that professional codebases assume.

    Advanced Patterns & Ecosystem

    The layer that professional codebases assume.

    Time: about 2 weeks. Topics: Error boundaries & portals · Suspense & concurrent features · State-management libraries · Styling & component libraries · Forms & validation at scale · Animation.

    Error boundaries & portals

    Catching render crashes gracefully and escaping the DOM tree for modals and toasts.

    Suspense & concurrent features

    Declarative loading boundaries, transitions and streaming - the model modern frameworks build on.

    State-management libraries

    Zustand, Redux Toolkit and Jotai - when component state stops scaling and which tool fits which shape of app.

    Styling & component libraries

    CSS Modules vs Tailwind vs component systems (Radix, shadcn/ui) - accessible primitives over reinvented wheels.

    Forms & validation at scale

    react-hook-form + zod: performant forms with one schema validating client and server.

    Animation

    Motion (Framer Motion) for enter/exit and layout animation - polish that respects reduced-motion.

  8. 8. Portfolio piece + verified credential.

    Prove It

    Portfolio piece + verified credential.

    Time: about 1 week. Topics: Certification.

    Certification

    Take the OneRoadmap React certification - verified proof recruiters can check.

Prove it as you go

Reading is half of it. This roadmap is backed by a free, scored React.JS Developer certification with a public verification link and a Frontend Engineer job simulation on real tickets - evidence a recruiter can check, not a claim. Mark topics done, learning or skipped as you go; your progress carries into the classic view.

Fresher or experienced?

Both tracks hold every topic. On the Fresher track the foundations are filled and the later stages are outlined - do them when a project needs them. On the Experienced track the foundations are outlined and the later stages are filled. The 2026 section at the top applies to both.

Prefer a list?

The classic view shows the same 7 stages as a sequential checklist with time estimates. Your marks are shared between the two views.

Frequently asked questions

Is React still the right choice in 2026?

Yes. The Stack Overflow 2025 survey shows React use rising to 44 percent of developers, the State of JavaScript survey finds it used by around 84 percent of JavaScript developers, and it is what AI app builders generate by default. The jobs, the learning material and the ecosystem are larger than any alternative's.

Do I need to learn JavaScript before React?

Yes, properly: functions, closures, arrays and objects, promises and async, modules and the DOM. React is a library on top of those, and every React bug you cannot explain is usually a JavaScript concept you skipped. TypeScript comes right after, because that is how React is written now.

Next.js or plain React?

Learn React's model first - components, hooks, state, rendering - on a small plain project, then Next.js as the framework most jobs and AI builders assume. Next.js adds routing, server components, data fetching and deployment; learning it before you understand React makes its magic confusing instead of convenient.

Which state management library should I learn?

None first. Learn React's own state, context and reducers, then TanStack Query for server data, which the State of React 2025 survey ranks the most used data library. Reach for a store such as Zustand or Redux only when a real project needs shared client state that React's tools make awkward.

How long does it take to learn React?

With JavaScript in place, a few weeks to build with it and a few months to understand rendering, data and performance well enough for interviews. Nobody can promise a timeline. The evidence is a deployed Next.js application with real data, forms and error states, and a certification a reviewer can verify.

Should I learn React Native for mobile?

After React on the web. React Native and Expo take the same component model to iOS and Android and are how many web developers move into mobile; the new skills are navigation, native modules, device performance and app-store releases. The web is still where the ecosystem's centre of gravity sits.

Will AI replace React developers?

AI builders generate React components by the thousand, and they generate the classic faults - duplicated state, effects that should be derived values, missing keys, inaccessible markup - just as readily. Knowing React's rendering model is what lets you fix a generated draft in minutes rather than ship it. The review has become the job.

How do I prove React skills without job experience?

A deployed Next.js application with real data, filters, forms, error and loading states, accessibility done properly and tests on the critical flows; a readme that explains the decisions and what the builder generated versus what you changed; a GitHub profile with real history; and OneRoadmap's free React certification with its public verification link.