Pertento Runtime Script and Core Web Vitals Impact

Pertento is designed to be the fastest experimentation script available. It adds no measurable degradation to Core Web Vitals (LCP, CLS, INP or FID). This is a core engineering requirement for us, not a marketing claim.

Below is a detailed explanation of why the script has near-zero impact and how the architecture ensures long-term performance safety.

Why Core Web Vitals Stay Unaffected

1.The script loads with defer, so it never blocks rendering

The defer attribute guarantees:

• the browser continues parsing HTML without waiting for the script
• critical rendering path is untouched
• rendering of above-the-fold content is not delayed

This protects two of the most important Web Vitals:

• LCP (Largest Contentful Paint)
• FCP (First Contentful Paint)

No render-blocking → no delay in displaying meaningful content.

2. The runtime is extremely small ( under 0.6 KB compressed)

JavaScript size directly impacts performance:

• less to download
• less to parse
• less to compile
• less time spent on main thread tasks

Most experimentation tools load 50–150 KB (some even >300 KB) of JS before activation. Pertento avoids this entirely.

A sub-1 KB footprint is effectively invisible to the browser’s performance pipeline.

3. No layout manipulation during initial render

Pertento does not inject DOM, CSS or layout changes before the page is painted.

This protects:

• CLS (Cumulative Layout Shift)
• INP (Interaction to Next Paint)

By not touching the DOM before first render, Pertento avoids:

• layout jumps
• style reflows
• blocking interactivity
• unexpected paint timing changes

Experiments only apply after the initial layout is complete, ensuring complete stability.

4.Activation happens asynchronously and after the browser is idle

Pertento’s activation logic is built to:

• wait for safe execution timing
• offload work to idle periods where possible
• run outside critical rendering paths
• avoid competing with user-triggered interactions

This ensures that early interactive metrics like FID and INP are never negatively affected.

5.No heavy analytics, no batching, no continuous polling
The runtime:

• does not send large analytics payloads
• does not open long-lived connections
• does not run expensive intervals or polling loops
• does not perform CPU-intensive computations

This eliminates the most common causes of:

• long tasks
• delayed input processing
• degraded responsiveness

Your INP stays clean.

6.Uses local storage, not cookies or cross-session lookups

Local storage lookups are fast and synchronous with negligible main-thread cost:

• zero network calls
• zero dependency on external trackers
• zero session blocking
• zero overhead on each page load

This reduces both execution time and browser I/O.

7. No flicker or reflow unless the anti-flicker snippet is used

By default, the script causes:

• no content flash
• no variant-switch flicker
• no sudden DOM replacement

This ensures an extremely stable CLS profile.

The optional anti-flicker snippet is available for UI-critical tests, but even then the mechanism is controlled and time-bound, not a continuous blocker.

What the script does do (safely)

Once loaded, the runtime handles:

• experiment activation
• variant logic
• impression reporting
• conversion reporting (if used)
  

All of this happens:

• after first paint
• after layout stabilization
• asynchronously
• without blocking main-thread rendering tasks
  

This architecture ensures that Pertento can run even on low-powered or mobile devices without affecting speed or user experience.

Summary: Why Pertento has zero meaningful impact on Core Web Vitals (CWV)

• Script is extremely small → negligible bandwidth and parse time
• Loads with defer → zero interference with rendering
• Does not modify DOM or CSS pre-paint → zero CLS risk
• Runs after the browser is ready → protects INP and FID
• No heavy analytics or loops → prevents long tasks
• Local storage instead of cookies → avoids slow lookups
• No render-blocking dependencies → consistent LCP and FCP

Pertento is engineered to allow full-scale experimentation without sacrificing performance, SEO, or user experience. For many sites, Pertento will not appear as a measurable contributor to performance metrics at all.