Heavy DataTables now scroll as smoothly as light ones

Scroll through thousands of rows in a demanding Strato DataTable—now it keeps up with you. Small, simple tables already scrolled smoothly. Now, with @dynatrace/strato-components 3.18, we bring the same smoothness to heavy tables with many columns, rich cell content, or custom cell renderers. Our most demanding test table went from dropping 78% of its frames to just 3%. Every app that uses DataTable gets these improvements as soon as it updates, and without any code changes.
Smooth scrolling through heavy tables
Tables are at the heart of most Dynatrace apps. You scan logs, traces, problems, and entities in them all day, so every slow frame while scrolling adds up. We set out to fix that and measured each change along the way.
One of our toughest tests was a tracing table modeled on the Distributed Tracing app. We used 1,000 rows, and 10,000 rows for the large variant. Here's the tracing table with the improvements in Strato 3.18. Each row shows one step of a request with a duration bar and expandable details. We scrolled with the trackpad, then flicked fast and jumped back to the top:
The video shows a manual trackpad scroll. The numbers below come from the automated benchmark described in How we measured.
Here's how wheel scrolling through the table changed. Lower is better, so each card shows the new value and how much it dropped:
- Frame time (p95): 95 of 100 frames render at or below this time. A 60 Hz display needs a new frame every 16.7 ms. On a 120 Hz display, such as a MacBook Pro, the budget is 8.3 ms, so the less work each frame requires, the more of these faster frames the table can deliver.
- Dropped frames: Frames the browser skipped because it was busy, which makes scrolling look uneven.
- Main-thread blocking: Time the browser can't respond to your input because of long frames.
- Blank area: Share of the table that shows empty space instead of rows while you scroll.
React render time over four scroll interactions fell from 8.39 seconds to 1.29 seconds—85 percent less work for the same rows.
Every heavy table we tested got faster
The gains go beyond the tracing table. We benchmarked six heavy table shapes, from 10,000 rows with 20 columns to 200 columns of plain text. Wheel scrolling improved in all of them.
Dropped frames:
Frame time at the 95th percentile:
React render time while wheel scrolling:
Blank area while scrolling:
Two more changes you'll notice right away:
- Drag the scrollbar and you see rows. When you jump through a large table, the area outside the rendered rows used to stay blank. Now the table paints a row pattern there before React renders, so the mid-jump blank area dropped from 96% to 0%.
- Small tables stay crisp. Tables that render quickly never show skeleton placeholders now, even when you flick through them fast.
What changed under the hood
We made the following changes in small steps and measured each step against the preceding one:
- Skip cell re-renders while scrolling. Cells that are already on screen no longer render again when the table scrolls. React only renders the rows that come into view.
- Lighter cells. We removed wrapper components from each cell, reduced meter bar re-renders after mount, and now mount row drilldowns only when you first open them.
- Rows at named grid lines. Each row places itself on the table's CSS grid by name, so the browser does less layout work per row.
- Placeholders when rows can't keep up. During fast scrolling, rows that can't render in time show placeholder cells until scrolling slows down. This change brought the biggest improvement: dropped frames averaged over four interactions fell from 60% to 3%.
- Placeholders only for slow tables. The table remembers whether it renders slowly, so fast tables show real rows all the time.
- Row pattern extends beyond the rendered rows. The scroll area always looks like a table, even before React catches up.
Some ideas looked promising and didn't survive the benchmark. Fixed row heights made no measurable difference, so we kept rows' flexible height. Fewer overscan rows rendered fewer cells, but left more blank space while scrolling. We shipped a change only when a benchmark proved its value.
Here's how React render time over four scroll interactions dropped with each commit:
Get it in your app
Update to @dynatrace/strato-components 3.18 or later. Your heavy tables get faster with no code changes. For the full list of changes, see the Strato components 3.18.0 changelog.
DataTable only renders the rows you can see when its height is limited. In development, the table now warns you when it renders more than 100 rows because its height isn't limited. Place the table in a container with a definite height to get the full benefit.
What's next
The search for more speed continues. Here's what we'll do next:
- Add a benchmark for how fast
DataTablerenders when it first appears. - Measure
DataTablein development and in production builds and compare the results. - Create an AI skill that checks your app for
DataTableusage that slows tables down, so you can find and fix it early. - Take another look at showing simple cell text instead of placeholders during fast scrolling, as long as it doesn't make scrolling slower.
- And more.
How we measured
We used an automated scroll benchmark built with Playwright, a tool that controls a real browser, on the Strato testing-app and development-app. Each scenario ran three times on the same machine with a 60 Hz display in Chrome. The baseline is the DataTable code from just before these changes, recorded on November 3, 2026.