Back to blog
November 8, 2026•24 views

Hiring a Next.js Developer? 12 Screening Questions That Reveal Real RSC and Streaming Experience

nextjshiring developersreact server componentsstreamingtechnical interviews
Hiring a Next.js Developer? 12 Screening Questions That Reveal Real RSC and Streaming Experience

I have sat on both sides of this table. I have interviewed Next.js developers for roles at AKIJ iBOS, and I have been the contractor founders call after a previous hire shipped an App Router project that fell apart under real traffic. The pattern is almost always the same: the developer could build a landing page, but could not explain why half the app was client-rendered when it should have been static.

That is the gap these screening questions for a Next.js developer usually miss. They hand you a list of React hooks questions and call it a technical interview. Hooks matter, but they do not tell you whether someone understands where rendering actually happens in the App Router era.

So here are 12 questions I actually use, grouped by difficulty, with model answers and the red flags I watch for. If you are hiring a Next.js developer remotely, this is the checklist I would want in my hands before a contract gets signed.

Why generic React interviews fail for Next.js hires

React and Next.js diverged hard when the App Router landed. A developer who is genuinely strong in React can still be lost in Next.js because the framework adds a whole layer of decisions React never made for you: where a component renders, what gets cached, when data is fetched, and how the page streams to the browser.

If your interview only asks "what is the virtual DOM" and "explain useEffect," you will hire someone who treats Next.js like React with extra files. That person ships client components everywhere, kills your SEO by accident, and cannot debug a stale cache. I have cleaned up three projects like that in the last two years.

The questions below are ordered so you can run a short phone screen (questions 1 to 5) and then a deeper technical round (6 to 12). Each one has a model answer and what a weak response sounds like. A scoring rubric for each tier follows the questions.

The 12 screening questions

Tier 1: Phone screen (foundation check)

These should take 20 to 30 minutes total. You are not looking for perfect answers, you are looking for whether the person thinks in Next.js terms.

1. What is the difference between a Server Component and a Client Component, and when do you reach for "use client"?

Model answer: Server Components render on the server, ship zero JavaScript to the browser, and can read the database or secrets directly. Client Components run in the browser and are needed for interactivity, hooks, and browser-only APIs. A strong candidate will add that "use client" marks a boundary, and everything imported below it becomes part of the client bundle. (See the React Server Components docs and the Next.js Server and Client Components guide.)

Red flag: "Client components are for the frontend, server components are for the backend" with no mention of the bundle or the boundary. That is a memorized line, not understanding.

2. Where does data fetching happen in the App Router, and what changed from getServerSideProps?

Model answer: In the App Router you fetch directly inside async Server Components, so there is no getServerSideProps or getStaticProps. You await the data in the component, and Next.js decides static or dynamic rendering based on what you use. The old Pages Router functions still exist if you are on the Pages Router, but they are not the App Router model. (See the Next.js data fetching docs.)

Red flag: Confusing the two routers, or insisting getServerSideProps is how you do it "in Next.js" without qualifying which router.

3. Explain fetch caching in Next.js. What does cache: 'no-store' do versus next: { revalidate: 60 }?

Model answer: no-store opts the fetch out of the data cache so every request hits the source, which forces dynamic rendering, while revalidate: 60 keeps the cached response and revalidates it at most every 60 seconds. A strong answer mentions that Next.js extends the native fetch with these options, and that the default caching behavior has shifted between versions, so you should verify against the current docs rather than assume. (See the Next.js caching docs.)

Red flag: "I just use no-store everywhere to be safe." That is a developer who has not thought about performance or cost.

4. How does streaming work in Next.js, and what does loading.js actually do?

Model answer: Streaming sends HTML to the browser in chunks as it becomes ready, so slow data does not block the whole page. loading.js wraps a route segment in a Suspense boundary automatically, showing a fallback while the segment loads, and you can also wrap individual components in <Suspense> manually for finer control. (See the Next.js loading UI and streaming docs.)

Red flag: No mention of Suspense, or thinking loading.js is just a spinner component you import.

5. What are route handlers, and when would you use one instead of a Server Action?

Model answer: Route handlers are route.js files that export HTTP methods for building API endpoints, while Server Actions are functions marked "use server" that you call from components for mutations. Use route handlers when you need a real HTTP API (webhooks, third-party consumers, public endpoints) and Server Actions for form submissions and mutations inside the app. (See the route handlers docs and the Server Actions docs.)

Red flag: Cannot articulate why you would pick one over the other. That usually means they have only used one and copied the pattern.

Tier 2: Technical round (depth and judgment)

