Skip to main content

Core Web Vitals for Arabic and RTL Sites: Seven Practical Fixes

T
Tarek Ibrahim
•
Core Web Vitals for Arabic and RTL Sites: Seven Practical Fixes

Most Core Web Vitals advice is written for Latin-script sites in left-to-right layouts. Arabic and right-to-left (RTL) sites behave differently in ways that matter for the three metrics Google uses as part of its page experience signals: Largest Contentful Paint (LCP), Interaction to Next Paint (INP) and Cumulative Layout Shift (CLS). Arabic fonts are heavier, text shaping is more expensive, mirrored layouts expose bugs in sliders and menus, and bilingual builds add redirects, cache variants and language switchers that a monolingual site never has to think about.

This guide covers seven fixes we would apply to an Arabic or bilingual Arabic and English business website, in the order that usually pays off. It is based on public documentation from web.dev and on general engineering practice. It contains no benchmark results, because the right numbers for your site are the ones from your own field data, and we explain how to get them at the end.

What you are actually measuring

The current Core Web Vitals set is LCP, INP and CLS. According to Google’s official Core Web Vitals guidance, these metrics measure loading performance, responsiveness and visual stability using real-world user experience data. Google recommends evaluating them at the 75th percentile of page loads, separately for mobile and desktop users.

Two consequences follow for Arabic sites. First, the 75th percentile means your slower visitors decide the result: someone on a mid-range Android phone and a congested mobile network, which describes a large share of real traffic in Egypt and the wider region. Second, the metrics are collected per URL group, so your Arabic pages and your English pages are assessed separately. It is entirely possible for the English version to pass while the Arabic version fails, and the reverse. Treat them as two products.

Fix 1: Subset, convert and limit your Arabic fonts

Fonts are the single largest difference between an Arabic site and a Latin one. A Latin font family may need a few dozen glyphs per style. An Arabic font must carry the base letters, their initial, medial, final and isolated forms, ligatures, punctuation, digits in more than one numeral system, and often the contextual rules that join letters correctly. The files are larger, and a family with four or five weights multiplies the cost.

What to do:

  • Serve WOFF2 only. Every current browser supports it, and it compresses better than older formats. Remove legacy TTF and EOT fallbacks from your CSS.
  • Cut the number of weights. Regular and bold cover most business sites. Each extra weight is another file on the critical path. If your design genuinely needs several weights, use a variable font so one file covers the range.
  • Subset by script. If the font includes glyphs you never use, such as extended Arabic characters for other languages or unused symbol sets, subset it to the characters your content needs. Keep Latin and Arabic in separate files and connect them with unicode-range, so an Arabic page that contains a few Latin brand names does not download a second large file at the wrong moment, and an English page never downloads Arabic glyphs.
  • Self-host. A third-party font host adds a DNS lookup, a connection and a TLS handshake before the first byte of the font. Hosting the files on your own origin or CDN removes that round trip and lets you control caching headers.
  • Preload only the font used above the fold. One link rel='preload' with as='font' and crossorigin for the main body weight is usually right. Preloading five fonts defeats the purpose.

A minimal declaration looks like this:

@font-face {
  font-family: 'BrandArabic';
  src: url('/fonts/brand-arabic-regular.woff2') format('woff2');
  font-weight: 400;
  font-display: swap;
  unicode-range: U+0600-06FF, U+0750-077F, U+FB50-FDFF, U+FE70-FEFF;
}

The range covers the main Arabic blocks. Your own subset should be built from the characters your content actually uses.

Fix 2: Make the font swap invisible to layout

Fonts cause layout shift when text is first drawn in a fallback font and then re-flows when the web font arrives. web.dev lists web fonts among the main causes of CLS and recommends several mitigations: font-display: optional so the web font is used only if it is ready at first layout, a close fallback font, and the metric override descriptors size-adjust, ascent-override, descent-override and line-gap-override to make the fallback occupy the same space as the real font.

Arabic makes this more important, not less. Arabic scripts typically have taller line boxes and different average glyph widths than the Latin fallback a browser picks by default, so a headline set in an unmatched fallback can wrap onto a different number of lines. That is a visible jump in a hero section.

Our approach:

  • Choose a system fallback that has proper Arabic coverage on the platforms your visitors use, and declare it explicitly in the font-family stack. Never leave the stack ending without a generic family.
  • Define an adjusted fallback face using the override descriptors, tuned until a before and after screenshot of the heading shows no line-count change.
  • For body text, consider font-display: optional. On a slow first visit the visitor sees the fallback and the page never shifts; on repeat visits the cached web font is used. For the main heading, many brands prefer swap with a well-matched fallback so the brand typeface always appears. This is a design decision, and you should make it consciously rather than accept the default.

Test it by throttling the network in your browser developer tools and recording the Layout Shift entries in the performance panel. If the heading shifts when the font arrives, the fallback is not matched.

Fix 3: Treat the hero as the LCP element and protect it

