The honest answer
Our Striveloom homepage went from a mobile Lighthouse performance score of 58 to 95 in six weeks. Total page weight dropped from 890KB to 230KB. LCP went from 4.3 seconds to 1.7 seconds on mobile. These are our actual PageSpeed Insights field data numbers, not lab simulations.
The changes were not exotic. No CDN rewrite. No edge computing. No server-side rendering changes. The gains came from using Next.js features we were already paying for but not using correctly, auditing and removing JavaScript that was adding weight without adding value, and fixing two image problems that were the primary cause of the LCP failure.
Here is exactly what we did, in the order we did it.
The Starting Point
Before any changes, our mobile metrics were:
- Lighthouse Performance: 58
- LCP: 4.3 seconds
- CLS: 0.22
- INP: 310ms
- Total page weight: 890KB
- JavaScript bundle: 540KB
These are genuinely bad numbers for a homepage that is supposed to be a selling tool. A 4.3-second LCP on mobile means most users on an average mobile connection are waiting over four seconds before they see the main content of the page. Core Web Vitals research from web.dev suggests that every second of load time increase correlates with measurable bounce rate increases.
The 58 Lighthouse score put us in the "Needs Improvement" category across every Core Web Vitals metric. Google's field data assessment uses real user data from Chrome users, which means these numbers were affecting our actual search performance, not just a synthetic test.
The Build Configuration Changes
We made changes in three categories: images, JavaScript, and fonts. Here is the before and after for each:
| Category | Before | After | Change Made |
|---|---|---|---|
| Hero image format | 1.8MB PNG | 42KB WebP | next/image with quality={80} |
| Hero image loading | No lazy loading | Eager + priority prop | next/image priority flag |
| Hero image dimensions | No width/height | Explicit 1200x630 | Fixed CLS to 0.02 |
| JavaScript bundle | 540KB | 198KB | Removed 3 analytics scripts |
| Font loading | @import in CSS | next/font with preload | Eliminated render block |
| Third-party scripts | 4 (inline loaded) | 1 (strategy="lazyOnload") | Next.js Script component |
| Total page weight | 890KB | 230KB | All of the above |
Image optimization: the biggest win
The hero image was a 1.8MB PNG loaded with a standard HTML img tag. No compression. No format conversion. No size attributes. It was causing the LCP failure almost entirely on its own.
We replaced it with the Next.js Image component (next/image). This component automatically serves WebP to browsers that support it, generates multiple sizes for responsive delivery, and prevents layout shift through the required width and height props. We set quality={80}, which produced a 42KB WebP that is visually indistinguishable from the original on any device we tested.
We also added the priority prop to the hero image. This tells Next.js to preload the image during the initial document fetch rather than waiting for the JavaScript runtime to process the component tree. LCP for the hero image dropped from 4.3 seconds to 1.7 seconds with just these two changes.
Below-the-fold images got the standard lazy loading behavior, which is the Next.js Image default. No additional configuration needed.
JavaScript: the hard conversation
Our 540KB JavaScript bundle included:
- Next.js framework code: ~85KB (unavoidable)
- Application code: ~175KB (necessary)
- Three analytics and heatmap scripts: ~280KB (removable)
We were running Google Analytics 4, a heatmap tool, and a live chat widget simultaneously. All three were loading synchronously in the document head, blocking rendering. None of them were being actively used by the team for any decision-making. The heatmap tool had not been checked in four months. The live chat widget was generating two conversations per month at a cost of $79/month and adding 140KB to every page load.
We removed all three. We added back Google Analytics 4 using Next.js Script component with strategy="lazyOnload", which delays loading until after the page is interactive. The heatmap tool was not re-added. The live chat widget was not re-added.
JavaScript bundle went from 540KB to 198KB. INP dropped from 310ms to 87ms.
This is the hard conversation most performance optimization projects avoid: the fastest JavaScript is the JavaScript you do not ship. That requires removing tools, which requires stakeholder agreement that those tools were not delivering value. In our case, the data was clear. We ran three months without the heatmap and saw no loss of insight we could measure.
Font optimization
We were loading our brand font using @import in a global CSS file. This is a render-blocking operation: the browser cannot render text until the font file downloads. We were serving fonts from a Google Fonts CDN URL, which meant an external DNS lookup was also required before the font bytes started transferring.
We switched to next/font/google, which is Next.js's built-in font optimization system. It downloads the font at build time, serves it from the same domain as the application (eliminating the external DNS lookup), and generates a size-adjust fallback font so text renders immediately with the system font while the brand font loads. No visible flash. No layout shift.
This change eliminated the render-blocking CSS import and reduced font-related page weight by 18KB. The improvement on Lighthouse's "Eliminate render-blocking resources" audit was immediate.
The JavaScript Tradeoffs We Made
Being specific about what we kept and what we removed is important here, because performance optimization without product tradeoffs is not realistic advice.
We kept:
- Google Analytics 4 (loaded lazily after page interactive)
- Our form library (necessary for the contact form)
- Our animation library, but only imported on the pages that use animations (route-level code splitting)
We removed:
- The heatmap tool entirely
- The live chat widget
- A social proof notification widget that was adding 34KB and displaying popups we found annoying as users ourselves
We also moved three large components to dynamic imports so they only load when the route that uses them loads. Our team page was importing a mapping library on every page because it was in the global component tree. Moving it to a dynamic import with next/dynamic reduced the homepage bundle by 28KB.
The CLS fix
Our CLS of 0.22 came from two sources: the hero image with no width/height attributes (content shifted down when the image loaded), and a promotional banner that loaded after the initial paint (pushing the navigation down by 48px).
The image fix: adding width and height to the Next.js Image component, which reserves space before the image loads.
The banner fix: rendering the banner on the server with a fixed height container so the space is reserved in the HTML rather than created by JavaScript after load.
CLS dropped to 0.02.
The results
Six weeks of focused work:
- Mobile Lighthouse Performance: 58 to 95
- LCP: 4.3s to 1.7s
- CLS: 0.22 to 0.02
- INP: 310ms to 87ms
- Total page weight: 890KB to 230KB
- JavaScript bundle: 540KB to 198KB
Our Core Web Vitals assessment in Search Console moved from "Failing" to "Passing" within 28 days of the field data updating. Organic impressions on the homepage improved by 23% in the following 60 days. We cannot attribute all of that to Core Web Vitals directly — we made other SEO changes in the same period — but the correlation is consistent with what the research suggests about performance as a ranking signal.
What this means in practice
Most Next.js sites have the same four problems we had:
- An unoptimized hero image in a standard img tag
- Third-party scripts loading synchronously in the document head
- Google Fonts loaded via @import rather than next/font
- No audit of what is in the JavaScript bundle or why
Fixing all four is achievable in a single sprint using only built-in Next.js features. No new infrastructure. No new dependencies. The main cost is the conversation about removing tools that add weight.
If you want help running this audit on your site, our web development team does performance audits and Core Web Vitals remediation for Next.js and other modern stacks. The 230KB homepage is also the one you're looking at right now — the browser dev tools are open to anyone who wants to verify the numbers.
