App Router applications, commerce storefronts and interfaces over existing APIs. The decisions that matter are made before the first component, and most of them are about where things render.
In one paragraph
What does Next.js development involve beyond writing React?
Deciding where each page renders and why. Static generation, incremental revalidation, server rendering and client rendering each carry a different cost in latency, infrastructure and cache behaviour, and a Next.js application is largely the sum of those decisions. Around that sits the data layer, server components and server actions where they belong, caching and revalidation rules that match how the content actually changes, TypeScript across the boundary so the API contract is enforced rather than remembered, and a performance budget held during the build instead of audited after it.
What this is
Most Next.js projects that go wrong went wrong at the rendering decision. Everything is client rendered because that was the default in the last project, or everything is static because static is fast, and then a page needs personalisation and the whole model has to be revisited. Deciding per route, early, with the reasons written down, is the single highest-leverage hour on the project.
The second recurring problem is the data layer. React has become very good at fetching on the server, and a lot of code is still written as though it has not: a client component fetching on mount, a loading spinner, and a waterfall of three requests that could have been one server render. Server components fix this when the boundary is drawn deliberately.
This site is built the way described here. It is a Next.js App Router application exported to static files, typed end to end, with every section rendering on the server and client JavaScript limited to the places that genuinely need it.
What this page is not
This page is about building the frontend. If what you need is advice on whether Next.js is the right choice at all, or how it fits a commerce stack you already have, that is a consulting conversation.
What usually brings this in
The app is fast in development and slow in production.
Everything renders on the client, the bundle keeps growing, and the fix keeps being described as code splitting.
Nobody can explain why a given page renders the way it does.
Rendering strategy was decided per pull request, so caching behaviour is now unpredictable and nobody wants to change it.
The API changed and the frontend found out in production.
Types are hand-written and optimistic, so the contract exists in a document rather than in the compiler.
Core Web Vitals fail on exactly the pages that convert.
Paid traffic lands on the slowest route on the site, and the team only sees it in a monthly report.
What gets built
- Rendering strategy, per route, written down
- Static, incremental, server rendered or client rendered, chosen against how the content changes and who it changes for. The document is short and it is the thing that keeps the application coherent as it grows.
- App Router architecture
- Layouts, route groups, loading and error boundaries, and a server and client boundary drawn where data actually lives rather than where the first component happened to need state.
- Commerce storefronts over a headless backend
- Next.js against Shopify Storefront API, Magento GraphQL or a custom commerce API, with the cart, the catalogue and the checkout handoff each treated as a separate problem.
- TypeScript across the boundary
- Generated types from the schema where there is one, strict mode on, and the API contract enforced by the compiler instead of by a changelog nobody reads.
- Performance as a budget
- Core Web Vitals targets agreed at the start, measured on every build, and treated as a blocker rather than as a report. Images, fonts and third-party scripts are where it is usually lost.
- Accessibility built in
- Semantic structure, focus management on route changes, and keyboard paths through anything interactive. Retrofitting this is several times the cost of doing it as you go.
Technologies
- Framework
- Next.js
- React
- App Router
- Server Components
- Server Actions
- Language
- TypeScript
- JavaScript
- Zod
- Styling
- Tailwind CSS
- CSS Modules
- Design tokens
- Data & delivery
- GraphQL
- REST APIs
- Vercel
- Cloudflare
- Node.js
How delivery runs
Scope, in writing
What the work is, and what it explicitly is not. The second half is the one that protects both of us, and it is written before anything is quoted.
Architecture before code
The data model, the integration points and the failure modes, agreed on paper. Most of the expensive mistakes in commerce are made here and discovered six weeks later.
Build in reviewable slices
Work lands in increments you can see running, not in one drop at the end. You find out early if something is going the wrong way, which is when it is still cheap.
Test against the real thing
Production-shaped data, production-shaped traffic. A checkout that works on twelve test products tells you nothing about one carrying a hundred thousand.
Deploy, document, hand over
Release process written down, documentation aimed at your team rather than at me, and a defined window afterwards where fixes are mine.
Relevant builds
- Headless commerce · Fashion
Headless fashion storefront
High-performance headless commerce architecture for India’s fastest-growing men’s fashion brand.
- Headless
- Storefront API
- Performance
- Web platform · Manufacturing
Engineering manufacturer platform
A modern engineering brand platform built for discovery and enquiry.
- Web platform
- Technical SEO
- Content
Questions
- Should a commerce storefront be built in Next.js?
- Sometimes. It is the right answer when the storefront needs behaviour or performance the platform theme layer cannot give, and the wrong one when the theme would have done and you have just taken on a frontend codebase to maintain. The headless commerce page sets out that trade-off in full, including the cases where the honest recommendation is to stay on the theme.
- Can you work on an existing React codebase?
- Yes. It starts with reading it and writing down the rendering and data-fetching patterns already in use, because the expensive mistake on an inherited codebase is introducing a second pattern alongside the first.
- Do you do the design as well?
- I build from a design, and I will push back on parts of it that will cost performance or accessibility. Where there is no designer I can work from a structure and a component system rather than a blank page, which is honest about what that produces: something clean and conventional rather than something art directed.
- App Router or Pages Router?
- App Router for new work. For an existing Pages Router application the answer is usually not to migrate wholesale: they interoperate, so new routes can go in the App Router and the old ones can move when they are being touched anyway.
Describe what is in front of you and you get a written scope and a figure, usually within a few days of a short call. No charge for either.