Skip to content
CasePerformance

Lighthouse from 90 to 100: what a perfect score takes

What does it take to score 100 in Lighthouse? How performance affects Google Ads costs, rankings and conversion, and what 100/100/100/100 requires.

Christian GangestadSenior full-stack developer at PXL
Published
Updated
Reading time
18 min
lowest score among the sites we tested
39
none of the major Norwegian sites scored higher
< 75
CLS fails, 0.10 passes
0.11
contrast fails, 4.5:1 passes
4.49:1

In short

  • None of the heavily visited Norwegian websites we tested in Google Lighthouse scored above 75, and one of the largest online shops scored just 39.
  • Faster pages give a better landing page experience in Google Ads, keep more visitors and sell more. In 2026 Shopify found that conversion is about 3.5% lower for every 100 ms slower a store loads.
  • Going from 90 to 100 takes stable layouts, no render-blocking resources, accessibility that works and good performance on slow phones.

The starting point

For this case study, we ran Google Lighthouse on some of Norway's most-visited websites: online newspapers, marketplaces, online shops and IT consultancies. The results were worse than we expected.

None of the sites we tested scored above 75 on performance. The weakest, one of Norway's largest online shops, scored 39. That's especially bad for an online shop, because even small delays lower conversion and make more visitors leave straight away.

In the industry, a Lighthouse score of 90 counts as excellent. Everything looks green, and the project is usually signed off as finished. When even the largest sites in Norway don't reach 75, many businesses are probably underestimating the impact or not prioritising performance at all.

This case study looks at what it takes to go from 90 to 100/100/100/100, and why the last 10 points give you a lead that most sites overlook.

Lighthouse reportmobile
  • 87Performancebefore
  • 91Accessibilitybefore
  • 91Best Practicesbefore
  • 96SEObefore
Failing audits: 4
  • Images without width and heightCLS
  • Render-blocking CSS and JavaScriptPerformance
  • Text contrast below 4.5:1Accessibility
  • Links without descriptive textSEO

The last 10 points are where the difference shows in ad costs, rankings and sales.

Switch between before and after to see which audits held the score back.

Why performance matters for your business

Developers read Lighthouse scores, but the numbers affect the business directly: what you pay for ads, how well you rank in search and how many visitors become customers.

Google Ads judges ad quality on three components: expected click-through rate, ad relevance and landing page experience. Quality Score shows how you're doing on these, but Google itself says the score is a diagnostic tool rather than an input to the auction (Google Ads Help). Ad Rank is what decides, and it combines your bid with quality as measured in each auction, landing page experience included (Google Ads Help).

Landing page experience is about how relevant and useful the page is to the person who clicks. Google writes that faster landing pages are one of the easiest ways to get better results from mobile ads (Google Ads Help). In February 2025, Google introduced a new model that shows fewer ads when the landing page doesn't give visitors what they expect (Search Engine Journal, 2025).

Higher quality often leads to a lower cost per click, Google says, without giving numbers (Google Ads Help). The agency Lubble went through 183,000 exact-match clicks in 2023 and found CPC fell by about 21% on average for each point Quality Score rose. The dataset is small, and the link was weaker on broad match (Lubble, 2023).

If you spend tens of thousands of kroner on ads every month, even a small jump in quality adds up.

Organic SEO and user engagement

Load time decides whether visitors stay at all. If the content doesn't appear quickly enough, many leave before they've seen anything:

  • Contentsquare analysed 90 billion sessions on 6,000 sites and found slow-loading content was a key reason 53% of visitors left after viewing a single page (Contentsquare, 2025). A year later, slow loading still affected one session in ten (Contentsquare, 2026). Contentsquare sells tools for measuring this.
  • The Economic Times cut Total Blocking Time from 3.3 seconds to 0.1 seconds and INP from about 1 second to 257 ms. Bounce rate fell by 50%, and page views rose by 43% (web.dev, 2023).
  • Rakuten 24 saw 35% fewer visitors exit in an A/B test where only performance changed (web.dev, 2022).

