Consistent lcp Element Render Delay on Blog Articles (2025.3.9) – investigatio 
Autor: Nektarios K.I am testing the WebSite X5 Blog component (version 2025.3.9) and analyzing Core Web Vitals using Lighthouse (mobile simulation).
I have identified a consistent performance pattern affecting blog article pages.
1. Test environment
- WebSite X5 version: 2025.3.9
- Blog component: default configuration (no custom scripts)
- Multiple templates tested
- Clean projects + minimal test articles used
- No external optimization plugins or custom JS
2. Observed behavior
Across all blog article pages, the following pattern is consistent:
Performance metrics:
- Time to First Byte (TTFB): ~0 ms
- Resource load delay: 0–190 ms
- Resource load duration: minimal
- Total Blocking Time (TBT): ~0–20 ms
- Cumulative Layout Shift (CLS): 0
- First Contentful Paint (FCP): ~1.8–2.9 s
- Largest Contentful Paint (LCP): ~2.9–4.3 s
3. Critical issue: Element Render Delay
Lighthouse consistently reports that the main cause of LCP degradation is:
Element Render Delay (~1.2s to ~2.3s)
This delay occurs even though:
- the LCP element is already present in the DOM
- there are no long main-thread tasks (TBT is negligible)
- network loading is not a bottleneck
4. LCP element variation
The LCP element alternates between:
- article text inside .imBlogPostBody
- blog cover image .imBlogPostCover
In both cases, the same render delay behavior is observed.
5. Additional observation
The blog cover image is rendered with dynamically computed inline styles (for example, inline height values such as style="height: 107.478px"), suggesting runtime layout calculations.
This indicates that the layout may not be fully resolved at initial render time.
6. Reproducibility
This behavior is consistent across:
- different blog templates
- fresh projects
- minimal test articles (plain text only)
- fixed and variable image height modes
- different breakpoint configurations
7. Hypothesis (for clarification)
It appears that blog article rendering may involve a post-DOM layout stabilization phase before the first paint of the main content.
This could involve:
- breakpoint evaluation
- dynamic image scaling calculations
- layout alignment processing
- JavaScript-driven container adjustments
8. Question to developers / support
Could you please clarify the following:
- Is the observed Element Render Delay in blog articles expected behavior in the current Blog engine?
- Does the Blog system perform a layout stabilization phase before first paint, which could affect LCP metrics?
- Is there any recommended configuration or optimization strategy to reduce this render delay and achieve more “static-like” rendering behavior for blog content?
- Are there known architectural constraints in the Blog component that impact Core Web Vitals (specifically LCP render delay), even when network and CPU performance are not limiting factors?
Objective
The goal is to understand whether this behavior is:
- a configuration-level optimization issue
or - a structural characteristic of the Blog rendering engine
Any technical guidance on improving blog article LCP performance would be highly appreciated.
https://www.pamsmaritime.comhttps://blog.pamsmaritime.com/index.php

Autor
Could this difference between Lighthouse lab results and real-world field simulation indicate:
Is there any recommended configuration to ensure more consistent lab vs field performance alignment for blog pages?
Hello,
thank you for the detailed analysis and for providing the testing methodology and observations.
Regarding your questions, it is important to clarify that some of the concepts mentioned (such as a "layout stabilization phase") are not explicit operations intentionally performed by the Blog engine itself. Rather, they are part of the normal rendering process carried out by the browser while loading and drawing a webpage.
For example, when Lighthouse reports rendering delays or layout-related timings, these measurements reflect how the browser processes and paints the page. They do not necessarily correspond to specific phases deliberately implemented by the application code.
Regarding the difference between Lighthouse lab results and real-world field measurements:
For this reason, all web platforms are inherently sensitive to these simulations. Running the same tests in Desktop mode typically produces significantly different results because the artificial constraints are reduced.
Based on our own testing, the Blog component performs well overall. If you compare Lighthouse Mobile scores across well-known, high-traffic websites, you will find similar patterns. As examples, even highly optimized websites such as Google and Apple can receive Mobile Lighthouse scores that may appear surprisingly modest despite their excellent real-world performance.
Therefore, from the information provided, we do not currently see evidence of a structural limitation specific to the Blog engine. The behavior you are observing appears to be primarily related to how Lighthouse simulates mobile rendering conditions and how browsers perform layout and painting operations under those constraints.
We hope this helps clarify the results you are seeing.
Autor
Dear Eric,
"Thank you for the explanation. I am well-versed in how Lighthouse simulates network and CPU throttling. However, my inquiry was not about the tool's methodology, but about the engine's DOM output efficiency.
While I understand that rendering is a browser-side process, the complexity of the DOM structure and the overhead of the injected scripts are entirely within the control of the application engine. If the Blog engine is producing a structure that causes the browser to struggle under mobile-throttled conditions—while other comparable technical blogs do not—that is a performance characteristic of the engine, not just a property of the browser.
My goal is to maximize performance for a professional maritime consultancy. I will continue to manually optimize my assets to compensate, but I believe it is worth noting that a more streamlined code output from the engine would significantly reduce the manual 'brute-force' optimization required by the end-user."
Regards
Thank you for the clarification.
I understand your point that, regardless of how Lighthouse performs its measurements, the structure and complexity of the generated output can influence rendering performance under constrained conditions.
However, based on the information available to us, we are not aware of any known issue or architectural limitation within the Blog component that specifically causes the behavior you describe. From our testing, the Blog engine behaves consistently with the rest of the pages generated by the software, and we do not currently have evidence that it introduces a unique bottleneck affecting LCP metrics.
As for the differences you observe between Lighthouse lab results and real-world measurements, these are common across many websites and platforms. Mobile Lighthouse simulations are intentionally designed to expose rendering costs that may have little or no noticeable impact under real browsing conditions. For this reason, it is not unusual for a page to receive less favorable lab metrics while still performing well in field data.
At present, there is no specific Blog-related configuration that we can recommend to alter this behavior or make the generated output substantially more "static" from a rendering perspective. The most effective optimizations remain those applied at the content level, such as image optimization and reducing the amount of content that must be processed immediately on page load.
We appreciate your feedback regarding DOM efficiency and Core Web Vitals. While we cannot confirm a structural issue within the Blog engine based on the results provided, your observations will be forwarded to our development team for review.