Static Where Possible
Content that does not change per request should be built once and served as files.
Next.js exists mainly to answer one question well: how should this particular page be rendered? Static at build time, on the server per request, or in the browser. Next.js development is largely the discipline of answering that per route rather than letting the whole application inherit one mode — because marketing pages and application pages want opposite things.
The framework offers the choice. Most projects make it once and apply it everywhere.
Content that does not change per request should be built once and served as files.
Per-user or genuinely live content rendered on the server, with caching considered.
Metadata, canonicals and structured data per route rather than set by script.
How stale is acceptable is a business question, answered before it is configured.
Server rendering needs somewhere to run. That is planned rather than discovered.
Four things, and getting them right is most of what a Next.js project is.
Discuss Your Build →Static, server-rendered or client-rendered — chosen page by page.
Where data is loaded and what is cached, which decides both speed and freshness.
File-based routing that produces real URLs, which is why it suits content sites.
Per-route titles, descriptions and structured data emitted in the HTML.
Route-level decisions, then the build, then the deployment those decisions imply.
Rendering problems on an existing build are diagnosed in JavaScript SEO.
The route map comes first. Everything else follows from it.
What exists, what changes, how often, and per whom.
A mode per route, with the freshness requirement stated.
Components, data layer and metadata together rather than metadata last.
Rendered HTML checked per route type, not assumed from the framework.
Hosting matched to the rendering, with field performance watched.
Static rendering trades freshness for speed and simplicity. The right trade is a business decision, not a technical default.
Pages are built statically but rebuilt in the background after a defined interval, so visitors get a static file while the content stays reasonably current.
It suits content that changes but not per request — a blog, a product catalogue, a directory. The question it forces is how stale is acceptable: a minute, an hour, a day.
That is a business answer. A pricing page that must never be wrong and a blog index that can lag an hour have different requirements, and the configuration should follow from that rather than from a default.
When the page genuinely differs per request — logged-in state, personalised content, live inventory that must be exact at the moment of viewing.
It is frequently chosen when it is not needed, which adds a server to operate, cache invalidation to reason about, and a slower response than a static file would give.
The test is whether two visitors at the same moment would see different HTML. If not, the page can almost certainly be static.







Next.js development builds React applications where the rendering mode is chosen per route — static, server-rendered or client-rendered — along with routing, data fetching and metadata handled by the framework.
It makes doing the right thing easier rather than automatic. Static and server rendering produce indexable HTML; the framework offers both per route. A Next.js app that client-renders everything has the same problem plain React would.
Only for the routes that render per request. An entirely static Next.js site deploys as files. Mixing modes means the deployment needs to support the dynamic ones, which is worth deciding before the build rather than at launch.
Either by rebuilding, or with incremental regeneration where pages refresh in the background after a defined interval. The right choice depends on how stale the content may be, which is a business decision.
Yes, and the URLs are the thing to protect. A framework change that alters paths without redirects loses whatever those URLs earned — see website migration.
Still deciding if next.js development is right for you?
Talk to UsNext.js gives you a rendering decision per route. Most projects make it once — in the first component anyone wrote — and then inherit it everywhere without noticing.
The result is usually one of two failures. Everything renders on the server, so a static marketing page pays a request-time cost it never needed. Or everything renders on the client, so pages that had to be found are not.
Both are avoidable with a list of routes and a column for how each one should render. It takes an hour and it is the single most valuable document in a Next.js project.
Tell us what the site does and which pages have to be found. We will map the routes against rendering modes and tell you what the deployment needs to support.
