Otimizar o element render delay do LCP

A imagem de LCP já descarregou e ainda não está no ecrã. Medido no Chrome 158: o que atrasa o paint e quando o Chrome contabiliza a imagem.

  • Bom ≤ 2,5 s
  • Precisa de melhorias ≤ 4 s
  • Mau > 4 s
Arjen Karel
Atualizado a · 11 min de leitura
Partilhar

Element render delay em resumo

O element render delay é a última das quatro partes do Largest Contentful Paint (LCP): o tempo desde o fim do download da imagem de LCP até o Chrome a pintar ou, num LCP de texto, tudo o que vem após o primeiro byte do HTML. Segundo o State of Web Vitals, é a maior parte do LCP em telemóveis em 8,5% dos sites com LCP de imagem.

Quanto tempo deve durar o element render delay?

O element render delay deve ser próximo de zero: quando as folhas de estilo chegam e nada oculta a imagem de LCP, o Chrome pinta-a assim que o download termina. A recomendação no web.dev é inferior a 10% do LCP. Na maioria dos sites, o time to first byte é a maior fatia, por isso verifique primeiro as quatro partes.

Em carregamentos lentos, o element render delay é superior ao time to first byte: nos carregamentos de páginas em telemóveis com um LCP de imagem de 2,5 segundos ou mais, no conjunto dos sites medidos pelo CoreDash nos 28 dias até 7 de novembro de 2026, rondava os 2,5 segundos no percentil 75, contra 1,8 segundos.

O render delay que aumentou após corrigir uma parte anterior é a mesma espera, agora visível: a imagem chega mais cedo, mas o que a retém continua lá, por isso avalie a correção pelo LCP. Numa página de teste criada à semelhança do site WordPress de uma imobiliária, o WebP reduziu o download da foto de 4,04 para 1,59 segundos e o LCP desceu apenas de 4,64 para 4,11 segundos: 1,94 segundos passaram para o render delay, atrás de uma animação de entrada (o LCP breakdown mostra cada etapa).

Onde começa e termina o element render delay?

Num LCP de imagem, o element render delay começa quando o último byte da imagem de LCP chega e termina quando o Chrome a pinta. Um LCP de texto não descarrega nada, pelo que o seu render delay começa no primeiro byte do HTML, e as folhas de estilo, os scripts e a web font ficam todos incluídos nele.

Timeline of the parts of LCP: for an image LCP, time to first byte, resource load delay and resource load duration, then element render delay from the end of the image download to the LCP; for a text LCP, time to first byte and then element render delay all the way to the LCP

Um LCP de imagem tem quatro partes e um LCP de texto tem duas; o element render delay é a última em ambos.

Antes dele surgem o time to first byte, o resource load delay e o resource load duration do Largest Contentful Paint. O nome varia consoante a ferramenta: Element render delay no Lighthouse 13 e Chrome DevTools, Render Delay no Lighthouse 12 e CoreDash, elementRenderDelay na biblioteca web-vitals. O CrUX publica as partes apenas para LCPs de imagem.

Porque é que uma imagem de LCP descarregada espera para ser pintada?

O Chrome só pinta a imagem de LCP descarregada quando nada bloqueia o primeiro ecrã: todas as folhas de estilo no head chegaram, todos os scripts sem defer ou async foram executados, o código que oculta o elemento já o revelou e não há nenhuma long task a correr. Essa espera é o render delay; o layout e o paint em si demoram milissegundos.

Numa página de teste no Chrome 158, a imagem descarregou em milissegundos e diferentes fatores atrasaram o elemento de LCP, um de cada vez. O Chrome contabiliza o LCP:

  • Uma folha de estilo no head: quando a folha de estilo chega.
  • Um script no head sem defer ou async: quando o script é executado.
  • O mesmo script com defer: de imediato.
  • A imagem oculta com visibility: hidden ou display: none: quando um script a mostra.
  • Um fade a partir de opacity 0 iniciado por um script: quando o fade termina.
  • Um fade em CSS a partir de opacity 0 que mantém o valor final (both, forwards): nunca. Um elemento mais pequeno torna-se o LCP.
  • Um fade em CSS a partir de opacity 0.01: no primeiro paint.
  • Uma long task antes do primeiro paint: quando a tarefa termina.
  • Texto numa web font com font-display: block: quando a fonte chega, no máximo após cerca de 3 segundos.

Como descobrir o que está a atrasar o elemento de LCP?

