Skip to content
Next.js | React | TypeScript

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.

How engagements work

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

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

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.

All services