- 01
Market
Saudi Arabia
- 02
Written for
CTO, Head of Digital
- 03
Decision
Build or migrate a site on Next.js with a deliberate rendering strategy
- 04
Languages
EN · AR
Information security for software delivery

ISO/IEC 27001
ISO/IEC 27001 certified
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.
- 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.
- 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.
- 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.
- 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.
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.
| Option | How fresh the content is | What the visitor waits for | What each visit costs you | What a search engine receives | Best for |
|---|---|---|---|---|---|
| Static generation | As 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 rendering | Fresh 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 rendering | Fresh 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
- 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.
- 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.
- 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.
In this cluster
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