AI dashboards stress the frontend in ways traditional apps don't - high-frequency streaming updates, dozens of live cells, charts redrawing constantly. We benchmarked SolidJS and React on a real workload to see what actually mattered.
We were rebuilding an analytics dashboard for a logistics client. The brief: real-time fleet telemetry, AI-generated insights streamed in as the underlying data changed and roughly forty live cells on screen at once - each potentially updating multiple times per second during peak operations.
The previous version, in React, struggled. Not at idle - at peak. Frame drops, janky chart redraws, a perceptible lag between the data arriving and the UI reflecting it.
The team was split on the rewrite. React was the safe choice and the team knew it well. SolidJS was the technically interesting choice and was reputed to handle this exact pattern better. We benchmarked properly before committing.
The benchmark was a realistic synthesis, not a microbenchmark. We built the same dashboard twice - same component tree, same data model, same charting library underneath. The only difference was the framework.
The workload simulated production: 40 live data cells, 6 streaming charts, an AI insight panel emitting tokens at 50 per second and a background data pipe pushing roughly 200 cell updates per second across the dashboard. We measured frame timings, interaction latency, memory usage and time-to-first-update.
React's reconciliation model is general-purpose. When state changes, React diffs the virtual DOM, decides what to update and applies it. For most apps, this overhead is invisible. For a dashboard with 200 updates per second hitting components across the tree, the diff cost stops being invisible.
We tried the standard mitigations. Memoisation, fine-grained Context splitting, useSyncExternalStore for the streaming source, pulling charts out into uncontrolled refs to bypass React entirely for that subtree. Each helped. Cumulatively, the dashboard was usable - but the code reading like a defensive crouch around React's defaults rather than a natural expression of the problem.
SolidJS has no virtual DOM. Signals propagate directly to the DOM nodes that depend on them. A cell that depends on signal truckSpeed updates exactly that cell when truckSpeed changes - no diff, no tree walk.
For our workload, this was a material difference.
Frame stability. Under peak load, React dropped to roughly 38 fps with the standard optimisations. SolidJS held steady at 58-60 fps. The dashboard simply felt smoother and the difference was visible without instrumentation.
Interaction latency. Time from click to visible response on a filter change was around 110 ms in React, 35 ms in SolidJS. Both are usable. One feels noticeably more responsive.
Memory. SolidJS held roughly 28% less heap at steady state. Garbage collection pauses were correspondingly less frequent.
Time to first meaningful paint. Roughly equivalent. The framework choice didn't move this metric.
// SolidJS - the cell updates only when truckSpeed signal changes.
function SpeedCell(props) {
return <div>{props.truck.speed()}</div>;
}
// React equivalent - relies on memoisation discipline to avoid
// re-rendering the entire parent when one truck's speed changes.
const SpeedCell = React.memo(({ truck }) => <div>{truck.speed}</div>);
A benchmark only measures what it measures. Two things shaped the decision beyond raw performance.
Library ecosystem. Several niche libraries we needed - one for the specific chart type, one for a third-party widget - had React bindings and no SolidJS equivalent. We could wrap them, but wrapping React components inside SolidJS, while possible, undoes some of the performance benefit.
Team familiarity. Our team was strong on React. Onboarding to SolidJS took roughly two weeks per developer to become fluent. For a six-week project, that's a real cost.
For this client we shipped SolidJS. The performance characteristics matched the workload and the team accepted the onboarding cost.
We would not recommend SolidJS as a default replacement for React. For a CRUD dashboard, a marketing site, or anything that isn't pushing the frontend hard, the differences won't justify the smaller ecosystem.
We would, however, benchmark earlier. Our first instinct was to try harder with React. The harder we tried, the more our code drifted from idiomatic React. A two-day benchmark would have surfaced the framework limit before we'd written a fortnight of workarounds.
SolidJS wins clearly on high-frequency, high-fan-out workloads - exactly the shape of an AI-powered streaming dashboard. React wins on ecosystem and team familiarity. Pick the framework that matches the workload, not the framework that matches the resume.