Techbanq

Stacks · front-end

React is chosen for the years of change after launch

A component architecture pays its rent when an interface changes for years under many hands: pieces are replaced without reopening the whole, and states compose instead of colliding. For a page that is mostly a document, that machinery is cost without benefit — and we say so before writing it.

Software team working together at desks in an open office

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

Information security for software delivery

  • ISO

    ISO/IEC 27001

    ISO/IEC 27001 certified

Certifications & registrations

The architecture

Four decisions that shape a React estate before the first component

React itself decides very little — it is a rendering library, not an architecture. These are the decisions that actually determine what the codebase costs to change in year three, and they deserve to be made deliberately rather than inherited from a starter template.

  1. 01

    Component boundaries

    Drawn from the product’s own seams — a booking flow, an approval queue — not from visual coincidence, so a team can own and change a slice without a meeting.

    • Design system
    • Feature modules
  2. 02

    Where each state lives

    Form input, server data and cross-cutting session state are different problems with different tools; treating them as one is how a global store swallows an application.

    • Local state
    • Server cache
    • Store
  3. 03

    The data layer

    Fetching, caching, retries and invalidation live in one declared layer, so components describe what they need rather than each inventing how to get it.

    • API client
    • Cache policy
  4. 04

    The rendering host

    A logged-in tool can live happily in the browser; a public, search-facing site usually should not. The choice of host is made from the audience, page by page.

    • SPA
    • Server framework

A server framework on top

When the estate includes public pages that search engines and first paints matter to, a server-side framework such as Next.js takes over the rendering host decision per route. The components stay React; only where they render moves.

The expensive React codebases are rarely the ones that chose a wrong library; they are the ones that never made these four decisions at all.

State, by need

Choosing React state management by the problem, not the conference talk

Most state debates compare tools; the useful comparison is between kinds of state, because each kind already has a right home. The mistake the ecosystem invites is picking one tool and forcing all three kinds into it.

OptionWhat it actually isIts right homeThe failure of forcing it elsewhereBest for
Interaction stateA form mid-edit, an open menu, a hovered row — state one component owns for moments.Local component state, where React already keeps it.Hoisted into a global store, it makes every keystroke an application-wide event.Nearly everything a user touches directly.
Server dataRecords the backend owns — the front-end holds a cache of them, never the truth.A server-cache layer with declared staleness, retries and invalidation.Copied by hand into a store, it goes stale silently and two screens show two truths.Lists, records, dashboards — most of an enterprise UI.
Session and cross-cutting stateWho is signed in, which locale, which permissions — read everywhere, written rarely.A small, deliberate global store or context, kept boring on purpose.Scattered through props and locals, it leaks into every signature in the codebase.The thin layer that genuinely is global.

Arabic, properly

What right-to-left actually demands of a React component tree

React does not make an interface bilingual; discipline does. An Arabic-ready component tree uses logical CSS properties — start and end, not left and right — so the layout mirrors from one direction attribute instead of from a parallel stylesheet. Icons that imply direction flip; numerals, dates and truncation follow the locale; and Arabic text gets typefaces and line heights chosen for Arabic, not inherited from the Latin design. Done in the design system once, every component inherits it. Done per screen, it is never finished.

The test we apply is blunt: open the Arabic build first in every review. When Arabic is reviewed as the afterthought, the defects accumulate on the side most of your Saudi users actually see. A component library that passes that review — mirrored, correctly set, honestly translated — is a one-time investment the whole estate then rests on.

The maintenance profile

Owning a React estate means budgeting for its ecosystem, not just its features

The honest cost of React is not the first build; it is the ecosystem moving underneath it. Dependencies release majors, patterns fall out of favour, and a codebase left unattended for two years quietly becomes a migration project. This is not a defect unique to React — every active ecosystem has it — but React’s size makes it pronounced, and a buyer deserves to hear it before choosing, not at renewal.

We manage it the way infrastructure is managed: few dependencies, each earning its place; upgrades taken small and regular rather than heroic and rare; and the design system as the stable layer product teams build on while the plumbing beneath it is serviced. A React estate run this way ages like a maintained building. Run without that discipline, it ages like an unmaintained one — and the rebuild gets priced as React’s fault when it was the regime’s.

Our role

What we architect in a React engagement and what your product team keeps

  1. 01

    The fit question, answered first

    Before any build, we say whether the interface justifies React at all — and when a simpler render of mostly-static pages would serve better, that is the recommendation, because we hold no stake in the library.

  2. 02

    Boundaries before components

    The component, state and data boundaries are drawn and written down before feature work starts, so the codebase grows along seams instead of accreting into one tangle.

  3. 03

    A regime your engineers inherit

    The upgrade cadence, the dependency policy and the Arabic-first review habit are handed over as working practice, so the estate stays maintainable after we step back.

What the product does and which features earn a place is your territory; we make sure the React architecture underneath it stays cheap to change, in both languages, for as long as you own it.

Common questions

What buyers ask

Is React the right choice for a mostly content-driven website?+

Usually only with a server-side framework on top, and sometimes not at all. React’s value is managing interfaces with many interacting states; a site that is mostly documents gains little from that and pays the full maintenance cost anyway. Where a content site does justify React — shared components with an application, an editorial team on a structured CMS — the public pages should render on the server so search engines and first visits get finished HTML. And when the honest answer is that a conventional CMS serves the case better, that is what we recommend, because we take no commission on the library.

How do you stop a React codebase decaying as it grows?+

By treating the ecosystem as an operating cost, not a surprise. The dependency list is kept short and every entry has to earn its place; upgrades are taken small and on a cadence rather than deferred into a heroic migration; and the design system is the stable contract product teams build against while the layers beneath it are serviced. The codebases that decay are almost never victims of React itself — they are victims of two years of deferred maintenance being discovered at once. A regime of small, regular servicing is unglamorous, and it is the entire difference.

Which state management library do you use with React?+

The one each kind of state needs, which is usually three answers rather than one. Interaction state stays local to components; server data lives in a server-cache layer that owns staleness and invalidation; and the genuinely global slice — session, locale, permissions — sits in a small, deliberately boring store. Named libraries change every few years, and we pick current, well-maintained ones per layer; the architecture is the part that lasts. The choice we argue against is the fashionable one: a single global store that swallows all three kinds and turns every screen into a dependency of every other.

Does an Arabic-first interface change how you build React components?+

Yes, from the first component. Layouts are written with logical properties so they mirror from a single direction attribute; directional icons are declared as such so they flip; typography, numerals and truncation follow the locale; and the Arabic build is opened first in reviews, not last. None of this is difficult, and all of it is nearly impossible to retrofit cheaply, because retrofitting means reopening every component that guessed. On a Saudi product the Arabic interface is the majority experience, so building it as the primary one is not a courtesy — it is aiming at the actual users.

Next step

Assess the fit with us

An architecture review that decides whether your interface justifies React, and if it does, the component and state boundaries before the first sprint.

Assess the fit with us

What happens next

  1. 1We reply within one business day.
  2. 2A 30-minute scoping call with a senior consultant.
  3. 3A written proposal with scope, team, and timeline.

Or reach us directly

By submitting this form you agree to our Terms of Use and Privacy Policy.