React is the most commonly listed framework on developer resumes and one of the most commonly tested in interviews. But the gap between developers who list "React" and developers who actually understand React at a senior level is enormous.
What separates them? Not whether they know the syntax. Anyone who's done a tutorial knows the syntax. The difference is understanding *why* React behaves the way it does — the rendering model, the rules of hooks, when to optimise and when not to, how to think about state vs derived state, what actually causes performance problems.
These are the questions interviewers ask. And these are the questions the Skeelzy React quiz tests.
The concepts that separate junior from senior React developers
Before getting to the questions, here's what senior React knowledge actually looks like:
Understanding the rendering model. React re-renders a component when state changes, when props change, or when a parent re-renders. Most developers know the first two. Many don't think carefully about the third — which is why they end up with unnecessary re-renders that hurt performance.
Understanding hooks correctly. The rules of hooks aren't arbitrary restrictions — they exist because hooks are implemented as a linked list tied to render order. If you understand that, you'll never write a conditional hook and you'll understand why hooks must be called at the top level.
Knowing when to optimise and when not to. React.memo, useMemo, useCallback — these are tools for specific situations, not defaults to reach for. Premature optimisation with these tools can actually make things worse by adding reference comparison overhead. Knowing when the trade-off is worth it requires understanding the virtual DOM diffing algorithm.
Understanding useEffect and its dependency array. This is where most bugs live. Missing dependencies cause stale closures. Unnecessary dependencies cause infinite loops. The cleanup function exists for a reason — omitting it causes memory leaks and subtle bugs with timers and subscriptions.
10 questions that test real React knowledge
These are representative of the questions in the Skeelzy React quiz. Work through them before checking the explanations — honest self-assessment is the fastest path to improving.
1. A parent component re-renders. Under what conditions does a child component re-render? (Hint: it's not just when props change.)
2. What happens if you call a hook inside a conditional? Why does React enforce this restriction?
3. You have a component that renders a list of 1000 items and is noticeably slow. What's the first thing you investigate before reaching for useMemo or React.memo?
4. What's the difference between useCallback and useMemo? When would you use each?
5. You have a useEffect with an empty dependency array that runs an async function. The async function updates state. What potential bug exists and how do you fix it?
6. What's the difference between controlled and uncontrolled components? When is an uncontrolled component appropriate?
7. React.memo wraps your component. A parent re-renders and passes a new object literal {} as a prop. Does the child re-render? Why?
8. What is a render cycle? What can cause an infinite render loop?
9. You're using useContext to subscribe to a context value. When does this component re-render?
10. What is the purpose of "key" in a list? What happens if you use array index as the key?
Why these questions matter for interviews
These questions come up in React interviews because they test the mental model, not just the API. A developer who's memorised the docs can answer "what does useState do?" A developer who truly understands React can answer why useEffect runs twice in development with StrictMode, or why an effect with no dependencies still has access to the component's state via closure.
Senior React interviews often look like this: the interviewer gives you a component with a bug — usually a performance issue, an infinite loop, or a stale closure — and asks you to find and fix it. The fix is usually one line. But finding it requires the exact conceptual understanding that surface-level React tutorials skip.
The developers who ace these interviews aren't the ones who've memorised the most. They're the ones who've built enough mental model to reason through novel situations. Quiz-based practice is one of the fastest ways to build that model — each question that trips you up reveals a gap you can go fix.
What your React quiz score means
The Skeelzy React quiz adapts to your performance — questions get harder as you score higher. A 90%+ accuracy score means you're operating at senior React level: the kind of understanding that passes technical screens. A 60-75% score means you know React well enough to build with it but have gaps in the deeper concepts that interviewers probe.
Your score isn't just for your own feedback. When you add a verified React score to your Skeelzy resume, it tells recruiters and hiring managers exactly how your knowledge compares to the benchmark — no guessing, no inflated self-assessment, no interview roulette on whether your claimed "Advanced" means the same thing as their expectation of "Advanced."
The best time to take the quiz is before you start your job search, so you know what to brush up on. The second best time is right now.