By this point you know if they can talk the talk. Now you want to see judgment under realistic constraints.

6. A page is fully client-rendered and your SEO is tanking. Walk me through how you would diagnose and fix it.

Model answer: Check whether "use client" has been pushed too high in the tree, so entire subtrees became client components, and look for data fetching inside useEffect instead of async Server Components. Fix by moving "use client" down to the leaf interactive components and fetching data on the server, then verify with the build output which routes are static versus dynamic.

Red flag: "I would add next-seo and meta tags." Meta tags do not fix a client-rendered body.

7. How do you handle a slow third-party API without blocking the whole page render?

Model answer: Wrap the slow part in <Suspense> so the rest of the page streams immediately, or move the fetch into a component that suspends independently. Consider caching the response with revalidate, fetching it in a route handler and caching server-side, or loading non-critical data after the fold.

Red flag: "I would just await it." That is a developer who has not felt a 4-second TTFB in production.

8. Explain the difference between static rendering, dynamic rendering, and ISR in the App Router, and how you control which one a route uses.

Model answer: Static rendering happens at build time, dynamic on every request, and ISR statically with periodic revalidation. You control it through dynamic APIs, fetch cache options, revalidate exports, and dynamic route segment config, and a strong candidate knows that using cookies() or headers() opts a route into dynamic rendering automatically. (See the Next.js rendering docs.)

Red flag: Cannot name the mechanisms that flip a route to dynamic. This is the single most common production bug I see in App Router projects. For a deeper walkthrough of how these caching layers actually behave, see Next.js 15 caching demystified.

9. What is the use client boundary doing to your bundle, and how would you audit it?

Model answer: Everything imported into a client component becomes part of the client bundle unless it is passed as a children prop from a Server Component. You audit with the Next.js bundle analyzer (@next/bundle-analyzer), and by checking that large dependencies (chart libraries, rich text editors, date libraries) are only imported where they are actually used.

Red flag: No awareness that a client boundary pulls in its whole import graph. This is how 200KB of unnecessary JavaScript ends up on a marketing page.

10. How do you secure a Server Action?

Model answer: Treat it as a public endpoint: validate and authorize inside the action itself, never trusting the client to have already checked permissions. Server Actions can be invoked directly, so authentication and authorization checks go at the top of the function, not only in the UI that renders the form. (See the Next.js Server Actions security docs.)

Red flag: "It is server-side so it is safe." Server Actions are callable endpoints. This question separates people who have shipped real apps from people who have only followed tutorials. If you are building an MCP or API layer alongside the app, the same "trust nothing from the client" rule applies, see how to build a production MCP server in Next.js.

11. How would you structure a Next.js app that has a marketing site, an authenticated dashboard, and an API for a mobile app?

Model answer: Route groups for the marketing site and dashboard so each can have its own layout and auth boundary, with middleware or layout-level checks for the dashboard. Route handlers under /api for the mobile app's endpoints, or a separate service if the API has different scaling or versioning needs, plus shared types and validation in a common package.

Red flag: "One big app folder, it is fine." It is fine until the dashboard's client code leaks into the marketing bundle or the mobile API starts breaking when you refactor a page. For multi-tenant setups, middleware for subdomain routing and auth is a good follow-up probe.

12. Tell me about a Next.js performance problem you actually fixed. What was the cause?

Model answer: There is no single right answer here, which is the point. A strong candidate names a specific cause (over-broad client boundary, N+1 fetches in a Server Component, missing Suspense on a slow call, unoptimized images, a dynamic route that should have been static) and describes how they measured it and what changed.

Red flag: Vague stories with no numbers and no cause. "I optimized it and it got faster" tells you nothing.

Model answers and red flags at a glance

Here is the same set compressed into a scoring sheet you can keep open during the call.

# Question Strong signal Red flag Tier
1 Server vs Client Components Explains bundle and boundary Memorized "frontend/backend" line Phone
2 Data fetching changes Async Server Components, no getServerSideProps Confuses routers Phone
3 fetch caching Knows no-store vs revalidate Uses no-store everywhere Phone
4 Streaming Names Suspense, loading.js Thinks loading.js is a spinner import Phone
5 Route handlers vs Server Actions Picks based on use case Cannot differentiate Phone
6 Client-rendered SEO fix Diagnoses boundary and useEffect fetches Reaches for meta tags Technical
7 Slow third-party API Suspense, caching, deferral Just awaits it Technical
8 Static/dynamic/ISR Names dynamic APIs and config Cannot explain what flips to dynamic Technical
9 Client bundle audit Knows import graph, uses analyzer Unaware of bundle impact Technical
10 Server Action security Treats it as a public endpoint "It is server-side so it is safe" Technical
11 App structure Route groups, separate auth and API One flat folder Technical
12 Real perf story Specific cause and measurement Vague, no numbers Technical

