Techbanq

Web · frameworks

Decide where every page renders, and the speed follows

Next.js lets a page be finished at build time, assembled on the server, or completed in the browser. Assigned deliberately per page type, that choice gives visitors a fast first paint and search engines a full page; left to a default, it buys server bills without the benefit.

Serving Saudi Arabia from our Riyadh office and our engineering hubs in Lahore and Karachi

Software team working together at desks in an open office
  1. 01

    Market

    Saudi Arabia

  2. 02

    Written for

    CTO, Head of Digital

  3. 03

    Decision

    Build or migrate a site on Next.js with a deliberate rendering strategy

  4. 04

    Languages

    EN · AR

Information security for software delivery

  • ISO

    ISO/IEC 27001

    ISO/IEC 27001 certified

Certifications & registrations

The request path

The route a request takes before a visitor in Riyadh sees anything

A well-decided page moves the waiting away from the visitor, stage by stage. Each stop on this path exists so that a later, slower one is never reached for pages that do not need it.

A four-stage path — finished at build, served from nearby, assembled on request, completed in the browser — with a branch for screens kept client-side by choice.

  1. 01

    Finished at build

    Pages whose content changes when you deploy — services, articles, landing pages — leave the build as complete HTML, with nothing left to compute per visit.

  2. 02

    Served from nearby

    That finished page is cached close to the visitor, so the distance to your origin server stops being part of the wait.

  3. 03

    Assembled on request

    Pages that must be current — pricing, availability, listings — render on the server per request, and only those pages pay that cost.

  4. 04

    Completed in the browser

    Interactivity attaches after the readable page has arrived, so scripts load behind the content rather than in front of it.

Always available

Kept client-side by choice

A logged-in dashboard or a live operations view has no search audience and may hydrate a bare shell. The word that matters is choice — a public page should never end up here by accident.

The decision

Build time, request time or browser — costing the three places a page can render

The strategy is not chosen once for the site; it repeats for every page type. This is what each choice trades, and the mistake the framework will not stop you making is applying one answer everywhere.

OptionHow fresh the content isWhat the visitor waits forWhat each visit costs youWhat a search engine receivesBest for
Static generationAs fresh as the last deploy.Almost nothing — finished HTML from a nearby cache.Near zero per visit; the cost was paid at build.A complete page, ready to index.Marketing, services, articles — most of a public site.
Server renderingFresh at the moment of each request.The server round trip — fast only if the server is quick and close.A compute cost on every single visit.A complete page, at the price of rendering it each crawl.Pricing, stock, listings — anything genuinely time-sensitive.
Client renderingFresh once the scripts have run.A blank shell until JavaScript downloads and executes.Cheap to host, expensive in the visitor’s time.Little to nothing without executing the scripts.Logged-in tools and dashboards no crawler visits.

Two honest notes

Arabic is a route in the codebase, and Next.js is not always the answer

For a Saudi organisation, the bilingual question is settled at the routing layer, not in a translation file. One codebase serves the Arabic and English trees as first-class routes: the document direction flips, layouts mirror, Arabic typefaces load with the Arabic route, and every page pair declares its counterpart. Retrofitting right-to-left onto a left-to-right build later means reopening every component; deciding it on day one costs a fraction of that, which is why it belongs in the architecture conversation rather than the polish phase.

And the framework should be allowed to lose the argument. A twelve-page brochure site edited by a marketing team is often better served by a conventional CMS with lower running costs and no build pipeline to babysit. An internal tool that lives behind a login gains little from server rendering it will never show a crawler. We hold no commercial stake in the choice — no framework vendor pays us — so when the page inventory says Next.js is more machinery than the site needs, that is what our recommendation says.

Our role

What we map before the first component and what your engineers keep

  1. 01

    The rendering map, first

    Before code, every page type on the site is assigned a place to render, with the reason written down — because the expensive mistakes in a Next.js build are the defaults nobody chose.

  2. 02

    Arabic from the first commit

    Locale routing, mirrored layout, Arabic typography and paired metadata are built into the skeleton, so the Arabic site is the same build — not a later project with its own budget.

  3. 03

    Conventions your team inherits

    The build ships with the conventions that made it fast — where data loads, what may ship to the client, how a new page picks its strategy — so the pages added after us stay as quick as the ones we launched.

Which pages exist and what they say is your commercial territory; we make sure each one renders in the place that serves its readers cheapest and fastest, and leave your engineers a codebase that keeps making that decision well.

Common questions

What buyers ask

When is Next.js the wrong tool for our site?+

When the machinery outweighs the site. A small brochure site maintained by editors is usually better on a conventional CMS: cheaper to run, nothing to build, nothing to break. An internal tool behind a login gains almost nothing from server rendering, because no search engine will ever see it and its users wait once, not per page. Next.js earns its complexity on public sites with many page types, real search traffic and a team that will keep engineering it. We take no vendor commission on the answer, so we give it from the page inventory rather than from fashion.

Can one Next.js codebase serve both the Arabic and English versions of our site?+

Yes, and it should. Locale routing gives each language its own URL tree from the same components; the document direction and layout mirror per route; Arabic typefaces load only on Arabic routes; and each page declares its counterpart so search engines serve the right language to the right searcher. The discipline that matters is treating Arabic as a first-class route with its own typography, line lengths and reviewed copy — not as a string file swapped under an English design. Done at the start it is routing work; done later it is a renovation.

Our React single-page app loads slowly on first visit. Does moving to Next.js mean a rewrite?+

Usually not. The components are already React, so the move is a migration rather than a rewrite: the public, search-facing pages move first, because they are the ones a slow first load and an empty initial response actually hurt. The logged-in areas can stay as they are for as long as you like — they were never the problem. The honest framing is that you are not adopting a framework; you are relocating the rendering of the specific pages where visitors and crawlers currently wait, one route at a time, while the rest of the application keeps running.

A rendering-strategy review that maps every page type on your site to where it should render, before a build or migration commits the architecture.

Map your pages with us