Os field data mostram que páginas e que elemento de LCP têm um element render delay elevado; uma trace de uma dessas páginas revela o que atrasa a imagem.

No CoreDash, abra o LCP em telemóvel, compare a barra de Render Delay no Phase breakdown com as outras três e agrupe por elemento de LCP para ver se um elemento em específico, como o slider da página inicial, é responsável pelo render delay elevado.

CoreDash Phase breakdown for image LCPs on phones: Time To First Byte, Load Delay, Load Time and Render Delay as bars on one time axis, each with its duration and a rating, with marks at 2.50 s and 4.00 s

Phase breakdown do CoreDash em telemóveis: as quatro partes no percentil 75, cada uma com a respetiva classificação.

No Chrome DevTools, grave uma trace com throttling de telemóvel e abra o LCP breakdown na barra lateral Insights. O request da imagem na track Network termina onde começa a faixa de Element render delay. Dentro dessa faixa, a track Network mostra um ficheiro que ainda está a carregar, a track Main uma long task (um triângulo vermelho no canto) e a track Animations um fade.

LCP breakdown insight in Chrome DevTools for a running-shoe shop's test page: time to first byte 565 ms, resource load delay 27 ms, resource load duration 996 ms, element render delay 800 ms. The Network track of the same trace: the hero photo's request (green) has ended while ab-test.js from the A/B testing tool is still loading, followed by the 800 ms Element render delay band.

Página de teste de uma loja de sapatilhas de corrida: a foto (a verde) foi descarregada enquanto o ab-test.js de uma ferramenta de testes A/B ainda está a carregar, e os 800 ms seguintes são element render delay.

O PageSpeed Insights mostra as quatro partes e o elemento de LCP na secção LCP breakdown, mas as linhas provêm de um carregamento rápido sem throttling, enquanto o seu LCP é calculado para um telemóvel lento; por isso, as contas não batem certo. O Lighthouse carrega a página num perfil limpo, pelo que um banner de consentimento ou uma variante de teste A/B pode surgir como o elemento de LCP, enquanto os visitantes habituais veem o hero: compare o elemento antes dos números.

Para developers, a versão de atribuição da biblioteca web-vitals fornece o render delay e o elemento de LCP de cada carregamento de página. O snippet faz log para a consola; envie antes estes valores para a sua ferramenta de analytics:

<script type="module">
  import { onLCP } from 'https://unpkg.com/web-vitals@6/dist/web-vitals.attribution.js?module';

  onLCP(({ value, attribution: a }) => {
    console.log('LCP', value, 'render delay', a.elementRenderDelay,
      'element', a.target, 'image', a.url);
  }, { reportAllChanges: true });
</script>

Como reduzir o element render delay?

O element render delay diminui quando aquilo que atrasa a imagem de LCP descarregada deixa de carregar ou de correr antes do primeiro paint, e no WordPress e Shopify isso é quase sempre uma configuração: a animação de entrada na primeira secção, o slider, a folha de estilo de um plugin ou o embed de uma app.

O que a trace mostra, a causa habitual e a solução:

  • Uma folha de estilo ou script ainda a carregar: ficheiros no head. Solução: folhas de estilo pequenas, scripts com defer.
  • Uma long task na track Main: tags, consentimento, código próprio. Solução: scripts de terceiros após o evento load.
  • A imagem cedo, o elemento tarde: uma página construída por JavaScript. Solução: o elemento no HTML vindo do servidor.
  • Um fade ou um script que revela o elemento: animação, slider, teste A/B. Solução: não ocultar o elemento de LCP.
  • Texto que surge tarde: uma web font com block. Solução: font-display: swap.

Render-blocking requests: folhas de estilo e scripts no head

O Lighthouse lista as folhas de estilo e os scripts que atrasam o primeiro paint em Render-blocking requests: "Requests are blocking the page's initial render, which may delay LCP. Deferring or inlining can move these network requests out of the critical path." Uma imagem de LCP cujo download terminou antes da chegada desses ficheiros fica à espera deles, e essa espera é o element render delay.

No WordPress, a opção Load JavaScript deferred no WP Rocket adia os scripts, e o Asset CleanUp ou o Script Manager do Perfmatters desativam a folha de estilo de um plugin nas páginas onde não é utilizada. O meu próprio plugin, o WP Core Web Vitals, junta as folhas de estilo num conjunto reduzido de ficheiros de 12 a 14 kB comprimidos e aplica defer aos scripts. No Shopify, desative os App embeds que não utiliza no editor de temas: a folha de estilo de cada um deles vai parar ao head.

