A SaaS dashboard is used all day, so small delays add up quickly. A page that takes four seconds to become usable, or a table that freezes while it filters, makes a product feel unreliable long before users can explain why. Next.js gives you powerful tools to keep dashboards fast, but you have to use them deliberately. This playbook covers the changes that make the biggest difference.
Know the numbers: Core Web Vitals
Google's Core Web Vitals measure the parts of performance that users actually feel:
- LCP (Largest Contentful Paint): how quickly the main content appears. Aim for 2.5 seconds or less.
- INP (Interaction to Next Paint): how quickly the page responds to clicks and taps. Aim for 200 milliseconds or less.
- CLS (Cumulative Layout Shift): how much the layout jumps around while loading. Aim for 0.1 or less.
Measure with Lighthouse for lab data and with real-user monitoring (for example the web-vitals library or your analytics tool) for field data, since real devices and networks behave very differently from your laptop.
1. Do more on the server
With the App Router, components are Server Components by default. They render on the server and send no JavaScript to the browser. Keep data fetching and static layout in Server Components, and mark only truly interactive pieces (charts, filters, modals) with "use client". Less client JavaScript means faster loads and better INP.
2. Stream and use Suspense
Do not make the whole page wait for its slowest query. Wrap slow sections in Suspense with a skeleton fallback so the shell and fast widgets appear immediately while heavier data streams in.
3. Cache deliberately
- Cache data that changes rarely and revalidate it on a schedule or on demand when it changes.
- Use HTTP caching headers and a CDN for static assets.
- Avoid fetching the same data multiple times in one request by sharing a cached data function.
- For dashboards, cache expensive aggregate queries in Redis or a materialised view instead of recalculating on every load.
4. Split your code
Load heavy libraries only when needed. Use next/dynamic for charting libraries, rich text editors and date pickers that are not visible on first paint. Audit your bundle with the bundle analyser and replace oversized dependencies with lighter alternatives.
5. Optimise images and fonts
- Use
next/imagefor automatic resizing, modern formats and lazy loading, and set width and height to prevent layout shift. - Mark the main above-the-fold image with the
priorityproperty. - Use
next/fontto self-host fonts and avoid render-blocking requests and font swap jumps.
6. Make big tables and lists smooth
- Paginate or use cursor-based infinite loading rather than sending thousands of rows.
- Virtualise long lists so only visible rows are rendered.
- Debounce search inputs and use transitions so typing never blocks the interface.
- Memoise expensive calculations and avoid unnecessary re-renders.
7. Fix the backend, too
A fast frontend cannot hide a slow API. Add database indexes for common filters, avoid N+1 queries, return only the fields the screen needs and put slow work into background jobs.
8. Guard performance in CI
Set performance budgets for bundle size and Lighthouse scores, and fail the build when a pull request breaks them. It is far easier to keep a fast app fast than to fix a slow one later.
Conclusion
Start by measuring, fix the biggest bottleneck first and repeat. Server-first rendering, streaming, smart caching and lean client bundles will take most dashboards from sluggish to snappy without a rewrite.