Core Web Vitals are used by Google's ranking systems, but relevance comes first: Google shows the most relevant content even if the page experience is poor (Google Search Central). Google's John Mueller said in 2024 that Core Web Vitals aren't a giant ranking factor (Search Engine Journal, 2024). Bounce rate from Google Analytics isn't used for ranking either. The value of performance in search lies mostly in what visitors do after they click.

Conversion rates

Page speed affects how many visitors become customers:

  • Shopify analysed its stores in 2026 and found that conversion tends to be about 3.5% lower for every 100 ms slower a store loads. Shopify stresses that this is a correlation and doesn't prove cause (Shopify, 2026).
  • Yottaa analysed over 500 million visits to 1,300 online stores. One second faster loading gave 3% more mobile conversions, and 63% of shoppers abandoned pages that took more than 4 seconds (Yottaa, 2025). Yottaa sells performance tools.
  • Google and Deloitte compared 37 brands and over 30 million user sessions. A 0.1-second faster mobile load gave 8.4% more conversions and 9.2% higher order value in retail (Milliseconds Make Millions, 2020).

Case studies show the same:

  • Ray-Ban cut LCP by 43% by prerendering pages and doubled mobile conversion in an A/B test (web.dev, 2025).
  • Rakuten 24 saw 53% higher revenue per visitor and 33% higher conversion in the same A/B test as above (web.dev, 2022).
  • QuintoAndar cut INP by 80% and saw 36% more conversions over a year, though it says performance wasn't the only cause (web.dev, 2025).
  • Nuvemshop improved LCP by 68% and saw 8.9% higher mobile conversion from organic search (web.dev, 2026).

The effect is largest on mobile, where most visits come from. Phone processors are far weaker than a PC's, so JavaScript takes much longer to run. Lighthouse simulates this with a 4x CPU slowdown for mobile (Lighthouse). Reality is often worse: budget Android phones are up to 9x slower per CPU core than current iPhones, and mid-range phones more than 3.5x slower (Alex Russell, 2025).

The competitive opportunity

Very few Norwegian websites optimise for performance. We've worked with clients who spent thousands of consultant hours on UX without treating performance as part of the user experience.

When the typical Norwegian website scores 60–70 and the best reach 90, getting to 100 gives you a clear lead. Your pages load faster, rank better, cost less to advertise and convert more visitors.

A perfect score in every category isn't always necessary. What counts is staying ahead of your competitors, consistently. In practice that means at least 90 for performance and 100 for accessibility, best practices and SEO.

Many teams stop once the results look good enough, the project is delivered and everyone moves on. That's when the lead disappears.

What Lighthouse actually measures

Google Lighthouse evaluates your site in four categories. Together they give a good picture of user experience and technical quality.

Performance

The Performance score measures how quickly your page loads and becomes usable. It's calculated from five weighted metrics, and the weights are unchanged in Lighthouse 13 (Lighthouse docs):

Metric Weight
Total Blocking Time (TBT) 30%
Largest Contentful Paint (LCP) 25%
Cumulative Layout Shift (CLS) 25%
First Contentful Paint (FCP) 10%
Speed Index 10%
Metric What it measures Good Poor
LCP
Largest Contentful Paint
When the largest visible element is in place ≤ 2.5 s > 4 s
INP
Interaction to Next Paint
How quickly the page responds to clicks, taps and key presses ≤ 200 ms > 500 ms
CLS
Cumulative Layout Shift
How much content shifts unexpectedly ≤ 0.1 > 0.25
FCP
First Contentful Paint
When the first content appears ≤ 1.8 s > 3 s

LCP, INP and CLS are the Core Web Vitals, and Google assesses them at the 75th percentile of real visits (web.dev). INP replaced First Input Delay on 12 March 2024 (web.dev). In lab tests, Lighthouse uses Total Blocking Time (TBT) instead, because INP can only be measured when real users interact with the page.

