LifterLMS Core Web Vitals: Fixing LCP, INP and CLS on Course Sites

How to measure and improve Core Web Vitals on a LifterLMS site: which pages matter, the LifterLMS-specific causes of slow LCP, poor INP and layout shift, and a small plugin that removes two common bottlenecks.

  • Add as a preferred source on Google
Illustration for “LifterLMS Core Web Vitals: Fixing LCP, INP and CLS on Course Sites”

Core Web Vitals are Google's three measurements of real-world page experience: how quickly the main content appears, how quickly the page responds to a tap or click, and how much the layout jumps while loading. On a LifterLMS site they matter twice over. Course sales pages compete in search, and logged-in learners judge your product by how lessons feel on a phone.

This guide is for site owners and developers who have seen poor scores in Search Console or PageSpeed Insights and want to fix them properly. It covers which pages to measure, the causes of poor LifterLMS Core Web Vitals that we see most often, and a short plugin that removes two common bottlenecks.

For general speed work, such as hosting, caching layers and image optimisation, start with our guide on how to speed up a LifterLMS site. This article focuses on the three metrics.

The three metrics and their targets

MetricMeasuresGoodTypical LifterLMS culprit
Largest Contentful Paint (LCP)When the largest image or text block appears2.5 seconds or lessSlow server response on uncached pages, hero images, video embeds
Interaction to Next Paint (INP)How quickly the page responds to input200 milliseconds or lessToo much JavaScript: page builders, tracking tags, sitewide plugin scripts
Cumulative Layout Shift (CLS)How much content moves unexpectedly0.1 or lessLate-loading banners, fonts, and elements resized by JavaScript

Google assesses each metric at the 75th percentile of real visits, separately for mobile and desktop, as explained on web.dev's Web Vitals overview. A page passes when three out of four visits are good, which is why a fast desktop test can hide a poor mobile reality.

Measure the right pages on a course site

A LifterLMS site has very different page types, and each behaves differently:

  • Public, cacheable pages: home, blog, course and membership sales pages, the course catalogue. These are what search engines rank and where page caching works.
  • Checkout: public but never cached, and loaded with payment scripts. A slow checkout costs sales even if it does not affect rankings.
  • Logged-in learning pages: student dashboard, lessons and quizzes. They bypass page caches and are usually not indexed, but they are where learners spend their time.

Use field data first. Search Console's Core Web Vitals report groups similar public URLs and shows which groups fail. PageSpeed Insights shows field data for a URL or the whole origin when enough Chrome users have visited, plus a lab test. For logged-in pages, field tools see little, so record a performance trace in Chrome DevTools while logged in as a test student, on a throttled mobile profile.

Test a sales page logged out, then the same course's first lesson logged in. The gap between the two numbers tells you whether your problem is front-end weight or server time.

Fixing LCP on LifterLMS pages

Server response on uncached pages

Logged-in lesson pages are built fresh for every view, and LCP cannot start until the HTML arrives. If time to first byte is over about 800 milliseconds, fix that first: a current PHP version, enough PHP workers, and a persistent object cache. Our guide to object caching with Redis for LifterLMS covers the biggest single improvement for logged-in pages.

The Featured Video and Featured Audio fields on courses and memberships, and the Video Embed Url field on lessons, are turned into players with WordPress's wp_oembed_get(). Unlike embeds placed in post content, which WordPress caches in post meta, that function does not store its result, so a page that is not served from a page cache can spend time asking the video provider for embed code before it can finish. The plugin at the end of this article caches that response.

The player itself is often the LCP element on a lesson. Iframes from YouTube or Vimeo load a lot of script. Consider a lightweight facade, a poster image that loads the real player on click, for lessons where the video is not watched immediately, and use your video host's own performance options.

Hero images on sales pages

  • Serve the course image at the size it is displayed, in a modern format.
  • Do not lazy-load the image at the top of the page. WordPress adds fetchpriority="high" to the image it believes is the LCP candidate; check in the HTML that your theme or page builder has not overridden that.
  • Avoid sliders and background-image heroes set in CSS, which the browser discovers late.

Fixing INP: less JavaScript on every page

INP is about main-thread work. On course sites the main sources are page builders, analytics and marketing tags, chat widgets, and scripts from plugins that load everywhere.

LifterLMS contributes some of that. Its front-end asset loader enqueues the main llms script, an AJAX helper, the checkout form script, a popover library, and three jQuery UI components (tooltip, datepicker and slider) on every front-end page, including pages with no course content. Logged-in users also get the notifications script. Each is small, but together with jQuery they add parsing and execution time on low-end phones. LifterLMS's own front-end code does not use those jQuery UI components, which makes them a safe first target, as long as your add-ons do not rely on them.

Beyond LifterLMS:

  • Audit third-party tags. Pixels and chat widgets are the most common cause of poor INP. Load them only where they earn their place, for example the pixel on sales and checkout pages, not on lessons.
  • Delay non-essential scripts until user interaction, but exclude LifterLMS checkout, quiz and lesson scripts from delay and combine features, or you will break buttons. Our article on LifterLMS caching conflicts lists what to exclude.
  • Watch heavy lesson content. A lesson with ten embeds, large H5P activities or a long page-builder layout is slow to interact with. Split long lessons.
  • Check the quiz page. Quiz questions load by AJAX as the student answers. If each answer feels slow, that is server time, not INP, and the fix is on the server.

