Skip to content
PRS India

React 19 · TypeScript · Vite · TanStack Query

React Development

React is the easy part. The choices around it decide whether an app does well or goes bad. We do React development in TypeScript with the right way to show pages, server data handled by TanStack Query, and slow screen updates measured, not guessed.

Last updated

  • The right way to show pages, SPA or server-rendered, decided first
  • Server state on TanStack Query, client state kept small
  • TypeScript throughout; re-renders profiled, not guessed
  • Bundle size limit checked in CI, accessibility built in
React Development
Why React

The library is easy. The decisions around it are the job.

React won the frontend because it made complex screens easier to build, and almost everything around it now expects it. But the library is the easy part. A React project does well or goes bad because of a set of choices around it. These are: which framework wraps it, whether it shows pages from the server, how server data and screen data are kept apart, and whether anyone is watching the bundle size. We do React development that gets those choices right first. We use TypeScript, keep server data in a proper data layer, and keep screen data small and planned. The result is React that nobody complains about. It is fast on a mid-range phone, easy for the next engineer to read, and still pleasant to work in three years later.

Talk to a React engineer
TS
Typed throughout

Every component has types, so mistakes show up in the editor and not as a white screen on the live site.

<200
Bundle budget

A size limit for the first load of the main page, checked in CI. If it gets worse, the build fails. We do not wait for a bad quarter.

INP
Profiled, not guessed

We measure how fast the app responds to clicks with the React profiler. We find needless re-renders and fix the cause.

AA
Accessibility built in

Components are built on accessible parts, so keyboard and screen-reader support is part of the base. It is not added in a rush before an audit.

How we actually build it

React is the library the rest of the frontend world orbits, and most of what people call "React development" is really a set of decisions around React: which framework wraps it, how state is managed, how data is fetched, and whether the app should render on the server at all. Get those four right and React is a joy to maintain for years. Get them wrong and you have the sprawling, re-rendering, prop-drilled application that gives React its bad reputation.

Not every React app should be a single-page app

The reflex to reach for a client-rendered SPA is the source of most of the React pain we are asked to fix: a blank page until a large bundle downloads and runs, poor SEO unless you work very hard, and a slow first paint on the mid-range Android your users actually hold. If the app is public and needs to rank, we build it in Next.js with server rendering so crawlers and users get real HTML. If it is a logged-in dashboard where SEO does not matter, a light Vite SPA is the right and simpler choice. The mistake is using one answer for both. It is the first thing we settle.

Data fetching is a solved problem — stop solving it again