The scoring curves are based on real sites in HTTP Archive. A metric value as good as the best 8% of sites scores 90 (Lighthouse docs). In July 2025, 48% of sites passed all three Core Web Vitals on mobile and 56% on desktop (Web Almanac 2025).

Accessibility

Accessibility checks whether everyone can use your site, including people who rely on a screen reader or keyboard, or who have impaired vision or motor skills.

Lighthouse uses the axe-core library for automated accessibility testing. How much automated tests find depends on whom you ask. Deque, which makes axe-core, says they cover 57% of issues by volume (Deque), while the UK government's accessibility team puts it at 30–40% (GOV.UK, 2025). A score of 100 means you've passed the automated checks. Finding the rest takes manual testing with a real screen reader and keyboard.

Lighthouse checks image alt text, colour contrast, form labels, ARIA attributes, heading structure, visible focus indicators and tap target sizes, among other things.

Best Practices

Best Practices covers security and general technical quality, and catches problems that make a site harder to maintain later. It checks HTTPS, console errors, image aspect ratios and valid source maps, among other things.

SEO

SEO checks that search engines can crawl, index and understand your content. Lighthouse looks at the page title, meta description, robots.txt, canonical, hreflang, alt text and descriptive link text. Viewport and font size are no longer part of the SEO category (Lighthouse 13).

A Lighthouse SEO score of 100 doesn't guarantee good rankings. It confirms that the technical foundations are in place so search engines can do their job.

Core Web Vitals75th percentileGoodNeeds improvementPoor
  • LCPLargest Contentful Paint

    How quickly the main content becomes visible.

    Common cause:large imagesrender-blocking CSS
  • INPInteraction to Next Paint

    How quickly the page responds to interactions.

    Common cause:heavy JavaScriptlong tasks
  • CLSCumulative Layout Shift

    How much the layout shifts unexpectedly.

    Common cause:images without dimensionsfont swaps
Google assesses Core Web Vitals at the 75th percentile of real visits. In the lab, Lighthouse uses Total Blocking Time instead of INP.

The difference between 90 and 100

Getting to 90 is fairly straightforward. A current framework, basic image compression and lazy loading will usually get you there. The scores turn green, and the project can be signed off.

Getting to 100 is a different job. The last 10 points require control over details that are easy to miss:

  • Layout stability at every viewport size, including the ones you don't test on your own machine. A CLS of 0.11 fails and 0.10 passes. That margin leaves no room for the one Android phone where the font loads slightly differently.

  • No render-blocking resources. Lighthouse penalises any CSS or JavaScript that holds back the first paint. In practice that means inlining critical CSS and deferring everything else.

  • Accessibility that works: correct ARIA roles, a logical focus order and sufficient contrast. The 4.5:1 ratio for text isn't a suggestion, and 4.49:1 fails the audit.

  • No unused JavaScript or CSS shipped to users. Every kilobyte counts, so bundle analysis and tree-shaking stop being optional.

  • Consistent performance on slow phones. Your site has to work on a four-year-old budget Android phone with poor mobile coverage. A MacBook Pro on fibre tells you little about what your users experience.

Together, these decide whether real users get a good experience outside the demo as well.

Performance: 90 to 100

Getting from good to the very top means working on three areas: images, JavaScript and the critical rendering path, meaning what the browser needs to show the page the first time.

Image optimisation

Images are often the heaviest part of a page, and on many sites they account for more transferred bytes than anything else. The fix is to provide several sizes and let the browser pick the one that suits the screen.

image-optimization.html
<!-- Before: Single image, no optimisation -->
<img src="hero.jpg" alt="Hero image">
<!-- After: Responsive with reserved space -->
<img
src="hero.jpg"
srcset="
hero-400.webp 400w,
hero-800.webp 800w,
hero-1200.webp 1200w
"
sizes="(max-width: 640px) 100vw, 1200px"
width="1200"
height="675"
alt="Hero image"
fetchpriority="high"
decoding="async"
/>
● Before and after: image optimisationHTMLUTF-8LF