On most business pages the LCP element is either the hero image or the main headline. web.dev breaks LCP into four subparts: time to first byte, resource load delay, resource load duration and element render delay. As a guide, roughly 40 percent of the time should be spent on TTFB, roughly 40 percent on downloading the resource, and under 10 percent each on the two delays. These are guidelines, not fixed millisecond budgets, but they show where Arabic sites usually lose time: in the delays.

Typical causes on RTL builds:

  • The hero image is lazy-loaded. Many themes and optimisation plugins add loading='lazy' to every image. web.dev is explicit that the LCP image must never be lazy-loaded because it delays the start of the request. Exclude the first image in the viewport.
  • The hero is a CSS background image. The browser cannot discover it until the stylesheet is downloaded and parsed. Use an img element with fetchpriority='high' so the resource is discoverable in the HTML, or preload it.
  • A separate mirrored image for RTL. Designers often export a flipped hero for the Arabic version. If a design can be mirrored with CSS or composed so that it works in both directions, you avoid maintaining and loading two heavy assets.
  • Text baked into images. Arabic headlines exported as part of a banner image are larger than live text, cannot be indexed as text, and cannot respond to font loading. Use live text over a clean image.
  • The LCP element is text, and the font is late. Then your LCP is effectively your font load. Fixes 1 and 2 are your LCP fix.

Use fetchpriority='high' on one image, at most two. web.dev warns that applying it to many images dilutes the signal. Serve a modern format such as WebP or AVIF with responsive srcset, and size the image for the largest slot it appears in, not for the original upload.

Fix 4: Clean up RTL CSS and remove duplicate stylesheets

Many WordPress themes and page builders handle Arabic by loading an additional rtl.css file that overrides the LTR styles. That means the browser downloads and parses two layers of CSS for every Arabic page, and the overrides tend to be large because they repeat declarations just to flip left and right.

The modern alternative is CSS logical properties. Instead of margin-left and padding-right, use margin-inline-start and padding-inline-end. Instead of text-align: left, use text-align: start. Instead of float: left, use float: inline-start, or better, use flexbox and grid, which follow the document direction automatically. With logical properties one stylesheet serves both directions and the RTL override file shrinks or disappears.

.card {
  padding-inline: 1.5rem;
  margin-inline-start: auto;
  border-inline-start: 4px solid currentColor;
  text-align: start;
}

Combine that with the usual render-blocking work. web.dev advises shrinking or inlining small critical CSS and avoiding synchronous scripts in the document head. On a custom build, extract the above-the-fold CSS for each template, inline it, and load the rest without blocking. On a page-builder site, audit what the builder loads on a page that uses a fraction of its widgets, and remove unused widget stylesheets and icon libraries.

Icons need a specific check on RTL. Directional icons such as arrows, chevrons and carousel controls must flip in RTL, but logos, play buttons, clocks and most other icons must not. A blanket transform: scaleX(-1) applied to every icon is a common source of bugs. Mark directional icons explicitly and use SVG rather than icon fonts, which add another font file to the critical path.

Fix 5: Stop layout shifts caused by direction, language and widgets

Besides fonts, bilingual and RTL sites have their own sources of CLS.

  • Direction set by JavaScript. If the dir='rtl' and lang='ar' attributes on the html element are applied after the page loads, the whole layout flips. Set them on the server in the initial HTML. This is usually a theme or Polylang template setting, not a script.
  • Sliders and carousels initialised late. Many slider libraries measure their container and compute positions in JavaScript. In RTL they sometimes initialise in the wrong direction and correct themselves after a delay, producing visible movement. Give the container a fixed aspect ratio with CSS aspect-ratio or reserved height, and prefer CSS scroll snap for simple carousels.
  • Images without dimensions. web.dev recommends width and height attributes on every image so the browser can reserve space from the aspect ratio, even when CSS sets width: 100%; height: auto. Check images inserted by the page builder, which sometimes omits them.
  • Language switchers and sticky bars. A language banner, cookie notice or promotional strip injected above the content pushes everything down. web.dev advises avoiding banners inserted at the top without reserved space; either reserve the height up front, or overlay the element so it does not take part in the document flow.
  • Embeds. Maps, video players, booking widgets and review feeds need a container with a fixed height or aspect ratio before they load.
  • Mixed Arabic and Latin text. Brand names, prices in Western digits and English technical terms inside Arabic paragraphs can change line breaks when a font fallback occurs. Setting unicode-bidi correctly on inline Latin fragments, and keeping both fonts metrically close, reduces surprises.

To find the culprit on a given page, record a performance trace and open the Layout Shifts track, or use the Layout Shift Regions option in the rendering tools to highlight what moved. Fix the largest single shift first. One slider that moves 400 pixels outweighs ten tiny text reflows.

Fix 6: Make INP better by cutting JavaScript on interaction paths