Scoring rubric and pass/fail thresholds

Use a simple 0-2 scale per question: 0 means a red flag or no real answer, 1 means a partially correct answer that misses the "why," and 2 means a clear answer with the mechanism and trade-offs named. Score each tier separately, since the two rounds test different things.

  • Phone screen (questions 1-5, max 10 points): pass at 6 or above with no more than one zero. A candidate who scores 6 but zeros out on the server/client boundary is a no, that gap is foundational, not cosmetic.
  • Technical round (questions 6-12, max 14 points): pass at 9 or above. Weight questions 8, 9, and 10 double if the role is senior or lead, because caching, bundle control, and action security are where production incidents cluster.
  • Combined decision: a candidate who passes both tiers moves to a paid trial or take-home. A candidate who passes the phone screen but fails the technical round is a reasonable junior or mid-level hire for a Pages Router codebase, but not for an App Router rebuild.

How to run the screen without wasting anyone's time

A few things I have learned from running these screens across time zones.

  • Keep the phone screen to 20 minutes and five questions. You are filtering, not evaluating.
  • Ask for a short take-home only if the role is senior. A 2-hour take-home in the App Router, where they build a page with one streamed section and one cached fetch, tells you more than an hour of trivia.
  • Do not punish version differences. The App Router has changed caching defaults between releases (for example, Next.js 15 changed the default for fetch requests and route handlers to no longer cache by default). Ask "how would you check the current behavior" and reward the person who says "read the docs and check the build output" over the one who confidently recites a stale default. (See the Next.js 15 release notes.)
  • Give the candidate a code snippet with a bug and ask them to spot it. A "use client" at the top of a layout is a great one. See if they notice the whole tree just became client-rendered.
  • For remote hires, ask how they would hand off a project. Documentation habits matter as much as code quality when you are not in the same room.

If you want a broader hiring framework beyond Next.js, my guide on how to hire a Next.js developer covers contracts, trial periods, and scope. This article is the technical filter that sits inside that process.

What this screening actually protects you from

The expensive mistakes in Next.js hiring are rarely about syntax. They are about architectural judgment. A developer who does not understand the server/client boundary will build you an app that looks fine in development and then bleeds JavaScript, ranks poorly, and costs more to host. A developer who does not understand caching will ship stale data and blame the framework.

These 12 questions are not a perfect filter. Nothing is. But they surface the difference between someone who has used Next.js and someone who has run it in production, and that difference is usually what you are paying for.

About the author and how to get help

If you are building a Next.js product or an automation layer around one and would rather not run this screen yourself, I do this for a living. I lead Web Engineering and AI Automation at AKIJ iBOS, and I have delivered a large portfolio of sites and apps for clients across several countries, you can see the work on my portfolio through the contact page. If you want a second opinion on the developer you already have, or a straight answer on whether you need a full-time hire or a contractor, reach out through the contact page and tell me what you are building. I will tell you honestly which one it is.

Frequently asked questions

Can a strong React developer with no Next.js experience pass this screen after a weekend of study?

Usually not past the phone tier. React fluency gets them through the hooks-adjacent parts, but questions 3, 4, and 8 depend on having watched caching and streaming behave in a real deployment. If you want to take a chance on a fast learner, hire them for a scoped, paid trial on a non-critical route rather than a full rebuild.

My team already has a senior React lead. Do we still need to ask all 12?

Probably not. The lead can absorb questions 1-5 by reviewing pull requests, so spend your interview time on 8, 9, and 10, the three areas where a wrong call is expensive to reverse. The rubric still applies, just with the phone tier marked as assumed.

How do these questions change for a contract or agency hire versus a full-time employee?

Contractors are judged more on question 11 and the handoff discussion, because you are buying a finished, documented deliverable rather than long-term ownership. Full-time hires should be pushed harder on question 12, since you want evidence they will keep improving the codebase after launch.

What should I do if two candidates score within a point of each other?

Break the tie with the take-home, not another interview. Give both the same App Router task with one streamed section and one cached fetch, then compare how each one explains their trade-offs in writing. The clearer write-up is usually the better long-term hire, especially for remote teams. </||DSML|| parameter> </||DSML|| invoke> </||DSML|| calls>

Share this post

Native Web Share is available on mobile, so that share sheet includes Instagram and any other app you have installed.

Let's Connect

Get In Touch

Let's build something premium together.

Contact info

Follow me
Chat on WhatsApp