The first example loads a single large image regardless of device: a 1200px image on a 400px mobile screen wastes bandwidth and delays LCP. The second provides several sizes and states the dimensions, so the layout doesn't jump.

The width and height attributes matter for CLS: they let the browser reserve space before the image loads. Without them, content shifts when the image appears. The hero image is often the LCP element, so it shouldn't be lazy-loaded; set fetchpriority to high instead.

Newer image formats make a big difference. WebP gives 25–34% smaller files than JPEG at the same quality (Google). AVIF often saves more than 50% compared with JPEG and is usually clearly smaller than WebP, though encoding is slower (web.dev). AVIF is now supported by about 95% of browsers (caniuse), yet only 1% of mobile images are AVIF and 12% WebP (Web Almanac 2024).

For images above the fold, especially LCP candidates, avoid loading="lazy", since it delays them. For everything below the fold, lazy loading reduces the initial page weight.

Code splitting

Load JavaScript only when it's needed. Components that aren't visible on the first view should be lazy-loaded. That matters because JavaScript costs you twice: once to download and again to run.

On mobile, running the JavaScript is often the bottleneck. The median mobile page ships 632 KB of JavaScript (Web Almanac 2025), and 44% of the JavaScript loaded on mobile is never used (Web Almanac 2024). And it's getting worse. According to Web Almanac 2025, mobile pages at the 75th percentile have over 4 seconds of Total Blocking Time, and around 7.5 seconds at the 90th, up from 3 and 6 seconds the year before (HTTP Archive).

Dashboard.tsx
import { lazy, Suspense } from 'react';
const HeavyChart = lazy(() => import('./components/HeavyChart'));
function Dashboard() {
return (
<Suspense fallback={<ChartSkeleton />}>
<HeavyChart data={chartData} />
</Suspense>
);
}
● Dynamic importsTSXUTF-8LF

Heavy components load on demand instead of blocking the initial render. The Suspense boundary shows a lightweight skeleton while the component loads, and the rest of the page stays usable.

The pattern suits features users might not touch straight away: charts, complex forms, modals and content below the fold.

Server-side rendering

With server-side rendering (SSR), the initial HTML arrives fully rendered. Users see content straight away instead of a blank screen while JavaScript loads. That improves both First Contentful Paint and Largest Contentful Paint.

The trade-off is server processing time and the added complexity of hydration. The server has to render the page before sending it, and the browser then has to "hydrate" the HTML with JavaScript to make it interactive. When server and client agree on what to show, you get fast first content and full interactivity. When they don't, you get layout shifts during hydration or pages that look ready but don't respond.

Critical CSS

Putting the styles for above-the-fold content directly in the HTML removes render-blocking CSS requests. The browser can paint the first view without waiting for external stylesheets.

You need to work out which styles the first view needs and inline only those. The rest of the CSS loads asynchronously. Tools like Critical and Critters automate the extraction, and the principle is simple: users shouldn't wait for CSS they don't need yet.

Font loading

Custom fonts can cause invisible text (FOIT) or layout shifts (FOUT) if they aren't loaded carefully. This is how we load them:

  1. Preload critical fonts, so the browser fetches them early
  2. Use font-display: swap, so text shows in a fallback font straight away and swaps when the font has loaded
  3. Use WOFF2, which compresses better and is supported by all current browsers
  4. Subset fonts to include only the characters the site uses

Resource hints

preconnect opens connections early to domains you'll need, so the DNS lookup, TCP handshake and TLS negotiation are out of the way before the resource is requested. Use it for CDNs, font providers and API endpoints.

preload fetches resources you know you'll need early but that the browser would otherwise discover late, such as fonts referenced only in CSS. Use it sparingly: too many preloads compete with what matters most for the first view.

Accessibility: 91 to 100

In Norway, universal design of websites is required by law under the Equality and Anti-Discrimination Act and the regulation on universal design of ICT. Private businesses must meet WCAG 2.0 Levels A and AA, except three requirements about video. Public bodies have had to meet WCAG 2.1 since February 2023. The Norwegian Authority for Universal Design of ICT can order fixes and then impose coercive fines (Uu-tilsynet).

