Categories: SaaS

React Performance Optimization: What to Check Before You Rewrite the Frontend

Published by
Colleen Borator

Edgeport's dashboard was slow before release. Opening the page took too long, search lagged, and the interface stalled. A large dataset arriving from the backend made data volume an obvious suspect.

The team improved the application by changing how the frontend handled that data and loaded its code. They kept the existing frontend and left the API, data structure, and backend caching unchanged.

Yevhenii Bryzhko, Senior Front-End Developer at Merge Rocks, joined the cloud infrastructure SaaS project in its final development stage to help bring it to release. In written answers shared for this article, he explained what the investigation uncovered. The team was already planning to optimize the existing code; a rewrite was never under consideration.

The Large Payload Was Only Part of the Explanation

The dashboard displayed the data as individual cards. He initially suspected that the amount arriving from the backend accounted for the delay. He investigated with Chrome DevTools' Performance and Network panels, alongside Lighthouse and PageSpeed Insights checks.

“The main problem was not the volume of data itself, but the frontend requesting that heavy data again and again without a real need.”

In a follow-up, Yevhenii Bryzhko clarified that repeated component rendering was triggering the extra data requests. Measuring only the time spent rendering the cards would leave out the network work those renders triggered. The relevant question was what each update caused the application to do.

That changed what needed attention. A large response raises a question about how much data the application needs. Repeated requests raise a question about why it keeps asking for that data. Both can make a screen slow, but reducing the size of a response leaves the unnecessary calls to investigate.

The distinction matters before assigning work to the backend team. Seeing a heavy response in the Network panel establishes its size. An engineer still has to follow what triggers it and whether the application needs it again at that point in the task.

The Fix Followed the Repeated Work

The team used memoization to reduce the unnecessary component rendering. Reducing those renders, he explained, also helped with the repeated calls. They also split the JavaScript bundle so that someone opening the dashboard would not have to load code they did not yet need.

“We did not change the API, the data structure, or backend caching. All the changes were on the frontend.”

Memoization and code splitting addressed different costs. One helped the team avoid repeated work during updates. The other changed when parts of the application's code had to load. Together, the changes addressed the way the existing frontend used its resources.

React's memo documentation describes skipping component re-renders when props are unchanged. Whether that also avoids requests depends on how the application triggers them; memoization is not a general-purpose request cache.

His published React performance optimization guide explains how to move from a reported symptom to a measurement and a suitable fix. Edgeport adds a concrete reason to follow that order: the first plausible explanation did not identify all the work responsible for the delay.

Check the Task That Was Slow

The team compared dashboard loading and search before and after the changes. He reports a noticeably faster dashboard and higher Lighthouse and PageSpeed Insights scores, without exact timings or score values. The changes were checked together, so that result describes the combined work.

These were pre-release checks. The team could address the problem before real users encountered it, using the actions that had exposed the delay during development.

For a team checking its own application, the task needs to remain visible alongside the score. If search was slow, a better loading report still leaves the search interaction to verify. Someone needs to enter a query, see when the results are ready, and open the item they were looking for.

The team also needs to record the conditions of the comparison. A small test account on a fast laptop can hide work that appears in a larger account. First entry and repeat visits can behave differently because code or data is already cached. Recording those conditions makes the result useful to the next engineer who has to check whether the delay has returned.

A Broader Change Needs a Specific Reason

Yevhenii Bryzhko would consider substantial refactoring or replacement when code becomes difficult to read, optimize, and scale, with each new optimization adding another patch. The next step is to identify what in the structure makes a limited intervention insufficient.

At Edgeport, the team could locate unnecessary renders and calls. Excess JavaScript was also something they could address through code splitting. A heavy download therefore gave them a problem to investigate without establishing that the whole frontend needed replacing.

With a diagnosis, a team can decide whether front-end development work can stay within the existing application or needs changes to the systems it connects to. An API that cannot supply the required data would create a different job from removing avoidable browser activity. The proposal should explain which situation the engineers have found.

Other reasons for replacement can stand on their own. Unsupported dependencies or required features that the architecture makes difficult to deliver deserve consideration, even when they are not the cause of a slow screen. Naming those reasons lets the business assess what the proposed work is meant to achieve.

If a replacement prototype is part of that decision, it needs to face the relevant workload. Fewer records, missing editing behavior, or omitted permission rules can make a demo easier to run. A changed API may be a valid part of the solution, but its implementation belongs in the scope too.

Before approving a rewrite to fix performance, the product lead should be able to name the delay it removes and the constraint that prevented a smaller fix.

React Performance Optimization: What to Check Before You Rewrite the Frontend was last updated November 19th, 2026 by Colleen Borator
React Performance Optimization: What to Check Before You Rewrite the Frontend was last modified: November 19th, 2026 by Colleen Borator
Colleen Borator

Disqus Comments Loading...

Recent Posts

How to Build a Small Business Website That Actually Helps You Sell

You can have a great product, solid service, and loyal customers, then still lose sales…

2 minutes ago

Top 10 SEO Consultants in London for Content Outreach and Link Earning

Before commissioning a piece of content for outreach, consider the editor who might receive it.…

7 minutes ago

Why a Pregnancy Pillow Becomes Non-Negotiable in the Third Trimester

Somewhere around week thirty, sleep stops being something you do and becomes something you negotiate.…

12 minutes ago

Small Businesses Are Replacing Break-fix Tech Repairs With Proactive Network Care

Rather than waiting for server crashes or phishing breaches to stall operations, suburban companies are…

32 minutes ago

8 Best No-Code Email List Cleaning Tools for Marketers in 2026

A single campaign sent to a stale list can undo months of sender reputation, and…

41 minutes ago

Exploring the Benefits of IPTV for Modern Digital Entertainment

The entertainment industry has experienced a remarkable transformation over the past few years. Traditional television…

1 day ago