React Certification
One paper across the whole course: JSX, components and props through state and effects, composition with context and custom hooks, the performance model behind re-renders, and the real-world craft — error boundaries, portals, forwardRef, Suspense — that separates a demo from a shipped component. Sat in one sitting a little over two hours.
- Sitting
- 140 minutes
- Questions
- 60
- Pass mark
- 70%
- Price
- ₹199$9.99
Sit this when you can do these without looking them up
This is not a certificate of attendance. It is 60 questions in 140 minutes at 70% with no partial credit and one attempt, and roughly a third of the paper is foundations — the certificate is for the whole language, not the parts you enjoyed.
- Explain why a component re-renders when its parent does, even with unchanged props, and what React.memo actually opts out of
- Say why
key={index}breaks on a dynamic list, and what a stable key fixes that it doesn't - Spot a stale closure — an effect or interval reading an old value — and fix it with either a functional update or a corrected dependency array
- Explain what a dependency array compares, and why an inline object/array/function prop can defeat useMemo, useCallback, or React.memo
- Choose between lifting state up, composition, and context for a piece of shared state, and justify why context isn't always the fix
- Say what an error boundary catches that a try/catch in an event handler doesn't, and why the reverse is also true
- Explain what forwardRef and useImperativeHandle are for, and what changed about passing ref in React 19
If you'd rather find out than guess, the free 5-question readiness check reports a predicted band in two minutes. If several readiness points are unfamiliar, the free course covers everything on the syllabus.
Syllabus
Every paper is drawn to this mix, so the weights are a promise rather than a guide. The bars show each area's share of the 60 questions.
What React is and JSX
4 Q·7%Declarative vs imperative UI, what a React element actually is, JSX compiling to function calls, expressions vs statements inside JSX, and fragments.
Components, props and composition
4 Q·7%Components as functions, props as read-only inputs, defaults and renaming, children, and composing components instead of over-configuring one.
Rendering lists and conditionals
3 Q·5%map() over a for loop, why every list item needs a key, when index is (and isn't) an acceptable key, ternaries, &&, and the stray-zero gotcha.
Events and the virtual DOM
3 Q·5%Attaching handlers, passing arguments, SyntheticEvent, React 17's event-delegation change, and the render/commit/paint pipeline conceptually.
useState and state updates
4 Q·7%State vs a plain variable, why updates aren't synchronous, the functional-update form, automatic batching, and replacing rather than mutating state.
Forms: controlled vs uncontrolled
3 Q·5%The controlled-input pattern, value without onChange, handling many fields with one handler, and why file inputs are uncontrolled by necessity.
Lifting state up and data flow
2 Q·3%Sharing state between siblings via their nearest common ancestor, callback props, and the prop-drilling cost that motivates context later.
useEffect and the dependency array
4 Q·7%What an effect is for, when it runs relative to render/commit, the three forms of the dependency array, and stale closures from a missing dependency.
Cleanup and data fetching in effects
3 Q·5%Returning a cleanup function, when it runs, the hand-rolled loading/error/data pattern, race-condition guards, and why libraries often replace it.
useRef for DOM and mutable values
3 Q·5%Refs vs state, reaching a real DOM node, storing mutable values that shouldn't trigger a re-render, and why refs shouldn't be read during render.
Context and useContext
3 Q·5%createContext, Provider and useContext, what context is genuinely good for, and the re-render-every-consumer cost that limits it.
useReducer for complex state
3 Q·5%Dispatch and actions, why a reducer must be pure, and when useReducer earns its complexity over several separate useState calls.
Custom hooks and prop drilling
3 Q·5%Extracting reusable stateful logic into a use-prefixed function, the rules of hooks and why they exist, and composition as an alternative to context.
Re-renders, memo, useMemo and useCallback
5 Q·8%The four re-render triggers, React.memo's shallow comparison, useMemo and useCallback, and why premature memoization has a real cost.
List reconciliation pitfalls and stale closures
5 Q·8%The exact failure mode of index-based keys on a dynamic list, and the general shape of a stale closure beyond just useEffect's dependency array.
Error boundaries and portals
4 Q·7%Why error boundaries still require a class, what they do and don't catch, createPortal, and what does (and doesn't) still follow the React tree.
forwardRef, Suspense and testing
4 Q·7%forwardRef and useImperativeHandle, React 19's ref-as-a-prop, Suspense conceptually and its Suspense-aware-source requirement, and testing behavior over implementation.
Three questions from the bank
Representative of the mix and difficulty — answer visible, shown here to calibrate expectations rather than test you.
- Sample 1What React is and JSX
What does it mean for React to be 'declarative' rather than 'imperative'?
- You describe what the UI should look like for the current data, and React works out how to update the DOM
- You write step-by-step DOM instructions and React executes them faster than the browser would
- Declarative code cannot use JavaScript expressions
- It means the app has no CSS
Why: Imperative code says how to mutate the DOM, one step at a time. Declarative code just describes the desired result for the current state, and React figures out what changed.
- Sample 2Components, props and composition
What are props, in one sentence?
- Mutable global variables shared by every component
- A component's own internal, changeable data
- The read-only inputs a component receives from whoever renders it, similar to function parameters
- CSS properties applied through JavaScript
Why: Props are simply the arguments to the component function — supplied by the parent, and never something the receiving component should reassign.
- Sample 3Rendering lists and conditionals
What is the standard way to render an array of data as a list of JSX elements?
- array.map(), producing a new array of elements that React can render directly
- A for loop written directly inside the JSX braces
- A built-in <For> tag
- array.forEach(), since it returns the rendered output
Why: JSX only accepts expressions inside {}; .map() is an expression producing an array, which React renders. forEach returns undefined, so it can't be used the same way.
What this does NOT replace
An honest comparison, because overclaiming cert value helps nobody and gets caught by anyone who hires.
- This is not an AWS / Google / Microsoft vendor certification — those cover a proprietary platform, carry employer discounts, and some recruiters filter resumes against them. If a role explicitly names those, this doesn't substitute.
- This is not a replacement for a degree, a bootcamp with job placement, or shipping real work. Those produce different evidence. A certificate is a focused signal, not a career.
- This is a focused, honest signal that you can hold the full syllabus in your head under a clock. Pair it with a résumé that shows what you've built — that's the combination that lands interviews.
Everything on this syllabus is taught free
The React course covers the whole syllabus above across 35 lessons, with a playground in each one. Work through it first — the exam is the same material under a clock.
Open the React courseWhat sitting it is like
The exam opens full screen with a countdown, a question at a time, and a grid showing what you have answered and what you have flagged to come back to. Nothing is submitted until you say so, or the clock reaches zero.
Every answer saves to the server as you give it. If your laptop dies at question forty, sign back in and you will find question forty exactly as you left it — with however much time was left still ticking, because the clock does not pause.
Leaving full screen or switching tabs is noted but does not end your exam. It is a record, not a trap: nobody is auto-failed for a notification stealing focus.
When it ends you get your mark, a topic-by-topic breakdown, and every question with the right answer and an explanation — whether you passed or not. Passing also produces a certificate with a link anyone can verify.