11 min read

Next.js Development Done Right

Next.js is the framework. Knowing how to use it well is the skill. We've shipped dozens of Next.js applications - marketing sites, dashboards, and full SaaS platforms.

Next.js development services build production web applications with the React framework Vercel maintains — using the App Router, React Server Components, streaming, edge runtime where it earns its keep, and the data-fetching primitives that make Next.js different from plain React. Borah Labs has shipped dozens of Next.js applications across marketing sites with perfect Lighthouse scores, customer-facing SaaS platforms, AI-driven products, agency partner sites, and the borahlabs.us site you're reading right now (Next.js 16, App Router, static export). A typical Next.js engagement runs 4-12 weeks, starts at $8,500, and includes the parts most teams underspend on: Core Web Vitals as a release gate, structured metadata and OG image strategy, image and font optimization, route-level code splitting, middleware for auth and personalization, ISR or static generation strategy chosen per page, and a CI pipeline that fails the build when bundle size or LCP regress. We deploy to Vercel by default — the DX is unmatched — but we also ship to AWS, Cloudflare Workers, and self-hosted Docker when the situation calls for it.

Send project details

Trusted by

BeamlineMabblyEYAllianzWorkwizeToptalTent FoundationKoppaRLC Solutions

Who this is for

If your situation looks like one of these three, you'll feel at home with us.

B2B SaaS, fintech, healthtech, vertical SaaS, marketplaces

Founder of a content-led business with a stale SEO problem

Has a great product but the marketing site was built four years ago in a CRA SPA, ranks for nothing, and the engineering team can't find time to migrate it. Wants a senior team to land a fast, SEO-friendly Next.js rebuild in 6-10 weeks while preserving every URL and tracking pixel.

Mid-stage SaaS, marketplaces, ecommerce platforms

Engineering manager modernizing a Pages-Router codebase

Inherited (or built) a Next.js Pages Router app over the last few years. Wants to migrate to the App Router, adopt server components incrementally, and clean up data-fetching patterns — without freezing feature work for two quarters.

Vertical SaaS, dev tools, AI products, B2B platforms

Product team launching a new SaaS platform

Greenfield project. Knows Next.js is the right choice but wants a senior partner to set up the architecture, the CI pipeline, the auth pattern, the data layer, and the deployment story so the in-house team can iterate confidently from week one rather than relearning the framework on every PR.

The Problem

Sound familiar?

  • Your React app has poor SEO because it's fully client-rendered, Google's crawler sees an empty shell, and the marketing team has no path to ranking despite owning the domain for years.
  • Page load times are killing conversion. Lighthouse mobile scores are red, the Core Web Vitals dashboard in Search Console is full of warnings, and every release seems to make it slightly worse rather than better.
  • You want to move to Next.js but your team is on a Pages Router or CRA setup, hasn't worked with the App Router, and doesn't have the bandwidth to figure out server components, streaming, and the new caching model alongside shipping features.
The Solution

How we solve it

  • Server-side rendering and static generation tuned per route — fully static for content, ISR for data that updates daily, server-rendered for personalized pages, client-only where it actually belongs. No compromises on SEO and instant page loads.
  • We use server components, streaming with suspense, partial prerendering, edge middleware, and image / font optimization to consistently hit sub-second LCP on real mobile devices — and we set the budgets in CI so the team can't regress them by accident.
  • Deep Next.js experience from the App Router and parallel routes to middleware, route groups, server actions, and the modern caching model. We know the framework inside out (we ship our own marketing site on it) and we'll bring your team along during the engagement so you don't lose knowledge when we hand off.

What you get

Concrete outputs you can expect from this engagement — and a sample of what each one looks like.

01

Marketing & Content Sites

Next.js marketing sites with perfect Lighthouse scores, fully static where possible, ISR for blog or pricing pages that update on a schedule, dynamic OG images per page, structured data, sitemap and robots configured correctly, and a headless CMS integration (Sanity, Contentful, Payload, Hygraph) for the content team to ship without engineering. The site you're reading is the canonical example.

Sample artifact

A deployed marketing site, a Lighthouse-budget guard in CI, OG image generation routes, and a Notion handoff doc for the content team explaining how to publish.

02

Web Applications

Full-stack Next.js applications with auth (NextAuth, Clerk, Auth.js), database (Prisma + PostgreSQL or Drizzle), API routes or server actions, real-time features over Pusher or Ably, payment integration (Stripe), file uploads, and a UI built on Tailwind plus a Radix-based component system. Multi-tenant where the use case calls for it, single-tenant when simpler is better.

Sample artifact

