Hiring Senior React/Next.js Engineers: Questions and Tasks

Senior hires do more than ship tickets; they shape systems, reduce risk, and unblock teams. Use this guide to run signal-heavy interviews with specific questions and pragmatic take-home tasks. It also helps compare candidates from nearshore software development companies and in-house pipelines, and to evaluate full-stack engineers who collaborate across GraphQL API development, edge delivery, and design systems.

Core screening questions (30-40 minutes)

• When do you choose Server versus Client Components in Next.js 14, and why?
• Outline a feature in a Turborepo monorepo using shared UI and typed contracts.
• Hydrate a page mixing SSR, ISR, and client state; where are caching boundaries?
• Prevent network waterfalls in nested layouts and route groups; give a concrete pattern.
• Replace context with selectors or memoization to remove wasted renders; what changed?
• Secure env vars, edge runtime secrets, and SDKs across environments.

Architecture and performance deep-dive

Have them map a checkout on Next.js with edge rendering, feature flags, and a CDN. Probe for architecture, not trivia.

• Model cache layers: HTTP, React cache, CDN, database. Who owns invalidation?
• Stream critical HTML and progressively hydrate complex widgets without blocking input.
• Choose an optimization: split, prefetch, or move logic to Server Actions; defend with metrics.
• Discuss failure modes: slow GraphQL resolvers or stale flags; how does UI degrade?
• Propose observability: client traces, server spans, and synthetic checks tied to SLOs.

GraphQL API development and full-stack alignment

Great seniors span the network boundary. Evaluate how they shape schemas, avoid waste, and keep the UI resilient.

• Design a product detail query: which fields live in GraphQL versus computed in the client?
• Show a fragment strategy that avoids over-fetching across web and mobile while keeping type safety.
• Explain N+1 pitfalls and how you’d use dataloaders, persisted queries, or field caching.
• Discuss error shaping: nullability, partial results, and UI states that maintain momentum.

High-signal take-home tasks (6-8 hours)

Keep scope sharp and outcomes measurable. Provide a stub GraphQL service and seed data.

• Build a product list and detail in Next.js with Server Components and route-based splitting.
• Integrate GraphQL queries and mutations; implement optimistic add-to-cart and persist state across reloads.
• Instrument Core Web Vitals; add a “time-to-add-to-cart” metric and report results.
• Secure env vars, configure a preview deployment, and add feature flags toggling cart behavior.

Score on correctness, performance, DX, code clarity, risk management, and written communication.

Working with nearshore teams

If you partner with nearshore software development companies, validate async fluency and cross-time-zone ownership.

• Request a written design doc; assess clarity, trade-offs, and decision logs.
• Simulate a handoff using GitHub issues and Slack updates; measure leverage creation.
• Probe feedback style, code review empathy, and rigor around tests and docs.

Red flags and power signals

• Red flag: treats Next.js as a black box; cannot reason about caching or hydration.
• Red flag: optimizes micro-interactions while ignoring Core Web Vitals or conversion.
• Signal: owns end-to-end work, from GraphQL schema tweaks to rollout and observability.
• Signal: mentors peers, designs with constraints, and communicates trade-offs succinctly.

Process and next steps

Compress hiring to two weeks: structured screen, deep-dive panel, take-home, and a paid trial for finalists.

• Create a scorecard tied to outcomes: faster lead time, lower cost per conversion, fewer incidents.
• Source networks that pre-vet full-stack engineers with Next.js depth and GraphQL competence.
• When speed matters, partner with specialists like slashdev.io for senior React and platform talent.
• Run a lightweight paid pilot that delivers a thin-slice feature across UI and GraphQL.

The result is a hire who codes, architects, and communicates-raising quality, speed, and conversion.

Live scenario prompts

Swap whiteboards for realistic constraints. Present concrete changes and ask the candidate to reason, sketch, and trade off in five-minute increments.

• Your feature flag service is down. How do you degrade UI safely without redeploying?
• A GraphQL resolver adds 200ms p95. What shifts client, schema, or caching-side reduce latency?
• Marketing needs A/B on product cards. Where do you place experiments to protect Core Web Vitals?
• Compliance requires masking PII in logs. Demonstrate an approach across client, API, and observability.
• Traffic spikes 5x from a campaign. What breaks first, and what do you throttle or cache?

Leveling signals to justify senior compensation

Senior engineers compress uncertainty. Look for candidates who define interfaces before code, expose unknowns early, and prefer incremental rollouts over big reveals. They communicate with product and marketing using shared metrics, not jargon. They turn vague goals into measurable hypotheses, and they leave behind dashboards, runbooks, and patterns others reuse. That leverage, not syntax trivia, earns senior rates. Hire for impact.