React Query Quiz ( Advanced ) - All Questions

This hard-level React Query quiz targets senior developers working with complex data-fetching scenarios, performance tuning, cache synchronization, and concurrency. It focuses on real-world edge cases, architectural decisions, and interview-level React Query knowledge.

Question 1: What is the core architectural goal of React Query?

Replace Redux completely
Manage server state separately from UI state
Cache all application data permanently
Eliminate async code

Explanation: React Query is designed specifically for managing server state.

Question 2: Why can overly aggressive cacheTime values cause memory issues?

Too many retries occur
Unused queries remain in memory longer
More components re-render
Network requests increase

Explanation: Long cacheTime keeps inactive queries in memory.

Question 3: Which scenario benefits most from useInfiniteQuery?

Form submissions
Cursor-based pagination
Single resource fetch
Optimistic updates

Explanation: useInfiniteQuery is ideal for paginated or infinite scrolling data.

Question 4: Why can invalidating too many queries degrade performance?

Cache corruption
Excessive refetching
Lost optimistic updates
Disabled retries

Explanation: Over-invalidation triggers unnecessary network requests.

Question 5: What problem does query deduplication solve?

Multiple components fetching the same data simultaneously
Retry failures
Cache eviction
Mutation rollbacks

Explanation: React Query avoids duplicate requests for identical queries.

Question 6: Why should query keys include all query parameters?

To improve retries
To avoid cache collisions
To enable Suspense
To reduce memory

Explanation: Missing parameters can cause incorrect cache reuse.

Question 7: What is a major risk of optimistic updates?

Slower UI
Complex rollback handling
Extra re-renders
Disabled caching

Explanation: Optimistic updates require careful rollback on failure.

Question 8: Which option ensures queries remain responsive during rapid updates?

staleTime
structuralSharing
keepPreviousData
retry

Explanation: keepPreviousData prevents UI flicker during transitions.

Question 9: Why should select functions in useQuery be pure?

To avoid side effects and recomputation bugs
To reduce bundle size
To enable retries
To improve caching speed

Explanation: Pure select functions ensure predictable transformations.

Question 10: What does structuralSharing optimize?

Retry logic
Reference stability between query results
Mutation speed
Cache eviction

Explanation: Structural sharing minimizes reference changes to reduce re-renders.

Question 11: Why can excessive background refetching harm UX?

Memory leaks
Network congestion and UI churn
Cache deletion
Mutation failures

Explanation: Too many refetches can overload the network and UI.

Question 12: Which feature enables React Query to work well with Suspense?

Error boundaries
Throwing promises during loading
Retry logic
Mutation batching

Explanation: Suspense relies on thrown promises for loading states.

Question 13: What is the primary downside of setting staleTime to Infinity?

Queries never refetch automatically
Cache is deleted immediately
Retries stop working
Pagination breaks

Explanation: Infinite staleTime prevents automatic refetching.

Question 14: Why should mutations usually invalidate related queries?

To clear memory
To keep cache consistent with server state
To retry mutations
To enable polling

Explanation: Invalidation ensures UI reflects latest server data.

Question 15: Which scenario requires manual cache updates instead of invalidation?

Simple GET requests
High-frequency optimistic updates
Static data fetching
Prefetching routes

Explanation: Manual updates avoid excessive refetching in frequent changes.

Question 16: What happens if multiple QueryClient instances are used incorrectly?

Automatic cache merge
Isolated caches and inconsistent state
Improved performance
Shared retries

Explanation: Separate clients create isolated caches.

Question 17: Why is React Query considered concurrency-safe?

It blocks renders
It manages overlapping fetches predictably
It avoids async code
It disables retries

Explanation: React Query handles overlapping requests safely.

Question 18: What is the main performance benefit of prefetchQuery?

Reduced bundle size
Faster perceived navigation
Automatic retries
Smaller cache

Explanation: Prefetching loads data before the user needs it.

Question 19: Why should retry logic be customized in production apps?

To reduce code
To avoid overwhelming failing services
To disable caching
To simplify queries

Explanation: Uncontrolled retries can overload servers.

Question 20: Which feature helps manage dependent queries safely?

Multiple clients
enabled flag
invalidateQueries
refetchInterval

Explanation: enabled allows sequencing queries based on conditions.

Question 21: Why can returning new objects from queryFn be problematic?

It breaks hooks
It causes unnecessary re-renders
It disables retries
It clears cache

Explanation: New references trigger re-renders even if data is unchanged.

Question 22: What does onSettled guarantee in mutations?

Runs only on success
Runs after success or error
Runs before mutation
Runs only on error

Explanation: onSettled always executes after mutation completion.

Question 23: Why should large query results often be normalized?

To improve styling
To simplify updates and caching
To reduce retries
To enable Suspense

Explanation: Normalization avoids duplication and complex updates.

Question 24: Which option best limits unnecessary polling?

retry
enabled
refetchInterval
cacheTime

Explanation: enabled can conditionally disable polling.

Question 25: What is a common anti-pattern with invalidateQueries?

Targeted invalidation
Invalidating everything globally
Using exact query keys
Scoping invalidation

Explanation: Global invalidation causes excessive refetching.

Question 26: Why is React Query well-suited for micro-frontend architectures?

Shared global store
Independent cache per application
Centralized routing
Mandatory Redux usage

Explanation: Each micro-frontend can manage its own server state.

Question 27: What risk exists when mutations update cache incorrectly?

Slower fetches
UI-server data inconsistency
Retry loops
Disabled Suspense

Explanation: Incorrect cache updates desync UI from server.

Question 28: Which feature helps avoid loading spinners during pagination?

staleTime
keepPreviousData
retryDelay
structuralSharing

Explanation: keepPreviousData preserves prior results.

Question 29: Why should QueryClient configuration be centralized?

To reduce bundle size
To enforce consistent caching behavior
To enable Suspense
To disable retries

Explanation: Central configuration ensures predictable behavior.

Question 30: What is the main trade-off of optimistic updates?

Slower performance
Complex error recovery logic
More network calls
Reduced caching

Explanation: Optimistic updates require rollback handling.

Question 31: Why is React Query not ideal for managing local UI state?

Performance reasons
It is designed for server state only
Hooks break
Cache grows too fast

Explanation: Local UI state belongs in React state.

Question 32: Which feature best reduces redundant network requests?

Query deduplication
Retry logic
Polling
Manual refetch

Explanation: Deduplication prevents duplicate requests.

Question 33: Why should error handling logic be centralized?

Cleaner UI only
Consistent UX and recovery strategies
Faster retries
Smaller cache

Explanation: Central handling ensures predictable user experience.

Question 34: What is the biggest architectural benefit of React Query?

Automatic reducers
Clear separation of server and client state
Elimination of APIs
Built-in routing

Explanation: React Query cleanly separates server-state concerns.

Back to programming Quizzes

React Query Quiz ( Advanced )

Questions

Minutes

Min Limit