The European Accessibility Act (EAA) has applied in the EU since 28 June 2025 (EUR-Lex). It covers products and services such as e-commerce, banking and transport. Only microenterprises providing services are exempt, meaning fewer than 10 employees and no more than €2 million in turnover or balance sheet. Norway's implementation is delayed, but it will come through the EEA Agreement (Uu-tilsynet). The technical standard is EN 301 549, which currently references WCAG 2.1 Level AA.

WCAG 2.2, published in October 2023, is the current W3C standard. It adds 9 new success criteria compared with 2.1, 6 of them at Levels A and AA, including requirements for focus visibility, target size and accessible authentication (W3C). If you aim for WCAG 2.2 Level AA, you cover both today's requirements and what's coming.

Compliance aside, accessible sites work better for everyone, including people on phones, on slow connections or standing in bright sunlight.

What Lighthouse 100 requires

Lighthouse tests only what can be tested automatically. You have to pass those tests to get a full score, but passing them doesn't make a site fully accessible. Manual testing with a screen reader and keyboard is needed to find the rest.

Most sites already fail the automated tests. WebAIM found WCAG failures on 95.9% of the top one million home pages in 2026, with 56 errors per page on average. The most common was low contrast, on 83.9% of pages (WebAIM Million, 2026).

navigation.html
<nav aria-label="Main navigation">
<ul>
<li><a href="/services">Services</a></li>
<li>
<button
aria-expanded="false"
aria-controls="about-menu"
>
About
</button>
<ul id="about-menu" hidden>
<li><a href="/who-we-are">Who we are</a></li>
<li><a href="/contact">Contact</a></li>
</ul>
</li>
</ul>
</nav>
● Semantic navigation with a submenuHTMLUTF-8LF

Start with semantic HTML, and add ARIA only where HTML falls short. The navigation uses <nav> with aria-label, plain lists and links, and a button that opens the submenu.

aria-expanded tells screen readers whether the submenu is open, and aria-controls points to the list the button controls. The menubar and menuitem roles are meant for application menus rather than website navigation, and they give keyboard users behaviour they don't expect.

Colour contrast

WCAG AA sets specific contrast ratios between text and background:

  • Normal text (smaller than 18pt or 14pt bold): 4.5:1 minimum
  • Large text (18pt/24px or larger, or 14pt/18.5px bold): 3:1 minimum
  • UI components and graphics: 3:1 minimum

These are hard thresholds. 4.49:1 doesn't meet the 4.5:1 requirement, and W3C states that the values must not be rounded (W3C). The ratios compensate for loss of contrast sensitivity equivalent to 20/40 vision, which is typical at around age 80.

Good contrast makes text easier for everyone to read, on a phone screen in sunlight, a cheap monitor with poor colour reproduction or with tired eyes at the end of a long day.

Focus management

Every interactive element needs a visible focus indicator, and the tab order should follow the reading order. Keyboard users depend on both.

WCAG 2.2 adds two specific requirements: focused elements can't be completely hidden by other content (2.4.11 Focus Not Obscured), and interactive targets must be at least 24×24 CSS pixels (2.5.8 Target Size Minimum).

Screen reader support

Screen readers don't see the visual layout; they navigate by the document's structure. A correct heading hierarchy from <h1> to <h6> gives the content that structure. Landmark regions (<header>, <nav>, <main>, <footer>) let screen reader users jump straight to the section they want. Link text should say where the link goes: "Read the full report" works on its own, "click here" doesn't.

Good screen reader support is mostly a matter of using HTML the way it was meant to be used.

Motion sensitivity

Some people get nauseous or uncomfortable from animation, particularly those with vestibular disorders. Respect the prefers-reduced-motion setting: when it's on, reduce animations sharply or remove them. For everyone else, keep animations subtle.

SEO and best practices

These categories catch technical faults that often go unnoticed at first but get worse the longer they're left.

