Why deep React knowledge separates juniors from seniors in India
React is now a commodity skill — every fresher knows useState and useEffect. What separates ₹6 LPA candidates from ₹25 LPA candidates is depth.
Indian product companies hiring React seriously:
- Razorpay, Cred, Flipkart, Myntra — React with TypeScript, often with Next.js
- Swiggy, Zomato — React on web, React Native on mobile
- Postman, Hasura, Atlan — React-heavy dev tools
- Microsoft IDC, Google India — React + TypeScript in many products
- Hotstar, Disney+ — Premium React experiences
- Most YC-backed Indian startups — React or Next.js by default
What "React knowledge" means at each level:
Junior (₹4-8 LPA):
- Knows useState, useEffect, basic hooks
- Can build a CRUD UI from a Figma design
- Can call REST APIs from React
- Has 1-2 small React projects on GitHub
Mid-level (₹10-20 LPA):
- Understands React rendering lifecycle deeply
- Custom hooks, useMemo, useCallback, useRef properly
- State management beyond useState (Zustand, Context, Redux Toolkit)
- React Query / TanStack Query for server state
- Performance: memo, lazy loading, code splitting
- React Testing Library
Senior (₹25-50 LPA):
- React internals: fiber, reconciliation, concurrent features
- React 19+ features: useTransition, useDeferredValue, Suspense for data
- Server Components and the RSC mental model
- Designing component APIs for large teams
- Advanced patterns: compound components, render props, headless UI
- Migration strategies (Class to Hooks, Pages to App Router)
Staff/Principal (₹50 LPA-1.5 Cr):
- Can write React Native, React DOM, React Server Components from first principles
- Architectural decisions: when NOT to use React (Astro, Qwik, etc.)
- Team-wide patterns, design systems, tooling
- Open source contributions or framework-level expertise
This guide focuses on jumping from Junior to Mid-level and Mid to Senior — the highest-ROI level transitions.
5 mental models you must internalize for senior React
Mental Model 1 — Components are functions of props and state: A React component is just a function that takes props + state and returns JSX. When state or props change, React calls the function again. That's it. Everything else (hooks, memoization, suspense) is plumbing around this core idea.
Mental Model 2 — Rendering is not "drawing to screen": "Render" in React means "calling the component function." Drawing to the DOM is a separate step (commit phase). A component can re-render many times without any DOM update — React diffs the virtual DOM and updates only what changed.
Mental Model 3 — State is owned by exactly one component: Where state lives determines what re-renders. Lift state up to share between siblings. Put state in a context to share across deep trees. Use Zustand/Redux for truly global state. Wrong state placement causes most React performance issues.
Mental Model 4 — Effects are escape hatches, not for derived state: Most useEffect uses are wrong. If you can compute a value from existing state during render, do that — don't use useEffect to "sync" state. The new React docs (react.dev) have a famous section: "You might not need an effect." Read it carefully.
Mental Model 5 — Server state is fundamentally different from client state: Don't use useState or Redux for data fetched from APIs. Use React Query / TanStack Query / SWR. These libraries handle caching, deduplication, refetching, optimistic updates, and stale-while-revalidate. Indian senior interviewers explicitly test for this distinction.
If you internalize these 5 models, your React code quality jumps two levels.
Hooks deep dive — useEffect, useMemo, useCallback, useRef
useEffect — the most abused hook:
When to use useEffect:
- Synchronizing with external systems (subscriptions, timers, third-party libraries)
- Fetching data when component mounts (though React Query is better)
- Setting up event listeners that need cleanup
When NOT to use useEffect:
- Computing derived values (do it during render)
- Resetting state when props change (use key prop instead)
- Setting state based on other state (compute during render or use useReducer)
- Coordinating with parent component (lift state up)
The mental check: "Could I delete this effect by computing the value during render?" If yes, delete it.
useMemo — when it actually helps:
useMemo caches the return value of a function across renders. Use it when:
- The computation is genuinely expensive (CPU-intensive)
- The result is referenced as a dependency in another hook
- The result is passed as a prop to a memoized child
DON'T use useMemo for:
- Simple primitive operations (the memoization overhead exceeds the benefit)
- Every value "just in case" — premature optimization
useCallback — same logic, for functions:
useCallback caches function references across renders. Use it when:
- The function is passed as a prop to a memo'd child (otherwise child re-renders)
- The function is a dependency in another hook
- You're using event handlers in lists with many items
DON'T use useCallback for:
- Every event handler "just in case" — causes complexity, often no real benefit
useRef — three legitimate uses:
- Holding mutable values that don't trigger re-renders (timers, intervals)
- Accessing DOM nodes directly (focus, measure, third-party libraries)
- Storing the previous value of a prop or state for comparison
Don't use useRef as a state replacement just because state causes re-renders. If something affects what users see, it's state.
Custom hooks — the underrated skill: Extract any repeated useState + useEffect + useCallback into a custom hook. Custom hooks are how you scale React knowledge across a team. Examples: useDebounce, useLocalStorage, useMediaQuery, useOnClickOutside.
If you can write good custom hooks, you've moved past Junior level.
State management in 2026 — what Indian companies actually use
The 2026 Indian React state management landscape:
Local state — useState and useReducer: Always start here. 80% of state should stay local to the component that uses it.
Cross-component state — React Context: Good for: theme, auth user, locale. Bad for: anything that changes frequently (causes all consumers to re-render).
Server state — React Query / TanStack Query: THE standard for API data in 2026. Used at Razorpay, Cred, Flipkart, Postman, almost every modern Indian startup. Replaces ~90% of what Redux used to do.
Features: automatic caching, refetching, deduplication, optimistic updates, infinite scrolling, pagination, stale-while-revalidate.
Global client state — Zustand (rising) or Redux Toolkit (legacy but still common):
Zustand is now the preferred choice at modern Indian startups:
- 4 KB bundle size
- No boilerplate
- Excellent TypeScript support
- Used at Razorpay, Cred, many YC startups
- Learning time: 1 day
Redux Toolkit is still the standard at:
- Larger enterprises (Flipkart, Microsoft IDC, older codebases)
- Teams with established Redux investment
- Apps with complex devtools / time-travel debugging needs
Jotai and Recoil are niche — atom-based state, used at some startups. Worth knowing about, not essential.
Form state — React Hook Form: THE standard for forms in 2026. Beats Formik on performance and TypeScript ergonomics. Almost universal at Indian product companies.
URL state — useSearchParams / nuqs: For state that should be shareable / bookmarkable (filters, search queries, pagination). Indian product company seniors increasingly emphasize this.
The senior framing: "Where should this state live?" is the most important question in React architecture. Wrong answer hurts performance and maintainability. Right answer: local first, lift only when needed, server state separate from client state, URL state for shareable filters.
React performance — measure, then optimize
Performance is a top interview topic at Indian product company senior rounds. Here's what matters:
Step 1 — Measure with React DevTools Profiler: Don't optimize blind. Profile in Chrome DevTools, identify which components re-render and why. Look for:
- Components rendering with same props (memo candidates)
- Long render times (split into smaller components)
- Cascading re-renders (state lifted too high)
Step 2 — Common performance fixes:
Memoize expensive components: const ExpensiveList = React.memo(({ items }) => ...) Combined with stable references via useCallback / useMemo on props.
Virtualize long lists: react-window or TanStack Virtual for lists >100 items. Renders only visible rows. Essential for Indian product apps with large data tables.
Code split with React.lazy + Suspense: Don't ship the entire app on first load. Lazy-load routes and heavy components.
Defer non-urgent updates: useTransition() lets you mark state updates as low-priority. Search-as-you-type benefits hugely from this.
Debounce expensive operations: Use lodash.debounce or a custom useDebounce hook for search inputs, scroll handlers, resize listeners.
Step 3 — Bundle optimization:
- Tree-shaking: import only what you need from lodash, date-fns
- Replace heavy libraries: moment.js → date-fns (10x smaller), lodash → es-toolkit
- Analyze bundle: npm install --save-dev source-map-explorer
Step 4 — Image optimization:
- Use next/image (if Next.js) — automatic lazy loading, format conversion
- Otherwise: srcset + sizes + loading="lazy"
- WebP / AVIF formats save 40-60% bandwidth
Step 5 — Network optimization:
- React Query caches API responses
- Prefetch on hover (use TanStack Query's prefetchQuery)
- Use Suspense for data fetching (concurrent React feature)
Indian interview question pattern: "Our React app is slow on the /products page. How would you debug and fix it?" Expected: profile → identify slow component → check for unnecessary re-renders → check for large lists (virtualize) → check API calls (cache with React Query) → check bundle size → check image sizes.
A confident systematic answer impresses senior interviewers.
React Server Components and the SSR shift in 2026
React Server Components (RSC) is the biggest architectural shift in React's history. Most Indian companies are now adopting or evaluating it.
The RSC mental model:
- Server Components render on the server only — they can't use useState, useEffect, or browser APIs
- They CAN directly access databases, file systems, and secrets
- Client Components ("use client" directive) work as React always has
- Server Components stream HTML to the browser, then hydrate
Why this matters in India:
- Indian e-commerce sites need fast first paint on slow networks — RSC dramatically helps
- Mobile-first Indian users benefit hugely from less JavaScript shipped to the browser
- SEO-critical sites (jobs portals, ecommerce, news) need server rendering
- Most new Indian projects in 2026 start with Next.js App Router (RSC by default)
Where RSC is used in India today:
- Most new Next.js projects at Razorpay, Cred, modern YC startups
- Internal tools and dashboards (especially at Postman, Hasura)
- E-commerce migrations to Next.js App Router
Where RSC is NOT used:
- Existing Next.js Pages Router apps (still very common)
- Apps that don't use Next.js (RSC requires a framework)
- SPAs / dashboards that don't need server rendering
Learning path for RSC:
- Learn vanilla React deeply first (3-4 months)
- Learn Next.js Pages Router (1 month)
- Then Next.js App Router with RSC (1-2 months)
- Practice the "Client component vs Server component" decision repeatedly
The interview signal: Senior Indian React interviewers in 2026 ask: "When would you use a Server Component vs a Client Component?" Strong answers show understanding of: bundle size, data fetching location, browser-only APIs, interactivity, and the new mental model.
Don't skip RSC — it's the future of React at Indian companies.
Frequently asked questions
How long does it take to become a senior React developer in India?▾
3-5 years of full-time React work to reach Senior level (₹25-50 LPA). Faster if you join a high-velocity product company and ship complex features. Slower at IT services where you maintain rather than build. Independent learning matters — read source code of popular libraries, contribute to open source.
Should I learn class components or hooks first?▾
Hooks only. Class components are legacy — new React code is 100% hooks. You'll occasionally encounter class components in older codebases, but you can learn them in 1-2 days when needed. Start with hooks from day one.
Redux vs Zustand vs React Query — which to learn?▾
Learn React Query first (mandatory in 2026 for any non-trivial app). Then Zustand for client state (lightweight, modern). Redux Toolkit only if your target company specifically uses Redux. Don't learn legacy Redux (with reducers, actions, types boilerplate) — it's outdated.
Is React still the best choice in 2026?▾
For Indian job market: yes, by a wide margin. ~70% of Indian frontend roles ask for React. Vue and Angular are minor. Newer frameworks (Solid, Qwik, Svelte) are interesting but have negligible India job market. Learn React unless you have a specific reason not to.
What's the difference between React and Next.js?▾
React is a library for building UI. Next.js is a full framework built on React, adding routing, server-side rendering, image optimization, and Server Components. In 2026, most new Indian React projects use Next.js as the default framework. Learn React first, then Next.js.
How do I prepare for React interviews at Indian product companies?▾
Three layers: (1) React fundamentals (hooks, rendering, state, performance), (2) JavaScript/TypeScript depth (closures, async, types), (3) System design at frontend level (component architecture, state management strategy, API design). Build 2-3 production-quality projects on GitHub — that's your trump card.
Are React certifications worth it?▾
No. Indian React employers don't care about certifications. They care about your GitHub portfolio, your code in interviews, and your ability to explain React concepts clearly. Don't waste money on Coursera certificates — invest that time in building projects.