A lot of buggy React comes from data fetching written by hand: useEffect chains, loading flags, timing bugs and old cached data, repeated in every component. We use TanStack Query as our standard (or the framework's own data layer) for server state — caching, deduplication, background refetching and invalidation handled once, correctly. That leaves genuine client state — the cart drawer, the wizard step, the theme — for a small, deliberate store like Zustand, or Redux Toolkit when the app is large and the team wants strict conventions. Mixing server data and screen data into one big global store is the most common design mistake we have to fix.

TypeScript, and re-renders you can actually see

We write React in TypeScript, always, because a typed component contract catches the prop and shape errors that otherwise show up as a white screen on the live site. On speed, we do not guess: we profile with the React DevTools profiler, find the components re-rendering for no reason, and fix the actual cause — an unstable callback, a context that is too broad, a list without stable keys — rather than adding memo everywhere and hoping. Most "React is slow" complaints are a handful of fixable re-render problems, not the framework.

The tooling that keeps it maintainable

Vite for the dev server and build, because fast feedback is not a luxury. A component library built on accessible parts — Radix or React Aria — so keyboard and screen-reader support is built in and not added later. Testing with React Testing Library at the component level and Playwright for the flows that carry money. And a bundle size limit checked in CI, because a React app's size only ever grows unless someone is watching it, and the person watching should be the build, not a customer on a slow connection.

The honest part

When React is the right call — and when it is not.

  Choose React Choose something else
Complex, interactive product UI Yes. This is what React is for: rich state, many components, and a design system shared across screens. For a mostly static content site, a lighter tool shows pages faster with far less JavaScript.
Public page that must rank Yes, but as Next.js with server rendering, not as a client-rendered SPA. For pure content with a team that works in it every day, a CMS or a static site generator can be simpler.
Mostly static marketing content Too much as a client SPA. You send a lot of JavaScript just to show text. Astro or a static generator: almost no JavaScript, faster first view, cheaper to run.
You have a React web + mobile roadmap Strong. Types, checking rules and logic can be shared with a React Native app with little repeated work. If mobile is Flutter, that sharing is lost. Think about it before you decide.
Simple server-rendered site, small team Ask whether you need a SPA at all before taking on its extra build and caching work. Laravel Blade or a server-rendered stack is faster to finish for a team that already uses it.
Team is Vue- or Angular-first No reason to force React if the team is productive and invested elsewhere. Stay with Vue or Angular. The gain from React's large ecosystem is real only if your team works in it.
What we build

React work we take on.

Product dashboards & portals

Screens full of data, with real state: filters, tables, charts and live updates. They are built to stay fast and easy to read as they grow, in TypeScript throughout.

Server-rendered React (Next.js)

Public pages that must rank and load fast: server rendering, real HTML for search crawlers, and a bundle that stays within its size limit on a mid-range phone.

Design systems & component libraries

A typed, documented, accessible component library in Storybook. Your marketing site and product both use it, so the brand looks the same in both.

Real-time interfaces

Live dashboards, editing together and showing who is online, over WebSockets. We handle the odd cases with server data and lost connections, and do not just hope they never happen.

React rescue & refactor

Data fetching written by hand, a global store holding everything, no types and no tests. We fix these step by step while the app keeps going out to users.

Performance & Core Web Vitals

A check against real user data, the re-render and bundle problems fixed at the cause, and size limits checked in CI so it does not quietly get worse.

Characteristics

What good React gives you, with the caveats.

  • The largest ecosystem in frontend

    A library, a component and people to hire for almost anything. This wide choice is React's biggest advantage. If it is not managed, it is also the cause of its bloat.

  • Typed component contracts

    TypeScript catches the prop and shape errors that otherwise show up as a white screen. We treat a public component without types as a fault.

  • Server state handled once

    TanStack Query does caching, removing repeated requests and refreshing old data correctly. So it is not rebuilt, with bugs, in every component.

  • Real HTML when it matters

    Server-rendered React gives crawlers and users real HTML and a fast first view. A client SPA gives them a blank page and a bundle to wait for.

  • Accessibility by construction

    When it is built on accessible parts, keyboard and screen-reader support comes built in. Adding it after an audit costs far more.

  • A bundle someone is watching

    A React bundle only grows unless the build enforces a size limit. We let the build do the watching, not a customer on a slow connection.

How we build

From decisions to a React app that ages well.

The four choices that decide a React project are settled first. Then we build in small slices, each one working from screen to server.

  1. 01

    Settle the four decisions

    Week 1

    How pages are shown (SPA or server-rendered), the framework, how state is organised, and the data layer. We write down the choice and the trade-off before we build a component, because these cost a lot to change later.

  2. 02

    Component library and tokens

    Weeks 1–3

    Accessible parts, design tokens, and the empty, loading and error screens that nobody remembers to draw. Written up in Storybook so the team builds from one source and not from screenshots.

  3. 03

    Build in vertical slices

    Weeks 3–12

    Each sprint delivers a working path from screen to API, typed from start to finish, with server data on the data layer and tests on the flows that carry risk. A demo and a list of changes every two weeks.

  4. 04

    Profile and budget

    Ongoing

    Re-renders measured and fixed at the cause, the bundle kept under its size limit in CI, and Core Web Vitals checked against real user data and not a test on office wifi.

  5. 05

    Hand over

    Final week

    The component library, a note on how it is built, and a getting-started session so your team owns it. Or we move to a monthly plan and keep building your roadmap.

The stack

What ships with a React build from us.

The tools we pick when the choice is ours. We can swap them for what your team already uses.

React 19
TypeScript
Vite
Next.js

Bring us the React app that is slow, sprawling, or not ranking.

Tell us what it does and where it hurts. A senior engineer reads every enquiry and replies within one business day with the scope, the risks and a price. You do not get a brochure.

FAQ

The questions you were going to ask on the call.

It depends on one thing: does Google need to find it? If the app is public and ranking matters — marketing, content, a storefront — we build it server-rendered in Next.js so crawlers and users get real HTML and the first view is fast on a mid-range phone. If it is a logged-in dashboard behind authentication where SEO is irrelevant, a light Vite SPA is simpler and fully fine. Most of the React trouble we are hired to fix comes from building a client-rendered SPA for a page that needed server rendering. So we settle this before anything else.

First, keep server data and screen data apart, because mixing them is the most common design mistake we have to fix. Server state — anything fetched from an API — belongs in TanStack Query or the framework's data layer, which handle caching, removing repeated requests, refreshing in the background and clearing old data correctly. So you do not rebuild them in every component. Real screen data, such as a cart drawer, a wizard step or a theme, goes in a small, planned store like Zustand. For a large app where the team wants strict rules, use Redux Toolkit. One big global store holding both is how React apps become hard to maintain.

Almost never the framework itself. In practice "React is slow" means a handful of problems that can be fixed. Components re-render because of an unstable callback or a context that is too broad. A list has no stable keys. A bundle has quietly grown to several megabytes. Or data is fetched on the client that should have been shown from the server. We profile with the React DevTools profiler to find the real cause rather than sprinkling memo everywhere and hoping, set a bundle size limit in CI, and move work to the server where it belongs. The fix is usually small and quick.

Not really. Next.js is a framework built on React. So the question is whether you want a framework around React, or React on its own with a build tool like Vite. For anything public where you want server rendering, routing and SEO handled for you, Next.js is the sensible choice. For a stand-alone SPA behind a login, plain React on Vite is lighter and has fewer parts. We build both, often for the same company. One example is a public Next.js site and an internal Vite tool that share one component library. We choose for each app, not by fashion.

Regularly. We start with a short audit. We read the code, measure it, and map how it manages state and fetches data. We often find data fetching written by hand and full of timing bugs, a global store holding everything, no TypeScript, no tests on the key flows, and a bundle nobody has been watching. We give you a written report with a plan in order of importance. Then we fix things step by step while the app keeps going out to users. We add types, a proper data layer and a bundle size limit, with no big rewrite.

A focused React front end on top of an existing API, such as a dashboard or a portal, usually takes 8 to 14 weeks and starts from around ₹8,00,000. A larger product with complex state, live features and a shared component library takes 16 to 24 weeks and costs more. If the app must rank and needs server rendering, we build it in Next.js and scope that separately. The thing that changes the most is rarely React itself. It is how many other systems the front end connects to and how well they work. Our first planning stage is there to pin this down.

Let's talk react development

Bring us the hard version of the problem.

A senior engineer reads every enquiry. You'll get a real answer — scope, risk and a number — within one business day.