A working web application deployed to Vercel (or your cloud of choice), a CI pipeline gating type-check, lint, tests, bundle size and LCP, and architecture documentation for whoever inherits it.

03

Migration from React SPA

Incremental migration from Create React App, Vite, or Pages-Router Next.js to App-Router Next.js. We move routes one at a time behind a proxy or a Next.js rewrite, ship to staging continuously, and never freeze the rest of the team's feature work. Common reasons clients migrate: SEO, performance, server components, the modern caching story, or just exiting a no-longer-maintained framework.

Sample artifact

An incremental migration plan with a route-by-route timeline, a co-existence proxy or rewrite layer, and a parity test suite ensuring no UX regressions during the migration.

04

Performance Optimization

Audit your existing Next.js application against Core Web Vitals, INP, and LCP on real mobile devices. Common wins: route-level code splitting, image optimization with next/image, font subsetting, removing client components that should be server, RSC payload trimming, parallel data fetching, and CDN cache headers. Every fix is benchmarked before and after with WebPageTest and Real User Monitoring data.

Sample artifact

A before/after performance report with WPT runs, a list of merged optimization PRs, a Lighthouse-budget CI guard preventing regression, and an RUM dashboard tracking field metrics post-launch.

Tech stack

Battle-tested, boring where it should be, modern where it earns it.

  • Next.js logo for next.js development done rightNext.js
  • React logo for next.js development done rightReact
  • TypeScript logo for next.js development done rightTypeScript
  • Tailwind CSS logo for next.js development done rightTailwind CSS
  • Vercel logo for next.js development done rightVercel
  • Prisma logo for next.js development done rightPrisma
  • PostgreSQL logo for next.js development done rightPostgreSQL
  • tRPC logo for next.js development done righttRPC

Process

A typical engagement, end to end. Concrete deliverables every milestone.

  1. Week 1

    Audit & architecture

    • Audit the existing site (or design + spec for greenfield): rendering strategy per route, performance baseline, SEO status, accessibility, deployment story.
    • Decide rendering strategy per page — fully static, ISR, server-rendered, or client-only — and document the reasoning.
    • Set explicit performance budgets (LCP < 1.5s on real mobile, INP < 200ms, bundle < 200KB JS first load) and wire CI gates.
    • For migrations: route-by-route migration plan with a coexistence strategy that keeps the existing site live throughout.
  2. Weeks 2-4

    Foundations & first routes

    • Land core scaffolding: layout system, design tokens, component library, error boundaries, loading states.
    • Wire CI: build, type-check, lint, unit tests, Playwright E2E on critical paths, bundle-size guard, Lighthouse-budget guard.
    • Ship the first three to five routes end-to-end including metadata, OG images, and structured data.
    • Stand up staging on a preview URL with every PR getting its own preview deployment.
  3. Weeks 5-8

    Build the rest of the surface

    • Ship the remaining routes — application screens, dashboard, content surfaces — on the foundation set in weeks 2-4.
    • Server actions or API routes for any write-side functionality, with input validation (Zod) and structured error handling.
    • Auth integration, payments integration, third-party services as required by scope.
    • Continuous Lighthouse and WebPageTest checks; performance work as we go, not at the end.
  4. Weeks 9-12

    Cutover, polish, retainer

    • Final performance pass against real-device data — INP under 200ms, LCP under 1.5s on 4G mobile.
    • SEO cutover: 301s for changed URLs, sitemap, robots, structured data validation, Search Console submission.
    • Documentation handoff: architecture, deployment, content workflow, on-call runbook.
    • 30-day post-launch warranty plus optional retainer for ongoing feature work and Next.js version upgrades.

Featured plan · One-time

Growth6 weeks

$13,500

Recommended starting point for next.js development done right. Projects from $8,500.

See full pricing →
  • Everything in Launch
  • Up to 10 pages
  • Blog setup
  • GA + conversion tracking
  • Core Web Vitals optimization
  • AI chatbot (basic)
  • 3 revision rounds
  • 6 weeks delivery

Choosing a stack