Fixing CLS: keep the layout still

LifterLMS's own video wrapper reserves a 16:9 box for featured videos, so a featured video should not shift the page. The usual sources of layout shift on course sites are elsewhere:

  • Elements equalised by JavaScript. LifterLMS uses the matchHeight jQuery plugin to give equal heights to access plan cards in pricing tables, instructor boxes and lesson navigation links. If those heights change after the content is painted, nearby content moves. Where it shows up in a trace, use your theme's CSS (for example a grid or flexbox with equal-height rows) so the browser lays the cards out correctly the first time.
  • Cookie banners and notices that push content down instead of overlaying it.
  • Web fonts that swap late with very different metrics. Preload the main font and choose fallbacks with similar sizes.
  • Images and embeds without dimensions inside lesson content, especially ones added by page builders.
  • Ads or upsell boxes injected after load. Reserve their space.

LifterLMS's pop-up notifications for logged-in users are positioned over the page rather than inserted into it, so they are not a layout-shift source by themselves.

A small plugin for two common bottlenecks

This plugin caches oEmbed responses for a day and removes the three jQuery UI scripts outside quizzes, checkout and the student dashboard. Install it on staging, test checkout, quizzes and any add-ons with front-end interfaces, then measure again.

<?php
/**
 * Plugin Name: LLMSX Core Web Vitals Tweaks
 */

defined( 'ABSPATH' ) || exit;

// 1. Cache oEmbed HTML (featured videos, audio) for a day, so an uncached
//    page view does not wait on the video provider.
function llmsx_oembed_cache_key( $url, $args ) {
	return 'llmsx_oembed_' . md5( $url . wp_json_encode( $args ) );
}

add_filter( 'pre_oembed_result', function ( $pre, $url, $args ) {
	if ( null !== $pre ) {
		return $pre;
	}
	$cached = get_transient( llmsx_oembed_cache_key( $url, $args ) );
	return ( false !== $cached ) ? $cached : null;
}, 20, 3 );

add_filter( 'oembed_result', function ( $html, $url, $args ) {
	if ( $html ) {
		set_transient( llmsx_oembed_cache_key( $url, $args ), $html, DAY_IN_SECONDS );
	}
	return $html;
}, 20, 3 );

// 2. LifterLMS enqueues three jQuery UI scripts on every front-end page.
//    Core's own front-end code does not use them, so drop them where
//    add-ons are unlikely to need them. Test your add-ons after enabling.
add_action( 'wp_enqueue_scripts', function () {
	if ( is_singular( 'llms_quiz' ) || is_llms_checkout() || is_llms_account_page() ) {
		return;
	}
	foreach ( array( 'jquery-ui-tooltip', 'jquery-ui-datepicker', 'jquery-ui-slider' ) as $handle ) {
		wp_dequeue_script( $handle );
	}
}, 20 );

The oEmbed cache uses transients, so with a persistent object cache it lives in memory, and without one it lives in the options table. The pre_oembed_result filter runs at priority 20 and respects any earlier result, which leaves WordPress's own handling of embeds from your site untouched.

Common mistakes

  • Chasing a lab score. PageSpeed's lab number is a diagnostic. Google uses field data, so judge success by the 75th percentile over 28 days.
  • Caching logged-in pages to win a test. It breaks progress, checkout and account pages. Make uncached pages fast instead.
  • Deferring LifterLMS scripts blindly. Checkout, quizzes and Mark Complete depend on them loading in the right order.
  • Optimising only the home page. Course sales pages and checkout matter more for revenue.
  • Removing scripts without testing add-ons. Paid add-ons may use jQuery UI or LifterLMS scripts on their own screens.

Frequently asked questions

Does LifterLMS hurt Core Web Vitals?

Not much on its own. It adds a modest set of scripts and styles on every page. Themes, page builders, third-party tags and uncached server time usually matter far more.

Do lesson pages count towards my Core Web Vitals?

Search Console reports on URLs it knows about, which are mostly public pages. Lessons behind a login matter less for rankings but just as much for learners, so measure them with DevTools.

Which LifterLMS theme scores best?

Lightweight themes with native LifterLMS support start ahead, but your page builder and plugins decide the final result. Measure your own pages rather than relying on demo scores.

How long until Search Console shows improvement?

Field data covers the previous 28 days, so expect a few weeks after a fix before the report changes.

What to do next

Pick one sales page and one lesson, measure both on mobile, and fix the slowest metric on each. If server time is the problem, start with object caching; if it is JavaScript, start with third-party tags. If you would like a full Core Web Vitals audit with fixes that do not break checkout, quizzes or progress tracking, our LifterLMS optimization service does exactly that. Send us the URLs that are failing and we will tell you what is holding them back.

Add LifterLMS Expert to your preferred sources

Add lifterlmsexpert.com as a preferred source on Google, or open this article in your AI assistant to use it as a source.

  • Add as a preferred source on Google
Free consultation

Prefer expert help over DIY?

Skip the trial and error. Get specialist LifterLMS help and ship faster.

Talk to a LifterLMS Expert Explore our services

Replies within one business day