Web engineering / React
React development.
Web apps, dashboards and admin systems.
Build the browser workflows a business needs: customer portals, operations queues, analytics and SaaS screens. Design the API, access and rendering boundaries alongside the interface.
Discuss React requirements โContents ยท React
Start from the task and its authoritative data.
A React web scope can include a single-page application, customer portal, internal tool, marketplace vendor panel or SaaS dashboard. Define who reads and changes which records, the transitions each task permits and the recovery when a request fails. A responsive component tree is one part of that product, not its database, permission system or operating model.
Group related screens, hooks and domain behaviour into clear features. Keep shared primitives small, API access explicit and cross-feature dependencies visible. A folder convention can help a team change modules, but it does not guarantee isolation, fixed delivery speed or that changes cannot break another route.
- Browser experience: navigation, forms, tables, charts, empty/error states and accessible interactions.
- Data: API contracts, validation, query identity, pagination and mutation recovery.
- Access: session, tenant, role and record permissions checked by the authoritative backend.
- Delivery: reproducible builds, reviewed previews, tests, deployment and operating notes.
The original describes pre-existing production admin modules. Inspect the actual base, rights and tests before assuming those modules are available. React knowledge can carry into React Native, but web screens are not automatically native phone interfaces or a shared deployable codebase.
A repository is necessary, not the whole handover.
Agree the source repository/history, lockfiles, build/test/CI configuration, API schemas, deployment configuration, design assets and operating runbook. Identify the backend and mobile repositories separately where they exist. Confirm the receiving team can build, test, deploy and make a representative change from the documentation.
Separate rights in custom work from React and other dependencies, UI kits, fonts, images, commercial packages and hosted services. White-label use, IP assignment, confidentiality, transfer and continuing support require written terms; ownership language does not erase third-party licences or prove immediate effortless takeover.
Use a secure access-transfer route for hosting, domains and provider accounts. Keep secrets out of the repository, ordinary documentation and browser bundles. A source-code archive is not a database/files backup, a working restore or reversal of external side effects. No blanket IP-safety, zero-lock-in or free-support guarantee is established here.
Compare React, Vue and Angular against the same product.
Compare rendering, routing/data patterns, forms, accessibility, dependency choices, team skills and long-term operation on a representative screen. Do not convert ecosystem size, virtual DOM terminology or framework labels into a proven hiring advantage, speed ranking, cost minimum or performance ceiling.
- UI updates: realistic table/chart/form interactions and target-device measurements.
- Ecosystem: selected router, query/form/chart packages and maintained dependencies.
- Team fit: current skills, conventions, review, continuity and receiving-team operation.
- Rendering: client, static, server and streaming needs by route, not by brand label.
- Maintenance: testability, supported releases, upgrade scope and deployment constraints.
A team already maintaining Vue/Nuxt or Angular may reasonably stay there. A small interactive feature may not need a full application rewrite. A native-first product needs its own device and release evaluation. React is a UI choice within a larger architecture, not a universal recommendation.
Seven decisions before a React engagement.
What does the build actually include?
Name routes, layouts, data loading, mutations, API validation, auth/access, forms, error handling, tests and deployment. React is not the entire application framework. Current React guidance recommends starting new apps with a framework; a build-tool-only setup remains an option when its tradeoffs fit the requirements.
When is it the right interface?
Use the actual task: an operations queue, filterable dashboard, customer portal or complex form may benefit from reusable components and stateful interaction. A content-only site or a few interactive controls may need less infrastructure. Prototype the difficult workflow before selecting the full dependency set.
What should public crawlers receive?
Choose route-level rendering deliberately and inspect the initial response, links, metadata, status codes and accessible content. Server/static HTML can make important text available without waiting for browser JavaScript. This does not guarantee indexing, AI retrieval, ranking or conversions; crawler behaviour and discovery require separate checks.
Who owns architecture and delivery?
Whether using a specialist or a company, name decisions, code review, backend ownership, QA, release and continuity. A company label does not prevent drift and an individual label does not imply it. Request relevant evidence and receiving-team handover tests instead of repeat unsupported comparisons.
What affects build and running cost?
Large tables/charts, realtime updates, permissions, multi-tenancy, custom design systems, integration and migration increase the work to evaluate. Static output and request-time rendering have different hosting needs. A framework name alone does not determine a hosting bill or require a particular provider.
How should performance be improved?
Profile representative builds, queries and interactions. Consider route/data preloading, code splitting, list virtualisation, fewer expensive calculations and a supported compiler where appropriate. Avoid serial code-then-data waterfalls and memoisation that hides an underlying correctness issue.
Can an existing codebase be modernised?
Audit supported versions, dependencies, routes/data, tests, accessibility, client secrets and release constraints. Plan staged TypeScript adoption, data-loading changes, class/hook updates or a build-tool migration around user journeys. Do not assume every Redux use must be replaced or every app should adopt the same framework.
Give features, API data and local UI state clear owners.
Feature folders can keep components, hooks and tests near their purpose, with shared API/auth infrastructure and reusable controls. Define permitted dependency directions and exported interfaces rather than rely on folder names. Domain decisions such as order approval or payout eligibility belong in authoritative services, not a display component.
A query cache can own fetched server data. Component state or a small store can hold open panels, drafts and local filters. URL state may be preferable for shareable search, pagination and navigation. Avoid copying the same server record into several stores without a synchronization rule.
TanStack Query and Zustand are options in the source, not universal mandatory standards. Use framework loaders or another supported cache where they fit. Effects synchronize with external systems; direct fetching in an Effect is possible but needs cleanup/race handling and often lacks coordinated caching and preloading. It is not forbidden by React.
Write types for props and API interfaces, but validate untrusted responses and mutation inputs at the boundary. A TypeScript string vendorId or asserted response shape is not runtime validation, authentication or permission to access a tenant. Separate compile-time contracts from server enforcement.
An orders query key is a cache identity, not an access check.
The original useOrders hook calls api.getOrders(vendorId) with an orders/vendorId key and staleTime. That sketches how distinct vendor data can be cached; it does not show the API return contract, runtime validation, backend authorisation, pagination, errors, cancellation or post-mutation reconciliation.
- Key every variable that changes the fetched result: intended tenant/vendor context, filters, sort and page as appropriate.
- Require the backend to validate session, tenant membership, role and permitted target, regardless of browser-supplied IDs.
- Return parsed domain data from the API client, not an unexamined transport response or any assertion.
- For fetch, turn unsuccessful HTTP responses into rejected query results explicitly; fetching an error response does not itself throw.
- Choose freshness, refetch, retry, persistence and inactive-cache lifetime deliberately.
- Forward the supplied AbortSignal into a supported transport if real request cancellation is required.
- Clear or partition sensitive cached data when accounts/tenants change and avoid shared server caches across users.
- After mutations or realtime events, invalidate or update the intended keys and reconcile failed optimistic updates.
staleTime is freshness, not inactive-cache retention or a guarantee of instantly reopening a table. Cached data may not exist, may have been collected, or may require manual invalidation; explicit polling has its own interval. Define what stale data the user can see and prevent important actions from trusting an old browser snapshot.
Query cancellation does not automatically mean a network request was aborted: the transport must consume the signal. Nor does cancelling a display request reverse a server mutation. Test rapid vendor/filter changes, logout, expired permission, late responses and unknown mutation outcomes. This is a planning example, not a complete installed hook.
Pick rendering by route, not a Vite-versus-Next slogan.
Current React framework guidance covers client-side apps, static generation and server rendering. A framework does not always require a runtime server; a static export can use static hosting, subject to supported features. Conversely, adding request-time work requires the appropriate runtime and operational controls.
React Server Components can run at build time or per request in a separate environment. They are not identical to SSR, and a server-rendered Client Component can still hydrate and execute in the browser. In Next.js, the client boundary includes imported client modules; pass only data intended for the recipient across it.
Use server-only boundaries for sensitive services and keep secrets out of public build-time variables. Vite documents that VITE-prefixed values are bundled into client code; an environment file or encrypted deployment setting does not make a value private once emitted into browser JavaScript.
Hydration expects the initial client tree to match server-rendered HTML. Test timestamps, locale, random values, browser-only APIs and data snapshots rather than suppress mismatch warnings broadly. Verify links, status/error pages, loading states and first interaction under slow scripts. Framework rendering is not proof of SEO, accessibility or permission safety.
Routes and components cannot enforce backend permissions alone.
Route guards improve navigation and avoid presenting unavailable controls. The API must independently authorise each read, mutation and export against actor, tenant, role, record and state. An audit log needs a trusted server source, protected storage and retention rules; a browser event label does not prove an action occurred or was permitted.
Server Functions are client-callable network boundaries. React documents their arguments as untrusted and requires authorisation for mutations. A use server directive does not turn arbitrary code into a secure endpoint. Validate input and output, protect session/request boundaries and do not serialize private data to client props.
- Test anonymous access, wrong tenant, removed roles, direct resource IDs and forged mutation parameters.
- Handle double submissions, retries, stale edits, concurrency and uncertain payment results.
- Separate financial/provider confirmation from optimistic UI and notification state.
- Review unsafe HTML/URLs, file access, dependency updates and confidential export behaviour.
No penetration-test result, regulatory compliance or secure running system is established here. Logging, error reporting and analytics must respect approved data/audience limits. Do not send sensitive table rows, tokens or personal data automatically to monitoring tools.
Measure the expensive work before choosing an optimisation.
Inspect initial JavaScript, route transitions, network/data waterfalls, rendering commits, table/chart cost and server response. Use production-like builds and representative devices/data; retain development checks for correctness. Lab runs, profiler traces and real-user metrics answer different questions and should not be presented as the same result.
Current React Compiler guidance describes a stable, optional build-time optimisation that depends on code following React rules. Evaluate compatibility and measure its effects. For existing manual memoisation, test before removing it. useMemo is a performance tool, not storage on which business correctness should depend.
For long lists, consider virtualisation with keyboard, focus and screen-reader checks. A table with a large record count should not require rendering or downloading every record. Load chart code and data in a coordinated way rather than delay each serially. Bundle budgets and metrics are acceptance tools, not guarantees of a score or a fixed number of re-rendered nodes.
Realtime updates need sequencing, reconnect, duplicate/out-of-order handling and query reconciliation. A WebSocket transport alone does not prove consistent state, reliable delivery or a live financial/dispatch view. Display staleness and recovery states when authoritative updates are unavailable.
Three engagement shapes with explicit delivery boundaries.
- Admin base adaptation: inspect the actual reusable modules, rights, backend contracts and required changes.
- Custom React product: architecture, data/access, screens, integration and acceptance around the brief.
- Continuing development: prioritised features, releases, dependency upgrades and incidents under written capacity and terms.
Agree team roles, review cadence, milestones, billing, scope changes, cancellation and handover. Source starting prices, fixed dates, staffing and automatic weekly output are not current commitments. A browser admin base does not include every catalogue platform or native app.
Six acceptance areas across code, users and operation.
- Review: feature boundaries, hooks, data/types, server authorisation and dependencies.
- Tests: domain units, user-facing components, critical browser journeys and negative access cases.
- Performance: published build profiles, representative data/devices, hydration and bundle budgets.
- Handover: reproducible source/history, lockfiles, API/configuration docs and secure access route.
- Release: approved hosting/domain/TLS, environment separation, cache rules and recovery.
- Operation: errors, service health, data-safe telemetry, alert ownership and agreed support.
Coverage numbers alone do not prove behaviour, and a component library does not certify accessibility. Test keyboard/focus, labels, contrast and actual task success. Record the browser/device combinations and known gaps instead of claim universal compatibility or no untested code ever ships.
Choose a supported dependency set for the product.
- React/TypeScript: component model and compile-time contracts with validated boundaries.
- React Router or a selected framework: routing, data and rendering integration.
- Vite: a build-tool option where the chosen architecture fits.
- TanStack Query or another cache: server data, mutations and invalidation.
- Zustand or local/URL state: deliberate UI state ownership.
- Tailwind/shadcn or another design system: tested components, tokens and interaction patterns.
- Next.js: selected server/static/client patterns, not an automatic runtime hosting requirement.
- fetch/Axios: typed, validated transport with explicit errors and cancellation.
- Recharts/other charts and WebSockets: measured visualization and reconciled realtime updates.
- Node.js or another backend: authoritative data/access and supported API contracts.
- GitHub Actions/hosting tools: reproducible CI, private previews and reviewed releases.
- Vercel/AWS/another host and Sentry/another reporter: selected runtime, data exposure and operating terms.
Check actual maintained React releases and package compatibility rather than assume a historical major, type minimum or latest package is appropriate. Define account, hosting, telemetry and deployment responsibilities for the selected implementation, including any recurring charges.
From brief to a receiving team that can operate the product.
- Brief: people, workflow, sensitive data, devices, dependencies and confidentiality.
- Scope: actual base/custom architecture, contracts, acceptance and operating cost.
- Build/demo: protected preview, realistic records and the difficult end-to-end task.
- QA: browser/device interaction, API/access, performance, recovery and live-data reconciliation.
- Release/handover: owner-approved destinations, docs, verification and receiving-team operation.
Content, account access, provider onboarding and mobile-store approvals are dependencies. Agree current milestones rather than repeat first-commit, launch-day, NDA-turnaround or free-support claims. A frontend rollback may not reverse a schema migration, queued job, email or payment.
Price the modules and operating needs, not a framework label.
- Users, analytics, content, order/booking, dispatch and payout administration.
- Forms, tables, charts, design system and accessibility requirements.
- Realtime delivery, data freshness, offline expectations and error recovery.
- Tenant/role/record access, exports, logging and privacy duties.
- Rendering/runtime choice, APIs, integrations and migration.
- CI, testing, hosting/services, monitoring, maintenance and handover.
Request an itemised current written scope with exclusions, usage assumptions and ongoing costs. Reusing a base can change the work, but does not establish fixed pricing, a deadline or no surprise costs. Third-party licences, provider usage and additional native/backend work need their own lines.
Modernise one verified boundary at a time.
Inventory routes, components, state, API contracts, secrets, dependency support, test evidence and deployment paths. Map critical journeys before a build-tool, framework, data-cache or major-version change. Preserve URLs and behaviour deliberately; a passing compile does not establish runtime equivalence.
Move behind stable interfaces where practical: typed/validated API clients, feature boundaries and testable state rules. Avoid simultaneous schema, auth, design and cache rewrites without a rollback plan. Stage strictness and class/hook changes around testable increments rather than replace all working code for stylistic consistency.
Check hydration, assets, cache invalidation, session handling, old clients and provider callbacks during cutover. Keep database/files backup and reconciliation separate from source rollback. The source claim about moving from Create React App is an example migration category, not proof that a particular existing app is unsupported or that Vite is always the destination.
An analytics dashboard and exchange UI need distinct evidence.
The source supplies a multi-tenant B2B analytics brief: role-specific KPI views, live widgets, exports, React, Query, Recharts, Zustand and a Node API. Preserve it as a useful scope scenario, not proof of a timed launch, fundraising result or GDPR compliance.
- Define tenant/role isolation for every KPI source, detail view and export.
- Specify update freshness, timezones, units, aggregation and reconnect behaviour.
- Keep export authorisation, filtering and sensitive-data retention authoritative.
- Validate shared API schemas at runtime; do not confuse shared types with shared permissions.
- Test realistic data volumes and reporting correctness alongside UI responsiveness.
A separate source record names an exchange product with twenty proposed building blocks, sixteen described as reused, four as custom, two interfaces and six integrations. Those counts remain recorded scope to verify, not an independently confirmed delivered client result. Ask which exact modules changed, who owns each integration and how acceptance was evidenced.
A React exchange screen does not establish custody, trading/risk correctness, market-data authority or financial permission. The named quote, delivery date, application total and source-transfer outcome are not independently established here; no testimonial or launch claim is republished as proof.
React delivery review and handover.
Request permitted repository/app evidence, API and auth boundaries, dependency inventory, test results, production-like profiles, release/recovery and receiving-team handover. A billing, security or commerce testimonial may describe an adjacent product without proving this React architecture or its quality.
Agree the implementation boundary, deliverables and acceptance checks in the project scope. Include the source and configuration to be handed over, third-party dependencies, account ownership and the receiving owner's installation and operating walkthrough. Review the selected work at the agreed milestones, with unresolved items recorded before release.
Translate sectors into interface and backend requirements.
- Healthcare/life sciences: patient/booking workflows with minimum necessary data and separate compliance review.
- Telemedicine: intake/provider screens distinct from secure clinical/video delivery.
- Fintech: verified data sources, transaction authority, onboarding and audit.
- Retail: catalogue/checkout UI with authoritative stock, price and order state.
- Media: playback/content portals with licensed delivery and entitlement.
- Creators: profiles, paywalls, membership and moderation.
- Transportation: dispatch/maps with location permission, freshness and operational recovery.
- Food/beverage: menus, orders, branch roles and fulfilment state.
React, a UI kit or a sector label does not certify privacy, accessibility, banking permission or clinical readiness. Agree the backend, jurisdiction, data class and actual evidence required.
Questions to settle before React work.
Can the web admin work beside mobile apps?
Yes as an architecture option: define shared APIs, identifiers, permission rules and version compatibility. TypeScript can help some clients share contracts, but Flutter/Dart does not consume TypeScript as native source. Generate or maintain language-appropriate schemas and validate at the service boundary.
Does every public page need request-time SSR?
No. Select static, server or client patterns for content freshness, interactivity, privacy and operation. Current framework support allows route-level choices. Verify initial HTML, metadata and status behaviour without a blanket SEO guarantee.
Does a reusable admin base include every module?
Inspect the actual base and acceptance evidence. User management, analytics, orders, content, payout settings and configuration are requirements to scope, each to be inspected, scoped and accepted for the selected product.
What does white-label delivery mean?
Agree branding, custom-work rights, third-party licences, account access and receiving-team handover in writing. No zero-dependency, absolute IP-safety, NDA deadline or included support period is established here.
How is continuing development arranged?
Choose prioritisation, review, releases, dependency maintenance, incident ownership and cancellation terms around actual capacity. Source retainer figures, assigned team and rapid-response hours are not current offers.
Primary references for the technical checks.
Official React, framework, build-tool and query-library references checked on 17 November 2026. Re-check the supported dependency set, framework rendering features and hosting terms for an actual build; this is not a version certification or performance benchmark.
- Creating a React App | React
- Build a React app from Scratch | React
- Introduction | React
- Server Components | React
- Server and Client Components โ nextjs.org
- Important Defaults โ tanstack.com
- Query Cancellation โ tanstack.com
- use server | React
- Synchronizing with Effects | React
- hydrateRoot | React
- Env Variables and Modes | Vite โ vite.dev
- useMemo | React
- Query Keys โ tanstack.com
- Query Functions โ tanstack.com
- TypeScript โ tanstack.com
Bring the screen and the business rule behind it.
Describe users, records, permitted actions, rendering needs and integrations. Agree evidence, dependencies, testing, migration and handover before implementation.
Discuss your React scope โ