The honest version. Real trade-offs, not marketing slideware.

  • Next.js App Router vs Pages Router

    When to use

    App Router for every new project in 2026 — it's where the Next.js team is investing, server components solve real problems, and the data-fetching ergonomics are dramatically better. Migration paths from Pages are mature and incremental.

    When to avoid

    Don't pick Pages for new code. Don't migrate a stable, business-critical Pages app to App Router unless you have a real reason — the migration is real work and the operational benefit is gradual, not instant.

  • SSR vs ISR vs SSG

    When to use

    Static generation (SSG / output: 'export') for content that's the same for every visitor and changes on deploy — marketing sites, documentation, this page. ISR for content that changes daily but is the same for every visitor — pricing, blog. SSR for personalized content per request — dashboards, account pages.

    When to avoid

    SSR everywhere by default. SSR has a cost (server compute, slower TTFB) and is the right call only when the content actually changes per request. Most marketing teams over-SSR; most app teams over-static.

  • Server actions vs API routes vs tRPC

    When to use

    Server actions for form submissions and any UI-driven mutations within the same Next.js app — they're ergonomic and the React 19 patterns are excellent. API routes for public-facing JSON APIs. tRPC when you have a separate React or React Native client and want end-to-end type safety with minimal ceremony.

    When to avoid

    Don't put a tRPC layer in front of your own internal Next.js UI when server actions do the job. Don't ship server actions as a public API surface — they're an internal pattern.

  • Vercel vs self-hosted Next.js

    See Koppa AI

    When to use

    Vercel is the right default — built by the same team, zero ops, edge runtime, instant preview URLs, image optimization, ISR caching all just work. The DX advantage is real and the price is competitive up to substantial scale.

    When to avoid

    Self-host on AWS / Cloudflare / Docker only when you have a specific reason — data residency, an existing platform engineering team that owns the deployment story, predictable extreme volume where the math changes, or contracts that prohibit Vercel. Don't self-host out of habit; the operational cost is bigger than it looks.

FAQ

Everything you need to know about our next.js development done right services.

Next.js gives you server-side rendering and static generation (so Google sees real content), file-based routing, image and font optimization, edge middleware, server actions, streaming, and a deployment story that's mostly invisible. For anything that touches the public internet — marketing surface, SEO target, marketing-led product — Next.js is the safer default. Plain React (with Vite) is the right choice only for fully authenticated internal tools where SEO doesn't matter.

App Router for every new project in 2026. It's where Vercel is investing, server components solve real problems, the data-fetching primitives are better, and the ecosystem has caught up. We migrate Pages Router projects to App Router incrementally when it's worth doing, but we don't force the migration on a stable codebase that doesn't need it.

Yes — we run a route-by-route incremental migration. The existing app stays live the entire time. We move routes behind a proxy or via Next.js rewrites, ship one at a time to staging, validate parity, and cut over once the new path is proven. No big-bang rewrites, no two-month freeze on feature work, no all-or-nothing risk. Most migrations finish in 8-14 weeks depending on the size of the surface.

Vercel is our default — it's built by the same team behind Next.js and the DX advantage is enormous (preview URLs per PR, edge functions, image optimization, ISR caching, analytics, all just work). We also deploy to AWS (with the Open Next adapter or Lambda + CloudFront), Cloudflare Workers, and self-hosted Docker on a Hetzner / Fly / Railway box when the situation requires it. We help clients choose the deployment target during scoping.

URLs are sacred. We map every existing URL to its new equivalent, set 301 redirects for changes, preserve every meta tag and structured data block, regenerate the sitemap and submit it to Search Console, and run a side-by-side crawl of old vs new before cutover to catch anything missed. We've migrated marketing sites without losing rankings — it's mostly process discipline, not luck.

On marketing surfaces, yes — and we treat the Lighthouse budget as a release gate, not a launch checkbox. On heavily interactive applications (dashboards, editors, real-time UI), some Lighthouse metrics are harder to score perfectly because the workload is genuinely heavy — we focus on INP, LCP, and CLS for those, with explicit budgets. We share before/after WebPageTest runs on every performance engagement.

Yes — Vitest for unit and integration tests, Testing Library for components, Playwright for end-to-end coverage of critical user paths, and Lighthouse / Web Vitals checks gating CI. Coverage targets scale with the criticality of the surface — payments and core flows get heavy coverage, rarely-used admin screens get less. We don't chase a coverage percentage; we chase confidence.

Carefully. The Next.js fetch caching, route segment config, and revalidate semantics are powerful but easy to get wrong. We set explicit cache strategies per route, document them in code comments, and instrument cache hit rates so we know what's actually happening in production. When you're getting stale data or unexpected SSR, the answer is usually in the caching layer — we make it visible rather than mysterious.

A focused marketing-site rebuild ships in 4-6 weeks. A full SaaS application runs 8-14 weeks depending on scope. An incremental migration from CRA or Pages Router takes 8-12 weeks while keeping the existing app live. We commit to dates during scoping, demo weekly, and ship to the schedule we agreed in week one.

Ready to ship next.js development done right?

Tell us what you need. We will scope it, price it, and give you a timeline - all before you commit to anything.

Send project details

No commitment. No sales pitch. Just a clear plan.