INP measures how quickly the page responds visually after taps, clicks and key presses throughout the visit, and the reported value reflects the slow end of those interactions. Good is 200 milliseconds or less. On business websites the usual offenders are not the application code but everything bolted on around it.

  • Third-party scripts. Chat widgets, WhatsApp buttons from third-party plugins, analytics tags, heatmaps, social feeds and ad pixels all run on the main thread. List every script that loads on your Arabic pages, assign an owner and a business reason, and remove those without one. Load the rest after interaction or on idle where possible.
  • Heavy mobile navigation. A mega menu that rebuilds large parts of the DOM on tap will feel slow. Keep the menu markup in the page, and toggle a class instead of regenerating content. Check that the RTL menu does not trigger a full layout recalculation of the page.
  • Long tasks. Break up any function that runs for more than about 50 milliseconds so the browser can paint between chunks. Yield back to the main thread between phases of work, using setTimeout or the newer scheduler APIs where supported.
  • Form handlers and validation. Arabic forms often do input normalisation, such as converting Arabic-Indic digits to Western digits, on every keystroke. Do it on blur or submit, or make it cheap.
  • Page-builder animation libraries. Scroll-triggered animations that run on every scroll event and read layout properties force repeated reflow. Use CSS animations and the Intersection Observer API instead.

Measure INP by interaction, not just by page. Chrome DevTools can show which interaction was slowest and break it into input delay, processing time and presentation delay. That breakdown tells you whether to fix a blocking script, a slow handler or an expensive render.

Fix 7: Fix the server side of a bilingual site: TTFB, redirects and caching

TTFB is the first LCP subpart, and web.dev suggests minimising redirects and making sure cached content can be served from the CDN. Bilingual WordPress sites have specific ways of getting this wrong.

  • Automatic language redirects. A rule that detects the browser language and redirects the homepage adds a full round trip, and sometimes a chain of two or three. Prefer showing the default language and offering a visible switcher. If you must redirect, make it a single hop, and make sure search crawlers are not redirected.
  • Cache variations by cookie. Language plugins that set a cookie and vary content by it can bypass full-page caching. Use separate URLs per language, such as /ar/, and configure the cache to ignore the language cookie for anonymous visitors.
  • Cache warm-up per language. After a deployment the cache is empty for both languages. Warm the main templates in each language so the first real visitor does not pay for an uncached render.
  • Query load from translation plugins. Translation plugins can add database queries per request. Use persistent object caching so repeated lookups do not hit the database, and check slow queries in your logs.
  • Hosting location and CDN. Your audience in Egypt, the Gulf and Europe sits at different distances from your server. A CDN that caches HTML as well as static files, with sensible rules, makes TTFB far more consistent across regions.

Our page speed optimisation service starts here, because a good front end cannot compensate for a slow first byte.

How to measure whether the fixes worked

Do not trust a single lab score. Lighthouse and PageSpeed Insights lab runs vary from run to run, and they use a simulated device that may not match your visitors. Use them to find problems, and use field data to judge success.

  • Search Console Core Web Vitals report. It groups URLs by similar templates, usually separating your Arabic and English pages if they live under different paths. Look at mobile first.
  • PageSpeed Insights field data. When enough traffic exists, it shows Chrome User Experience Report data at the 75th percentile for the URL or the whole origin. Compare Arabic and English URLs side by side.
  • Real user monitoring. For a site with meaningful traffic, collect the metrics with the open-source web-vitals JavaScript library and send them to your analytics with the page language and device class as dimensions. That gives you the INP element and the LCP element for the actual slow visits.
  • A change log. Field data takes weeks to move because it is a rolling window. Keep a dated list of what was changed so you can connect improvements to causes.

Set a target per template, not per site: homepage, service page, blog post, contact page, booking page. Fix the template that carries the most traffic and the most revenue first.

A practical order of work for an Arabic business site

If you are deciding where to start, this sequence delivers the most for the least risk:

  1. Pull field data for Arabic and English URLs separately and identify which metric fails on which template.
  2. Fix the LCP element on the highest-traffic page: remove lazy loading from it, make it discoverable, reduce its size, and preload the font if it is text.
  3. Subset and limit fonts, self-host them, and add a metrically matched fallback.
  4. Replace the separate RTL stylesheet with logical properties where the theme is under your control, and trim unused builder CSS.
  5. Reserve space for every image, slider, embed and banner.
  6. Audit third-party scripts and delay or remove the ones that hurt INP.
  7. Remove language redirects, standardise per-language cache rules and verify TTFB from the regions that matter.

Every item in that list can be done on a WordPress site, and the deeper ones are easier on a custom Laravel front end where you control the rendering path. If your Arabic pages are failing Core Web Vitals and you want a prioritised plan based on your own field data, our team can run the audit through our page speed optimisation service, and the same fixes belong in the brief for any new multilingual website.

Share:
Free Website Review

Send us your website and we will tell you what is holding it back on Google and with visitors.

Free, with no obligation. We only look at your public pages, so you do not need to share any logins.

What does the review cover?
Report language

The report reaches you on WhatsApp within two working days

Planning Your Next Website Project?

Tell us about your goals. We'll review your requirements, recommend the right approach and send a clear quotation. We reply within one business day.