No código, adicione defer a todos os scripts e mantenha cada folha de estilo por volta dos 15 kB comprimidos: combine as mais pequenas, reduza as maiores e substitua @import por um link no HTML (Network dependency tree). Quanto ao inlining mencionado no aviso, veja abaixo as soluções que não valem a pena.

Long tasks antes do primeiro paint

A imagem de LCP descarregada aguarda por cada long task (trabalho de script superior a 50 ms de uma só vez) executada antes do primeiro paint: numa página de teste no Chrome 158, um script de 1,5 segundos atrasou o LCP em 1,5 segundos, mesmo quando colocado na fila com setTimeout(..., 0). Pela minha experiência, a long task nesse intervalo deve-se com muito maior frequência a um gestor de tags ou a um script de consentimento do que a código próprio.

Carregue o analytics, píxeis e ferramentas de chat após o evento load, para que aquilo que dá dinheiro carregue primeiro (no Google Tag Manager, o trigger Window Loaded). Divida o código próprio mais longo e faça yield to the main thread entre as várias partes.

Um elemento de LCP construído por JavaScript

Quando um script adiciona o elemento de LCP, o Chrome só o pinta depois de esse script chegar e ser executado, mesmo que a imagem tenha sido pré-carregada e descarregada cedo. Coloque o elemento no HTML enviado pelo servidor: o conteúdo fica no HTML e o JavaScript adiciona os extras. Os temas de WordPress e Shopify já fazem isso, a menos que um slider ou uma app adicione o hero.

No Next.js, não carregue o hero com dynamic(..., { ssr: false }). Um elemento no HTML pode ainda assim estar invisível: com initial={{ opacity: 0 }}, a biblioteca de animações Motion para React renderiza-o no servidor com opacity 0 e só faz fade in depois de o JavaScript do React ter corrido. No elemento de LCP, desligue a animação de entrada:

<motion.img src="/hero.jpg" initial={false} animate={{ opacity: 1 }} />

Animações, sliders e testes A/B que ocultam o elemento de LCP

O tempo durante o qual um fade, o script de um slider ou um teste A/B mantém o elemento de LCP oculto soma-se ao LCP, porque o Chrome só contabiliza um elemento oculto quando este é mostrado: um fade a partir de opacity 0 iniciado por um script só conta quando a animação termina.

Animações. No Elementor, defina Advanced, Motion Effects, Entrance Animation para None na primeira secção. No Shopify, a opção Reveal sections on scroll do Dawn (Theme settings, Animations) começa em opacity 0.01, o que conta logo no primeiro paint; noutros temas, desligue a opção de reveal. Um fade-in no elemento de LCP não compensa a espera que acrescenta. Se tiver mesmo de ter fade, comece a partir de um valor quase visível, como em Optimize the LCP image:

.hero img { animation: hero-in .6s ease-out both; }
@keyframes hero-in { from { opacity: .01; } to { opacity: 1; } }

A mesma animação CSS a partir de opacity 0 deixa o hero fora do LCP: as ferramentas reportam um elemento mais pequeno e um LCP melhor do que aquele que os visitantes obtêm, e quando todo o primeiro ecrã surge com fade dessa forma, o Lighthouse pode até reportar nenhum LCP (NO_LCP).

Sliders. Coloque o primeiro slide no HTML como uma imagem simples para o script assumir a seguir, ou mostre apenas uma foto em telemóveis.

Testes A/B. Numa página de teste criada à imagem da landing page de uma loja de sapatilhas de corrida, o snippet anti-flicker da ferramenta de testes ocultou a página até que os dois scripts alojados no servidor da própria ferramenta fossem executados. A foto tinha terminado o download aos 1,58 segundos numa ligação de telemóvel com throttling e depois esperou 0,79 segundos. Com a variante decidida no servidor, o render delay foi de 0,01 segundos e o LCP passou de 2,37 para 1,58 segundos.

Phone screenshot of the running-shoe shop's test page 2.0 seconds into the load with a client-side A/B test: a white screen, because the anti-flicker snippet still hides the page

Antes

Phone screenshot of the same page 2.0 seconds into the load with the test decided on the server: the logo, menu, the photo of grey running shoes, the heading and the button are on screen

Depois

A página de teste da loja de sapatilhas de corrida num telemóvel, 2,0 segundos após o início do carregamento, com o teste client-side e com o teste no servidor.