SEO fundamentals

Heading hierarchy: use one <h1> as the main page heading, with a logical <h2>/<h3> structure below it. Google says there is no ideal number of headings and that their order doesn't matter for Search (Google Search Central), but a clear hierarchy helps both users and search engines understand content structure.

Metadata: every page needs a unique title (50–60 characters, so it isn't truncated) and description (150–160 characters for desktop, with the key information first for mobile). Meta descriptions aren't a ranking factor, but they affect click-through rates. If a description doesn't match the query, Google often rewrites it.

Canonical URLs: every indexable page should have a self-referencing canonical with an absolute URL. Common mistakes are canonicals that point to 404 pages, content that doesn't match between the canonical and the actual page, and multiple canonical tags on one page, which causes all of them to be ignored.

Mobile-first indexing: since July 2024, Google crawls sites with Googlebot Smartphone and indexes the mobile version (Google Search Central). Content missing from the mobile version isn't indexed. Mobile and desktop need identical content, meta tags, structured data and headings.

Structured data: use JSON-LD for rich results. Common types are Article, Product, Event, Organization and LocalBusiness. FAQ rich results are no longer shown in Google Search. Google limited them to government and health sites in August 2023 and stopped showing them in May 2026 (Google Search Central).

Clean robots.txt and up-to-date sitemap: the sitemap should only include canonical URLs. Remember that robots.txt blocks crawling rather than indexing, so to keep a page out of search you need noindex.

Best practices

All resources over HTTPS: mixed content warnings hurt both actual security and how secure the site looks to visitors.

No deprecated APIs or console errors: browsers retire APIs, and code that relies on them eventually breaks.

Images at their natural aspect ratio: stretched or squashed images fail this audit.

Valid source maps: they let you debug production issues without exposing unminified code.

Sites with clean technical foundations age better. Browser updates don't break features, security scanners find less, and technical debt builds up more slowly.

The technology stack

Optimisation techniques only get you so far. The framework, rendering strategy and hosting you choose early on decide what's possible, long before anyone starts optimising.

A stack built for performance might include:

  • Server-side rendering for a fast first view
  • React or similar with code splitting for interactive features
  • Edge hosting to cut latency wherever users are
  • Build-time optimisation of CSS, JavaScript and images
  • Type-safe languages (TypeScript) that catch errors before production
GET /pxl.no
  1. 1Cloudflare
    CDNHIT

    Edge CDN wrapping the whole stack: caching, compression and security.

  2. 2Laravel
    BackendSkipped

    Routing, API and server logic.

  3. 3Inertia.js
    BridgeSkipped

    Connects Laravel routing to the React components.

  4. 4React SSR
    FrontendSkipped

    The page is rendered to finished HTML on the server.

Served from the edgeFinished HTML comes from the nearest Cloudflare node.BrotliHTTP/3
Choose whether the page comes from the cache or has to be rendered again.

CDN configuration: what actually helps

A CDN can make a site much faster, or quietly make it slower if it's set up wrong. Many assume that switching on Cloudflare solves performance problems by itself. In practice it depends on which features you turn on.

Features to disable

Rocket Loader defers JavaScript by rewriting your HTML. Cloudflare itself recommends disabling it if JavaScript misbehaves (Cloudflare). We've seen it break hydration, cause visible layout shifts and stop features working in server-rendered applications, especially React and Next.js. If you're using SSR, turn Rocket Loader off.

Auto Minify was deprecated in August 2024 (Cloudflare). It added nothing if your build pipeline already minifies (it should), and it could break source maps and Subresource Integrity hashes. Cloudflare recommends minifying at build time instead.

Mirage, which lazy-loaded images by injecting JavaScript, was deprecated in November 2025 (Cloudflare). Native loading="lazy" does the same without the extra script.

Features to enable

Brotli compression gives roughly 15–20% smaller files than gzip for HTML, CSS and JavaScript (Cloudflare, 2024), so enable it wherever you can. Zstandard (zstd) compresses slightly less but faster, which suits responses that are generated on every request. The share of zstd at CDNs rose from 3% to 12% between 2024 and 2025 (Web Almanac 2025).

HTTP/3 connects faster and handles packet loss better than earlier versions, especially on mobile networks. Cloudflare measured connections at the 95th percentile as 116 ms faster with HTTP/3 than with HTTP/2 (Cloudflare, 2024).

Early Hints (HTTP 103) lets browsers start loading resources before the server finishes generating the response. While your server runs database queries and renders templates, the CDN sends hints about the CSS, fonts and other resources the browser will need. Cloudflare measured a 6% better median LCP on desktop, and Shopify saw LCP over 500 ms faster (Cloudflare, 2022).

Aggressive caching for versioned static assets (files with a hash in the name), and no caching for dynamic content. Versioned files can be cached indefinitely, because the filename changes whenever the file does.

A well-configured CDN speeds up delivery and leaves code you've already optimised alone.

SpeedCloudflareRecommended for SSR apps
Keep off
Rocket LoaderOff

Rewrites the HTML and causes hydration errors and layout shifts in SSR apps.

Auto MinifyOff

Minification belongs in the build step, not in the CDN.

Worth enabling
BrotliOn

Smaller HTML, CSS and JavaScript than gzip.

HTTP/3On

Faster connections and better tolerance for packet loss on mobile networks.

Early HintsOn

The browser fetches CSS and fonts while the server is still rendering.

Cache for static filesOn

Files with versioned names can be cached for a year.

Key takeaways

For marketing: Landing page experience is part of the quality Google Ads measures in every auction, and higher quality often means a lower cost per click. Faster pages also keep more visitors and sell more, so the same budget goes further.

For technical teams: The last 10 points come from consistency and attention to edge cases. Heroic work on one metric won't get you there, because every metric has to pass for every user on every device. A CLS of 0.11 fails, and so does a contrast ratio of 4.49:1. The margins really are that thin.

For management: Most Norwegian websites score 60–70, so there's a clear lead to be had for those who prioritise performance. Accessibility is already a legal requirement in Norway, and the authorities can impose fines when it isn't met. Better performance can pay for itself through lower ad costs, better rankings, higher conversion and less legal risk.

Sources and further reading

Frequently asked questions

What is a good Lighthouse score?

A score of 90 or higher counts as good. If your site depends on search, advertising or conversion, it can pay to go further. The last points are less about the number itself and more about stable performance on every device.

Why do Core Web Vitals matter for SEO?

Google uses Core Web Vitals in its ranking systems, but relevant content weighs more. The bigger gain is in what visitors do after the click: with fast pages, fewer people leave straight away and more of them buy. In 2025, only 48% of sites passed all three Core Web Vitals on mobile.

What does poor performance cost in Google Ads?

Landing page experience is part of the quality Google Ads measures in every auction, and Google says higher quality often means a lower cost per click. Google gives no figures, but a 2023 dataset showed about 21% lower CPC per Quality Score point on exact match. Fast landing pages also convert better, so the ad budget goes further.

Is WCAG accessibility a legal requirement in Norway?

Yes. Norwegian law requires private websites to meet WCAG 2.0 Levels A and AA, and public bodies to meet WCAG 2.1. The European Accessibility Act has applied in the EU since June 2025 and is to be adopted in Norway through the EEA Agreement. The Norwegian Authority for Universal Design of ICT can issue orders and coercive fines when the requirements are not met.

How long does it take to improve performance?

It depends on how complex the site is and what technical state it's in. Simple improvements often take 1–2 weeks. Larger changes to the architecture or code usually take 4–8 weeks.

Written by

Christian Gangestad

Senior full-stack developer at PXL

Christian is an all-round full-stack developer. He specialises in accessibility and technical UX, and makes sure what we build works for everyone.

Questions about your site's performance?

We review the Lighthouse results, Core Web Vitals and accessibility of your site and tell you what will make the biggest difference. There's no obligation.

All articles