Next.js DevIndicators and `appIsrStatus` in 2026: Reading Rendering Mode at a Glance During Development Next.js 16.0 removed the deprecated appIsrStatus option, completing a migration to the unified devIndicators configuration object introduced in 15.2. The on-screen badge now appears by default in development mode, showing whether the current route rendered statically or dynamically, with position control via devIndicators.position. Projects still referencing appIsrStatus in next.config.js will hit a build error directing them to migrate. This article was written with the assistance of AI, under human supervision and review. Engineers building Next.js applications in 2026 face a persistent problem: the framework decides whether a route renders statically or dynamically at build time, but nothing on the page tells you which path the compiler took. A developer adds cookies to fetch user preferences, refreshes the browser, sees the page load normally, and assumes everything works. The route silently switched from static prerendering to dynamic server rendering. Performance budgets slip. Time to first byte doubles. No one notices until production traffic patterns surface the latency. Next.js 15.0 introduced appIsrStatus , a configuration option that displayed a small badge in the development viewport showing whether the current route rendered statically or dynamically. Next.js 15.2 deprecated that option and replaced it with a unified devIndicators API that consolidates rendering mode visibility, build activity status, and position control into a single configuration object. Next.js 16.0 removed appIsrStatus entirely. The on-screen indicator now appears by default in every Next.js project running in development mode, positioned at the bottom-left corner of the viewport, displaying a colored badge that reads "Static" or "Dynamic" based on how the framework rendered the route you are viewing. This matters because the difference between static and dynamic rendering determines your application's performance ceiling. Static routes serve prerendered HTML from a CDN with single-digit millisecond response times. Dynamic routes execute server code on every request, adding 50-500ms depending on database queries, API calls, and compute regions. Teams that catch rendering mode regressions during local development prevent production incidents. Teams that ignore the indicator ship performance problems. appIsrStatus , buildActivity , and buildActivityPosition in favor of the unified devIndicators configuration object introduced in 15.2. next build --debug output if the opt-out happened after the build analysis phase. devIndicators: false hides the visual badge but does not suppress build errors or runtime warnings. The appIsrStatus option appeared in Next.js 15.0 https://nextjs.org/docs/app/api-reference/next-config-js/devIndicators appisrstatus-static-indicator as a boolean flag. Setting appIsrStatus: true in next.config.js enabled a fixed-position badge that displayed the rendering mode for the active route. Developers could see whether their page rendered statically or dynamically, but they could not control where the badge appeared on screen. Projects with custom toolbars, debugging overlays, or accessibility widgets often found the indicator overlapping critical UI elements. Next.js 15.2 introduced the position option as part of a broader devIndicators object. The same release deprecated appIsrStatus , buildActivity , and buildActivityPosition in favor of the unified structure. The new API https://nextjs.org/docs/canary/app/api-reference/next-config-js/devIndicators accepts four corner positions: bottom-left , bottom-right , top-left , and top-right . The default remains bottom-left for backward compatibility with existing visual layouts. Next.js 16.0 completed the transition by removing the deprecated options entirely. Any project still referencing appIsrStatus in its configuration file will encounter a build error instructing developers to migrate to devIndicators.position . The version history https://nextjs.org/docs/app/api-reference/config/next-config-js/devIndicators documents the migration path explicitly. The consolidation reflects a broader pattern in Next.js development: collapsing multiple single-purpose configuration flags into structured objects that group related settings. The same principle applies to the images configuration, which moved from top-level imageSizes and deviceSizes arrays to a nested images object containing formats , deviceSizes , and imageSizes together. For teams maintaining multiple Next.js versions, the migration path is straightforward. Projects on 15.0 or 15.1 can continue using appIsrStatus: true until they upgrade. Projects on 15.2 should migrate to devIndicators: { position: 'bottom-left' } to avoid deprecation warnings. Projects on 16.0 or later must use the new structure or the build will fail. The indicator itself displays as a small rectangular badge with rounded corners, positioned absolutely within the viewport. The badge shows white text on a colored background: green for static routes, amber for dynamic routes. The color choice maps to the same visual language the framework uses in its CLI output during next build , where a green circle symbol marks static routes and an amber function symbol marks dynamic routes. Next.js DevIndicator showing Static and Dynamic rendering modes in the browser viewport The indicator execution flow starts when the Next.js development server renders a route. The framework determines whether the route will render statically or dynamically, then injects a small React component into the page that displays the badge with the appropriate label and color. A route renders statically when it does not use request-time APIs and all data fetching operations cache their results. Static routes generate HTML at build time and serve the same content to every visitor. The framework can deploy these routes to a CDN with long cache durations because the content does not vary per request. A route renders dynamically when it calls request-time APIs like cookies , headers , or searchParams , or when it fetches data without caching the response. Dynamic routes execute server code on every request to generate fresh HTML. The framework cannot prerender these routes at build time because the output depends on information that only exists when a user visits the page. The indicator reads "Static" for routes that meet the static rendering criteria. This includes pages that fetch data using fetch with caching enabled, pages that read from server-only modules without accessing request context, and pages that render purely from imported data or hardcoded constants. The green background signals that the route will serve from a CDN in production with minimal latency. The indicator reads "Dynamic" for routes that opt out of static rendering. The amber background warns that the route will execute server code on every request, adding latency and increasing infrastructure costs. The warning does not mean the route is broken, but it does mean the performance profile has changed in a way that might violate your application's requirements. Developers can verify the indicator's accuracy by running next build --debug and comparing the terminal output to the badge displayed during development. The build output https://nextjs.org/docs/app/api-reference/config/next-config-js/devIndicators uses a circle symbol for static routes and a function symbol for dynamic routes. The symbols appear next to each route path in a table that lists the entire application's route tree. Route app ┌ ○ / not-found └ ƒ /products/ id ○ Static prerendered as static content ƒ Dynamic server-rendered on demand The debug output captures the framework's rendering decision at build time. The on-screen indicator reflects the same decision during development. Any mismatch between the two signals a problem in the developer's understanding of when routes opt out of static rendering. The devIndicators configuration accepts two forms: a boolean or an object. Setting devIndicators: false disables the indicator entirely. Setting devIndicators: { position: 'bottom-right' } enables the indicator and places it in the specified corner. python import type { NextConfig } from 'next'; const nextConfig: NextConfig = { devIndicators: { position: 'bottom-right', // 'bottom-left' | 'bottom-right' | 'top-left' | 'top-right' }, }; export default nextConfig; The position option accepts four string literals. Each positions the badge in a fixed corner of the viewport with a small margin from the edges. The default value bottom-left matches the position most Next.js developers encountered when the indicator first appeared in 15.0. Teams with debugging tools, accessibility overlays, or custom development UIs in that corner should switch to bottom-right or one of the top positions. Disabling the indicator requires setting devIndicators to false at the top level. This form takes precedence over the object form. A configuration that sets both devIndicators: false and devIndicators: { position: 'top-left' } will disable the indicator because the boolean form appears first in the TypeScript type hierarchy. js const nextConfig: NextConfig = { devIndicators: false, }; export default nextConfig; Disabling the indicator hides the visual badge but does not suppress build errors or runtime warnings. The framework continues logging rendering mode decisions to the terminal during development and displaying error overlays when a build fails. The indicator only controls the persistent on-screen badge that shows rendering mode for the current route. Teams disable the indicator in three scenarios. First, when the visual badge conflicts with other development tools. Browser extensions, React DevTools overlays, and accessibility scanners often occupy the bottom corners of the viewport. Adding another fixed-position element creates visual clutter and makes it harder to click interactive debugging controls. Second, when the indicator distracts during design reviews or stakeholder demos. Non-technical reviewers looking at a development build may ask questions about the badge that derail conversations about product features. Temporarily disabling the indicator for specific sessions keeps the focus on the work being reviewed. Third, when the team has automated their rendering mode verification through other means. Projects that run next build --debug in continuous integration and fail the build when unexpected routes render dynamically do not need the on-screen indicator to catch regressions. The CI pipeline surfaces the same information earlier in the development cycle. Most teams leave the indicator enabled. The visual feedback loop it provides catches mistakes faster than waiting for a build to complete. A developer adding a new route can see immediately whether their implementation stayed static or opted into dynamic rendering. That instant feedback prevents the common mistake of assuming a route renders statically when it actually executes server code on every request. The official documentation https://nextjs.org/docs/app/api-reference/config/next-config-js/devIndicators recommends keeping the indicator enabled unless visual conflicts force you to disable it. The performance implications of accidental dynamic rendering justify the small amount of screen space the badge occupies. The indicator reads the framework's rendering decision at development time, but several edge cases produce misleading results. The most common pitfall occurs when a route conditionally calls request-time APIs based on runtime logic the compiler cannot analyze statically. js // app/profile/page.tsx import { cookies } from 'next/headers'; export default async function ProfilePage { const isDevelopment = process.env.NODE ENV === 'development'; // Conditional request-time API usage const userCookie = isDevelopment ? undefined : await cookies .get 'user' ; return