Corra o teste no servidor ou teste apenas elementos abaixo do primeiro ecrã, configurando a ferramenta para ocultar unicamente esses. O blocking="render" sugerido pelo guia do Chrome para testes client-side também retém o paint até o script chegar. Remover o snippet mantendo o teste a correr no browser mostra aos visitantes a página original primeiro e só depois a variante.

Um LCP de texto que espera por uma web font

Com font-display: block, ou sem qualquer font-display, um LCP de texto numa web font só conta quando a fonte chega, no máximo após cerca de 3 segundos. Definido como swap, o texto conta assim que surge na fonte de fallback, e a transição posterior para a web font não gera um novo LCP.

@font-face { font-family: "Brand"; src: url(/fonts/brand.woff2) format("woff2"); font-display: swap; }

Faça preload de uma ou duas fontes, começando pela fonte do maior texto no primeiro ecrã, e verifique o LCP de seguida. No Elementor, defina o Google Fonts Load para Swap. O artigo Font display explica o resto.

Que correções ao element render delay não valem a pena?

As correções a que a maioria recorre primeiro reduzem o element render delay, mas causam problemas noutros sítios, adiam a espera para outro momento ou não mudam nada — como o atributo elementtiming adicionado para excluir um popup do LCP.

  • Critical CSS e CSS inline. O Critical CSS pinta a página com parte do CSS e volta a aplicar estilos quando o resto chega. O CSS colocado inline no HTML é descarregado novamente em cada visualização de página, porque o browser raramente guarda o HTML em cache.
  • Funcionalidades de Remove Unused CSS no WP Rocket, Perfmatters ou LiteSpeed Cache causam tantos problemas como o Critical CSS: dão mais trabalho do que aquilo que valem.
  • A opção de atrasar o JavaScript (Delay JavaScript) no WP Rocket ou no Perfmatters. Os resultados no Lighthouse parecem melhores, mas os scripts correm apenas ao primeiro toque ou scroll do visitante, e um hero que dependa de um deles permanece oculto até esse toque.
  • Um preload ou uma imagem mais pequena. Enquanto houver algo a bloquear a imagem, o tempo poupado transfere-se para o render delay.
  • elementtiming num popup. O atributo serve apenas para etiquetar um elemento para a Element Timing API; nenhum atributo retira um elemento do LCP. Mostre o popup ao primeiro scroll ou toque, quando o Chrome já tiver deixado de procurar o elemento de LCP.
  • content-visibility. Numa página de teste no Chrome 158 com 6 000 cards no HTML abaixo do hero, o content-visibility não alterou o LCP: o Chrome pintou o primeiro ecrã antes de ter feito o parse dos cards.

O render delay diminuiu?

Numa nova trace, o marcador de LCP surge logo após o final do request da imagem de LCP. Execute o Lighthouse novamente e verifique as outras três partes no mesmo teste: um render delay mais curto pode revelar a espera seguinte. No CoreDash, o render delay em telemóveis desce em poucos dias nas páginas alteradas; o Search Console demora até 28 dias.

Nem tudo o que atrasa a imagem está nas suas mãos mudar: uma ferramenta de testes gerida pela equipa de marketing ou uma app que adiciona o respetivo script ao head. Numa Core Web Vitals power hour, analisamos os seus field data e uma trace do seu template mais lento, e decidimos o que pode sair do primeiro paint e o que pedir ao fornecedor.

About the author

Arjen Karel is a web performance consultant and the creator of CoreDash, a Real User Monitoring platform that tracks Core Web Vitals data across hundreds of sites. He also built the Core Web Vitals Visualizer Chrome extension. He has helped clients achieve passing Core Web Vitals scores on over 925,000 mobile URLs.

Arjen Karel

Precisa de um site mais rápido?

Sou o Arjen e há 17 anos que corrijo sites lentos. Se tem problemas que não consegue resolver sozinho, envie-me o seu URL e falamos.

Envie-me o seu URL
Arjen Karel
Arjen Karel, Consultor de web performance desde 2009

Porque é que o nosso fix não está a funcionar?

Por vezes a CDN ainda serve o HTML antigo, ou o fix foi feito no template de desktop e o mobile usa outro. Envie-me o seu URL e o problema, e respondo com alguns horários. Primeiro analiso os seus field data, depois dedicamos uma hora ao seu site, e no prazo de um dia tem as minhas notas por escrito. 350 € sem IVA.

Envie-me o seu URL

Sem programador para fazer o fix? Faço eu o trabalho, numa cópia do seu site.

Arjen KarelLCP ainda no vermelho em mobile?Envie-me o seu URL