A checklist definitiva dos Core Web Vitals (2026)

Todas as otimizações a verificar ao melhorar o desempenho do LCP, INP e CLS

Arjen Karel
Atualizado a · 23 min de leitura
Partilhar

A checklist definitiva dos Core Web Vitals

Esta checklist de Core Web Vitals reúne todas as otimizações a verificar antes de colocar um site em produção, ao trabalhar no Largest Contentful Paint (LCP), Interaction to Next Paint (INP) ou Cumulative Layout Shift (CLS), e após qualquer alteração relevante no site, para garantir que as páginas são rápidas e estáveis o suficiente para passar na avaliação dos Core Web Vitals da Google.

Mantenho esta checklist atualizada conforme aprendo coisas novas. Falta alguma coisa? Diga-me.

Core Web Vitals metrics: LCP loading under 2.5 sec, INP interactivity under 200 ms, CLS stability under 0.1

Checklist de otimização dos Core Web Vitals

Avance secção a secção, a começar pela métrica que falha no p75 no telemóvel. Cada secção remete para o respetivo guia detalhado, para que possa perceber a relevância de cada ponto antes de alterar o que quer que seja.

Otimizar imagens

Uma imagem grande na viewport visível costuma tornar-se no elemento do Largest Contentful Paint. Isto faz da otimização de imagens uma das melhores intervenções que pode fazer pelo LCP. Para a estratégia completa, leia como otimizar a imagem do LCP.

  • Redimensione as imagens para a dimensão máxima com que são exibidas no ecrã. Qualquer byte gasto em píxeis que ninguém vê é desperdiçado, e imagens com o tamanho certo são frequentemente 50% mais pequenas ou menos, sem perda visível de qualidade. Combine isto com imagens responsivas para ecrãs menores.
  • Aplique lazy loading às imagens abaixo da dobra. O browser não lhes mexe até o visitante fazer scroll até lá perto, reservando a largura de banda inicial para o que está no ecrã, o que ajuda o First Contentful Paint (FCP) e o carregamento geral. Nunca aplique lazy loading à imagem do LCP: o browser fica à espera do layout antes de sequer iniciar o download.
  • Defina fetchpriority="high" na imagem do LCP e faça preload apenas se o HTML a ocultar. Uma tag <img> no HTML é detetada pelo preload scanner de qualquer forma; o atributo coloca-a na frente da fila. O preload com <link rel="preload" as="image" fetchpriority="high"> serve para uma imagem do LCP definida em CSS ou carregada por JavaScript, que o browser não consegue ver no HTML.
  • Defina a largura e a altura em todas as imagens. Os browsers modernos usam estes dois atributos para calcular a proporção antes do carregamento da imagem, reservando o espaço devido para que nada se mova quando o ficheiro chegar. Menos uma causa de layout shifts.
  • Use WebP ou AVIF em vez de JPEG ou PNG. Com qualidade comparável, um ficheiro WebP é habitualmente 25 a 34% mais pequeno do que um JPEG, e o AVIF pode poupar até 50%. Um elemento <picture> com fallbacks assegura compatibilidade com todos os browsers.
  • Use lazy loading nativo e desative qualquer lazy loading por JavaScript. O atributo loading="lazy" faz o mesmo sem exigir que um script seja processado e executado primeiro.
  • Indique um srcset nas imagens, com o atributo sizes para um controlo rigoroso. O browser escolhe a imagem ideal para o dispositivo e o telemóvel deixa de descarregar o ficheiro preparado para um ecrã grande de computador.
  • Adicione decoding="async". O browser descodifica a imagem em paralelo e continua a pintar o resto da página entretanto.
  • Elimine os metadados das imagens. Dados EXIF e semelhantes só aumentam o peso em bytes, e removê-los não afeta a qualidade da imagem. O ImageOptim e o Squoosh fazem isto manualmente, e o Sharp pode fazê-lo durante o build.
  • Não use uma imagem de fundo em CSS para o elemento do LCP. O browser encontra uma imagem de fundo em CSS muito mais tarde do que uma tag <img> no HTML. Se não tiver alternativa, faça preload com uma tag <link rel="preload"> para que seja descoberta com antecedência. Saiba mais sobre o LCP resource load delay.

Otimizar web fonts

As web fonts podem atrasar o First Contentful Paint, causar layout shifts e concorrer com outros ficheiros pela reduzida largura de banda disponível no início do carregamento. O local ideal onde alojar os ficheiros é explicado no guia sobre self-hosting de Google Fonts.

  • Defina font-display: swap nas regras @font-face para antecipar o primeiro paint. O browser apresenta de imediato uma fonte de fallback e carrega a web font em segundo plano. Quando estiver pronta, substitui-a. Saiba mais sobre como garantir que o texto permanece visível durante o carregamento de web fonts.
  • Combine font-display: optional com um preload para eliminar layout shifts provocados por fontes. Com optional, o browser espera cerca de 100 ms pela web font; se esta não estiver pronta a tempo, a fonte de fallback mantém-se nessa visualização de página e nada é alterado. O preload torna muito mais provável que a fonte chegue dentro dessa janela temporal.
  • Ajuste as dimensões da fonte de fallback às da web font através de descritores font-face. Defina size-adjust, ascent-override, descent-override e line-gap-override no fallback para que o texto quase não se mova quando a web font entrar, mantendo o CLS no mínimo.
  • Crie subsets das fontes apenas com os carateres de que o conteúdo precisa. Uma fonte latina completa com mais de 100 KB passa frequentemente para menos de 20 KB após o subsetting correto. O Font Squirrel gera subsets online; o pyftsubset e o glyphhanger fazem-no na linha de comandos.
  • Limite o número de pesos e estilos de fonte. Cada peso adicional acrescenta entre 15 e 50 KB de download. Limite-se a um máximo de 2 fontes críticas (normalmente com preload) e 2 que carreguem mais tarde, após o primeiro render.

Otimizar scripts

Os scripts podem provocar problemas de Interaction to Next Paint, disparar Cumulative Layout Shifts ou atrasar o Largest Contentful Paint. Mesmo um script pequeno e bem comportado no topo da página compete por recursos e adia as métricas de paint (LCP e FCP). Todas as alternativas disponíveis constam de 14 métodos para diferir JavaScript.

  • Remova o JavaScript de que não precisa. O separador Coverage nas Chrome DevTools mostra o código não utilizado, e cada bloco de código morto removido poupa tempo de download e tempo de main thread.
  • Priorize os scripts segundo a respetiva função. Um script que faça grandes alterações na viewport visível deve ser render blocking. Scripts importantes devem ser diferidos ou carregados com async, e os acessórios aguardam que o browser fique inativo. O guia de priorização de recursos descreve a estratégia detalhada.
  • Divida o código e aplique lazy loading às partes. Separe bundles grandes de JavaScript em blocos mais pequenos que só carregam quando necessários, tornando o carregamento inicial mais leve. Qualquer bundler moderno (webpack, Rollup, esbuild) faz esta divisão de forma automática com dynamic imports.
  • Minifique e recompile sempre os ficheiros JavaScript com ferramentas como o SWC, Terser ou esbuild. Isso retira habitualmente 30 a 50% ao tamanho do ficheiro.
  • Limite os scripts de terceiros. Cada um acrescenta pesquisas de DNS, sobrecarga de ligação e tempo de main thread; avalie se é mesmo necessário e se existe uma alternativa mais leve. Verifique-os periodicamente no painel Network das Chrome DevTools.
  • Carregue scripts de terceiros com async ou defer. Nunca se sabe o que um terceiro vai fazer a seguir, pelo que nenhum deve bloquear a renderização.
  • Acompanhe o custo real dos scripts de terceiros para os utilizadores. A API Long Animation Frames (LoAF) ou o CoreDash mostram o impacto no INP e no LCP em field data. Estabeleça um performance budget para JavaScript de terceiros e reveja-o com regularidade.

Otimizar estilos

Os estilos bloqueiam a renderização por defeito, pelo que cada folha de estilos no head atrasa o First Contentful Paint e aumenta o LCP element render delay. Mantenha as folhas de estilos reduzidas e separadas, e ignore truques que dividem o CSS em dois. Para recomendações sobre a limpeza de estilos não utilizados, consulte como remover CSS não utilizado.

  • Minifique o CSS. Use o cssnano ou o PostCSS, ou a compressão integrada do pré-processador de CSS, para eliminar espaços em branco e comentários. Não custa nada fazê-lo, mas poupa apenas alguns kilobytes e nenhum visitante vai notar.
  • Remova o CSS que as páginas não utilizam. Menos CSS traduz-se em menos dados para descarregar e processar. O PurgeCSS ou o separador Coverage nas Chrome DevTools ajudam a localizar CSS não utilizado. Faça-o no seu processo de build e mantenha desativada a opção Remove Unused CSS de plugins como WP Rocket, Perfmatters ou LiteSpeed: gera tantos problemas como o critical CSS.
  • Não coloque CSS inline e dispense o critical CSS. O CSS inline aumenta o HTML, e o HTML é o ficheiro pelo qual tudo o resto espera. O browser normalmente também não guarda esse HTML em cache, logo cada página descarrega novamente o mesmo CSS, enquanto uma folha de estilos separada é servida a partir da cache logo na segunda página. O critical CSS até poupa um round trip na primeira visita, mas o restante CSS chega após o primeiro paint: um restyle, um repaint e, com frequência, um layout shift.
  • Mantenha cada folha de estilos render blocking abaixo de cerca de 15 KB comprimidos. É aproximadamente o que cabe no primeiro round trip de uma nova ligação, devendo servir de teto. Uma waterfall em Slow 4G demonstra bem os dois erros: uma folha de estilos de 60 KB demora demasiado tempo, e uma fila de ficheiros de 0,3 KB paga a latência inicial de cada pedido individual. Junte os ficheiros minúsculos e divida ou reduza o ficheiro volumoso.
  • Não adote o hábito de carregar CSS de forma assíncrona. O truque do media="print" só funciona para CSS que tenha a certeza absoluta de não ser usado no primeiro ecrã, e isso raramente se sabe com certeza. Isolar o CSS do primeiro ecrã do restante é critical CSS disfarçado com outro nome.
  • Remova todos os @import do CSS. Cada um desencadeia uma sequência de folhas de estilos que o browser só consegue obter uma a seguir à outra, impedindo o preload scanner de detetar os ficheiros no final da cadeia. Chame-os a partir do HTML ou agregue-os no build.

Otimizar resource hints

Os resource hints ajudam o browser a descarregar recursos críticos em primeiro lugar. Um ficheiro com preload entra na fila e fica pronto muito mais cedo do que aconteceria sem essa indicação. Bem aproveitados, reduzem o LCP resource load delay; para uma abordagem avançada, leia sobre 103 Early Hints.

  • Elimine os hints de recursos que não sejam precisos na primeira visualização. A largura de banda inicial é escassa, e qualquer preload ou ligação supérflua retira capacidade aos ficheiros que realmente importam.
  • Faça preconnect aos domínios de que necessita logo à partida, como uma rede de distribuição de conteúdo ou fornecedor de fontes. A pesquisa de DNS, a ligação TCP e o TLS handshake ficam assim tratados antes de o primeiro pedido sair para esse domínio. Utilize <link rel="preconnect" href="https://example.com"> para origens de terceiros críticas.
  • Pondere o dns-prefetch quando o preconnect for excessivo. O preconnect estabelece a ligação por inteiro, ao passo que <link rel="dns-prefetch"> limita-se a resolver o domínio previamente. Basta para domínios que previsivelmente irá utilizar mais tarde, quando o custo de uma ligação completa ainda não compensa.
  • Faça preload da imagem do LCP quando esta não figurar no HTML. O LCP afere quanto demora o conteúdo principal a aparecer, e o preload do elemento do LCP coloca esse recurso na frente da fila. Para uma tag <img> já presente no HTML, fetchpriority="high" atinge o mesmo fim sem a tag complementar.
  • Faça preload de fontes críticas com <link rel="preload" as="font" type="font/woff2" crossorigin>. O browser obtém-nas antecipadamente, pelo que o texto surge mais cedo e a troca de fontes provoca menos layout shifts.
  • Envie os resource hints através de 103 Early Hints sempre que tiver essa hipótese. Com um código 103, o servidor envia os hints antes de a resposta global estar concluída — o momento mais precoce possível para o browser tomar contacto com um recurso. Se o servidor não conseguir enviar um 103, recorra a cabeçalhos de resposta Link; se os cabeçalhos também não forem viáveis, adicione elementos <link> ao <head> da página como fallback.
  • Faça preload de fontes antes de o CSS as descobrir. Uma fonte indicada no CSS só é encontrada depois de esse CSS ter sido descarregado e processado. O preload no <head> do HTML elimina essa espera, a fonte carrega em paralelo e tanto o FCP como a probabilidade de layout shift caem.

Otimizar ícones

É fácil cometer excessos com ícones: carregar uma biblioteca inteira para utilizar os cinco ícones de que a página precisa. Ícones SVG inline volumosos sobrecarregam o HTML, e uma icon font transporta frequentemente milhares de glifos que nunca são usados. Tratar bem dos ícones beneficia o LCP (menos HTML e CSS para carregar) e o CLS (espaço reservado a cada ícone).

  • Não insira ícones SVG pesados inline no HTML. Tornam o HTML maior, a página mais lenta e o browser é incapaz de os guardar individualmente em cache. Um sprite sheet externo em SVG representa por norma o melhor compromisso entre desempenho e flexibilidade, embora ficheiros autónomos ou uma icon font (usada com cautela) também mantenham o HTML compacto.
  • Nunca carregue na totalidade um pacote grande de ícones como o Font Awesome. O conjunto integral pode ultrapassar 100 KB, enquanto um subset de 20 ícones fica abaixo de 5 KB; extraia por isso um subset para uma icon font menor ou utilize SVGs individuais.
  • Reserve largura e altura para os ícones, exatamente como nas imagens. O browser mantém o espaço vago e os ícones não provocam layout shifts ao carregar. Indique os atributos width e height nos elementos SVG ou atribua dimensões explícitas através de CSS.
  • Não faça preload nem coloque inline ícones desnecessários no primeiro ecrã, garantindo que o conteúdo fulcral carrega em primeiro lugar. Recorra a lazy loading nos ícones posicionados abaixo da dobra.

Otimizar o tempo de resposta do servidor

O tempo de resposta do servidor, quantificado como Time to First Byte (TTFB), precede qualquer métrica de paint, pelo que um servidor lento atrasa tudo o resto. Para estratégias aprofundadas, veja os guias sobre diagnóstico de problemas de TTFB e configuração do Cloudflare para máxima performance.

  • Escolha um fornecedor de alojamento veloz e fiável, com infraestrutura sólida. Compare serviços pelo TTFB que medir diretamente no mundo real. Os números apresentados no marketing são sintéticos.
  • Registe a duração de execução do código e das queries à base de dados, e faça-o frequentemente. Ferramentas de query profiling e de monitorização de desempenho aplicacional (APM) apontam diretamente os endpoints lentos.
  • Guarde em cache no browser e no servidor, evitando que dados pedidos repetidamente precisem de ser processados de cada vez. A cache de página integral consegue reduzir o TTFB de vários segundos para menos de 100 ms. O guia de otimização da duração da cache explica os pormenores.
  • Renderize pequenos blocos personalizados no cliente ou na edge. A contagem do carrinho, o estado de início de sessão ou um ajuste pontual no menu não devem deitar a perder a cache da página completa. Preserve a cache de página integral e preencha estes detalhes no client-side ou através de edge rendering.
  • Afine o servidor web: parâmetros de keep-alive, contagem de worker processes, afetação de memória e limites de timeout. Um servidor mal parametrizado esbanja recursos e responde com lentidão.
  • Utilize uma Content Delivery Network (CDN). O conteúdo estático é servido a partir de nós edge (servidores) na proximidade do visitante, o que encurta o trajeto dos dados e agiliza o carregamento a nível global. Por regra, uma CDN está também melhor configurada do que um servidor caseiro. Aceda ao guia sobre configuração do Cloudflare para um roteiro prático.
  • Faça menos trabalho por pedido. Processe previamente as tarefas mais pesadas, recorra a algoritmos eficientes e transfira tudo o que não seja essencial para tarefas em segundo plano. De seguida, percorra novamente o ciclo de vida dos pedidos da aplicação e elimine cada etapa que não seja indispensável.
  • Adote HTTP/3. O protocolo QUIC estabelece a ligação num só round trip, quando o TCP somado ao TLS requer dois ou mais, e a perda de um pacote deixa de bloquear os outros pedidos nessa mesma ligação. A melhoria sente-se com especial clareza nas redes móveis. O ganho dá-se na ligação, pelo que surge no TTFB e, por via deste, no LCP. A visita inaugural decorre muitas vezes ainda sobre HTTP/2, dado que o browser só fica a conhecer o HTTP/3 através do cabeçalho Alt-Svc ou de um registo HTTPS no DNS. Veja mais sobre otimização da duração da ligação.
  • Inclua cabeçalhos Server-Timing. Informam sobre a duração de cada fase de processamento no servidor para determinada página, revelando o estrangulamento para concentrar esforços onde o Largest Contentful Paint (LCP) está a ser penalizado. Pode consultá-los no separador Network das Chrome DevTools, e ferramentas de RUM como o CoreDash conseguem agregá-los.
  • Registe queries lentas à base de dados e resolva-as com regularidade. Ative o registo de slow queries (os principais sistemas de bases de dados dispõem desta opção) e analise o ficheiro semanalmente. Melhores índices, reescrita de queries e uma camada de cache para as mais recorrentes conseguem reduzir o TTFB drasticamente.
  • Comprima ficheiros de texto (HTML, CSS, JavaScript) com GZIP ou, ainda melhor, Brotli. O servidor comprime-os em tempo real antes de enviar, ficando cerca de 70% mais leves. O Brotli garante habitualmente uma compressão 15 a 20% superior à do GZIP.

Otimizar a interatividade

O Interaction to Next Paint (INP) mede a rapidez com que o site responde às interações do utilizador. Um INP fraco decorre habitualmente de long tasks de JavaScript que bloqueiam a main thread. Cada uma das três fases do INP tem um guia autónomo: input delay, processing time e presentation delay.

  • Adote o padrão idle-until-urgent para scripts pesados. As operações críticas são executadas primeiro e o JavaScript dispensável aguarda até a main thread estar ociosa, evitando que a renderização e o input do utilizador fiquem bloqueados por scripts morosos. Programe o trabalho não urgente com requestIdleCallback e, se o resultado for pedido antes, execute-o logo. Saiba mais sobre otimização do processing time.
  • Divida long tasks fazendo yielding para a main thread. Uma long task bloqueia a main thread e a página deixa de responder. Divida o processamento em blocos menores e devolva o controlo ao browser entre eles, permitindo-lhe processar um clique ou uma tecla nessas pausas. Use scheduler.yield() onde estiver disponível ou recorra a setTimeout(0). Veja o guia sobre como melhorar o INP ao dispensar o scrolling com JavaScript.
  • Pinte o feedback antes do processamento pesado. O INP conta até ao paint seguinte, logo altere primeiro o estado do botão ou mostre um spinner; depois faça yield (scheduler.yield() ou setTimeout) e execute a parte exigente em seguida. Um estilo :active ou uma transição em CSS só surgem quando a main thread está desimpedida para os pintar; um event handler que monopolize a thread bloqueia essa resposta visual juntamente com o resto da página.
  • Torne os listeners de scroll e touch passivos recorrendo a { passive: true }. Isto garante ao browser que o handler nunca irá chamar preventDefault(), permitindo desencadear o scroll de imediato em vez de ficar à espera do JavaScript. O ganho é evidente no telemóvel. O scroll propriamente dito não conta como interação mensurável para o INP, pelo que a meta aqui reside na fluidez de scroll e não na pontuação de INP.

Monitorização dos Core Web Vitals

Monitorize continuamente os Core Web Vitals: só assim deteta regressões atempadamente e confirma se um fix surtiu o efeito previsto. Os valores de field data no p75 são os determinantes; testes de lab data servem para apurar as causas. Comece pelo p75 de cada métrica no telemóvel, pelos conjuntos de páginas assinalados no Search Console e pela trajetória nas últimas semanas: uma quebra abrupta sinaliza habitualmente um deploy, ao passo que uma degradação lenta reflete scripts de terceiros a acumularem-se aos poucos.

  • Execute o Lighthouse com frequência. Trata-se da ferramenta gratuita e open source da Google para auditar problemas de performance numa página. O Lighthouse não mede os Core Web Vitals com a perceção exata dos utilizadores reais, mas é ideal para testar e aferir o site sempre sob condições padronizadas. Um teste vulgar de Lighthouse não afere o INP de todo, uma vez que ninguém clica na página durante a análise; o Total Blocking Time é a métrica mais aproximada. Integre o Lighthouse no pipeline de CI/CD para intercetar regressões antes de irem para produção.
  • Examine o histórico do CrUX regularmente. O CrUX (Chrome User Experience Report) é a base de dados pública da Google com métricas de desempenho real, sendo o critério que a Google utiliza para aprovar ou chumbar um site nos Core Web Vitals. Cada número no CrUX traduz o p75 dos últimos 28 dias; por isso, uma regressão instala-se subtilmente ao longo de semanas e um fix demora cerca de quatro semanas a refletir-se integralmente. O PageSpeed Insights apenas divulga os 28 dias correntes; o historial completo está disponível no CrUX Vis e na CrUX History API.
  • Implemente rastreio com RUM. O Real User Monitoring mede o tempo real que as páginas demoram para os visitantes, nas respetivas localizações e nos seus dispositivos. O Lighthouse opera em laboratório e o CrUX resume o p75 dos últimos 28 dias sem discriminar qual o elemento ou script culpado. O RUM preenche essa lacuna. Recomendo o CoreDash, concebido por mim expressamente para obter dados detalhados de atribuição nos Core Web Vitals.
  • Estipule performance budgets: metas palpáveis por métrica no p75 em telemóvel, como por exemplo LCP abaixo de 2,5 segundos, INP inferior a 200 ms e CLS inferior a 0,1. Avalie as métricas frequentemente face a estas balizas para detetar de imediato o que requer intervenção prioritária.
  • Segmente os dados recolhidos. Analise de forma isolada os tipos de utilizador mais valiosos e as diferentes tipologias de página, já que o volume global de tráfego consegue mascarar problemas pontuais que afetam apenas esses segmentos. Separe inicialmente por dispositivo e template de página; trate da velocidade de ligação e país logo a seguir.

Otimizar o critical rendering path

O critical rendering path abrange todas as operações do browser para converter HTML e CSS (e JavaScript) em píxeis no ecrã. Um percurso mais expedito traduz-se num First Contentful Paint mais célere e em menor LCP element render delay. Consulte igualmente como evitar um DOM com dimensão excessiva.

  • Reduza o total de recursos críticos. Todo e qualquer recurso render blocking — quer seja CSS ou JavaScript síncrono — tem de ser descarregado e processado antes de o browser pintar o ecrã. Difira os scripts prescindíveis e mantenha as folhas de estilos em quantidade mínima e com tamanho contido.
  • Organize a sequência correta de carregamento: primeiro as folhas de estilos, depois a imagem do LCP e as fontes utilizadas no primeiro ecrã, logo a seguir as outras imagens acima da dobra e, por último, os scripts diferidos. O atributo fetchpriority e os resource prioritization hints esclarecem o browser sobre o que é prioritário.
  • Mantenha a árvore do DOM pouco profunda. Um aninhamento excessivo acarreta mais cálculos de estilo e mais esforço de layout. Procure não ultrapassar 32 níveis e menos de 1500 elementos no total, se viável; um DOM mais raso pinta mais depressa e favorece o INP presentation delay.
  • Dê preferência a classes e IDs face a tags de elementos e atributos nos seletores. Escreva .important em vez de p.important para poupar verificações ao browser durante o style matching, recalculando os estilos mais rapidamente.
  • Não aninhe seletores profundamente. Cada nível extra obriga o browser a mais trabalho. Reestruture o HTML para diminuir o aninhamento ou atribua uma classe mais direta ao elemento, limitando-se a 3 níveis no máximo.
  • Reduza os seletores descendentes. Um seletor como .container .content força o browser a percorrer os elementos ascendentes de cada .content à procura do contentor. Aplicar uma classe diretamente no elemento pretendido resulta num matching mais rápido.
  • Agrupe seletores que partilham estilos numa só classe ou utilize a convenção BEM (Block Element Modifier). A manutenção simplifica-se e o CSS fica mais condensado.

Otimizar o consentimento de cookies

O RGPD e regulamentos equivalentes impõem um aviso de consentimento de cookies, mas um aviso carregado sem critério pode atrasar o LCP, gerar CLS e degradar o INP. Para mais informação, consulte como otimizar widgets de terceiros para os Core Web Vitals.

  • Renderize o aviso de consentimento no servidor quando a página for gerada aí. Fica logo integrado na resposta HTML inicial, sendo habitualmente mais rápido do que uma solução externa em JavaScript: poupa um pedido de rede adicional e prescinde de avaliar scripts.
  • Carregue o script de consentimento com async em páginas em cache e equacione usar fetchpriority="high" para assegurar que surge antes de qualquer interação do visitante.
  • Exiba o aviso sob a forma de overlay com posição fixa. Um aviso embutido no topo da página empurra a estrutura inferior para baixo, provocando um layout shift em cada visita inicial. Fixado na base do ecrã, sobrepõe-se ao conteúdo sem deslocar nada.
  • Aloje localmente os scripts e as folhas de estilos do aviso de cookies e defina a respetiva cache. Evita pesquisas de DNS e o estabelecimento de ligações à plataforma de gestão de consentimento, mantendo o controlo absoluto do carregamento.

Otimizar Single Page Applications

Single Page Applications (SPAs) criadas com React ou Vue enfrentam obstáculos específicos nos Core Web Vitals: a renderização client-side atrasa quer o FCP quer o LCP, e a hidratação pode paralisar o INP.

  • Opte invariavelmente por server-side rendering ou prerendering. Uma SPA renderizada estritamente no cliente obriga o browser a descarregar e a executar todo esse JavaScript antes de qualquer elemento estar visível. Com SSR (Next.js, Nuxt, SvelteKit) ou prerendering estático, fornece HTML que o browser pinta de imediato.
  • Prefira prerenders estáticos em detrimento de opções dinâmicas. O prerender estático é produzido no momento do build e distribuído diretamente por CDN sem consumo de CPU no servidor, tornando-se incomparavelmente mais rápido do que um cálculo por pedido. Reserve a geração estática para todas as páginas que dispensem dados em tempo real por pedido.
  • Carregue scripts de terceiros após a hidratação. A hidratação consome já considerável tempo de main thread para dotar a página de interatividade, e executar scripts externos em paralelo agrava o input delay. Difira todos os scripts dispensáveis até a hidratação estar totalmente concluída.

Evitar tamanho excessivo do DOM

Um DOM volumoso (com mais de 1500 elementos ou além de 32 níveis de profundidade) esgota memória, arrasta o cálculo de estilos e provoca reflows onerosos no layout. O reflexo surge no INP presentation delay e nas métricas de paint. Veja como solucionar o tamanho excessivo do DOM.

  • Elimine nós supérfluos do DOM. Procure elementos contentores (wrappers) inúteis para o estilo ou estrutura e substitua sequências de <div> profundamente aninhadas por HTML semântico. Listagens extensas devem ser virtualizadas através de bibliotecas como react-window ou virtual-scroller, preservando um DOM em memória compacto.
  • Mantenha seletores e interrogações ao DOM eficientes. Seletores de CSS intricados e pesquisas genéricas em JavaScript (um querySelectorAll abrangente, por exemplo) perdem performance à medida que o DOM cresce. Empregue seletores de classe cirúrgicos e circuncreva cada pesquisa a uma subárvore sempre que possível.
  • Utilize content-visibility: auto em blocos fora do ecrã. O browser poupa a renderização desses elementos até que surjam no campo visual após scroll, reduzindo expressivamente o esforço gráfico inicial em páginas com secções compridas.

Otimizar pedidos de API

Chamadas a APIs que bloqueiem a renderização ou adiem a exibição de conteúdos penalizam o LCP e o TTFB; em single page applications, o carregamento de dados no cliente constitui um dos motivos clássicos para um LCP lento.

  • Reduza o volume de pedidos a APIs. Cada chamada pesa no carregamento da página, pelo que deve filtrar o que a visualização inicial estritamente requer e cortar os restantes. O agrupamento em lote (batching) e o recurso a GraphQL poupam round trips.
  • Assegure que as próprias APIs respondem com rapidez. A arquitetura de uma API condiciona a página que fica na sua dependência. Aplique cache do lado da API para informação solicitada com frequência.
  • Faça preload de pedidos críticos de API com <link rel="preload" as="fetch" crossorigin>. À semelhança do preload de imagens, despoleta o pedido prematuramente para que a informação esteja acessível quando a renderização inaugural a exigir. Se prescindir de crossorigin, o preload não coincidirá com a invocação de fetch() e o browser descarregará a informação em duplicado. O guia de priorização de recursos aprofunda outras técnicas.

Otimizar widgets de chat

Widgets de chat são detonadores habituais de layout shifts e podem inclusivamente prejudicar o LCP se arrancarem prematuramente. Para uma implementação passo a passo, veja como instalar um widget de chat com Core Web Vitals perfeitos.

  • Inicie o widget de chat unicamente após o conteúdo central ter carregado. Ninguém em toda a história da internet precisou de entrar num chat antes de visualizar o conteúdo principal da página. Dispare-o após a renderização inicial, através de requestIdleCallback ou quando o visitante efetuar scroll.
  • Oculte o widget de chat até estar operacional. Caso provoque um layout shift, mantenha-o com opacity: 0 até completar a renderização; assim calcula a sua geometria em background sem movimentar o conteúdo visível. Posteriormente, aplique um fade in mediante uma transição de CSS.
  • Pesquise e selecione um widget de chat ligeiro. Certas soluções geram substancialmente menos entraves nos Core Web Vitals do que a concorrência. Antes de escolher, meça o tamanho do bundle de JavaScript, a quantidade de pedidos de rede e o impacto no INP de cada fornecedor.

Otimizar o desempenho do service worker

Um service worker tem capacidade para acelerar enormemente visitas repetidas mediante a colocação em cache de assets e páginas inteiras, encurtando o TTFB para quem regressa. Mal estruturado, acaba pelo contrário por degradar a navegação. Saiba mais acerca da otimização da duração da cache.

  • Guarde os assets críticos em cache no service worker. Uma abordagem cache-first destinada a ficheiros estáticos (CSS, JavaScript, fontes, imagens) faculta aos utilizadores habituais o carregamento do site quase imediato a partir da cache local. Efetue o precache dos recursos essenciais durante o evento install.
  • Mantenha o código do service worker enxuto. Regras intrincadas de routing, abuso de event.waitUntil() e um manifesto desmedido de precache arrastam a instalação. Para recursos sujeitos a alterações regulares, mas que não careçam de frescura no exato instante da modificação, use stale-while-revalidate.

Otimizar conteúdo de vídeo

Um vídeo assume o papel de elemento do LCP caso consista no maior conteúdo visível na viewport; em simultâneo, um ficheiro pesado canibaliza a largura de banda de outros recursos críticos.

  • Comprima os vídeos recorrendo a codecs modernos (H.264, VP9 ou AV1) com um patamar de qualidade equilibrado. Codifique à escala em que o vídeo é exibido: um vídeo apresentado a 400px de largura não deve ser gerado a 1920px. A codificação em dois passos (two-pass) oferece a melhor rentabilidade visual por peso de ficheiro.
  • Aplique lazy loading aos vídeos situados abaixo da dobra. Aplique loading="lazy" num <iframe> ou trave o vídeo via Intersection Observer API. Substitua vídeos de background com reprodução automática por uma imagem de poster, despoletando o carregamento do vídeo unicamente quando o visitante fizer scroll para as suas imediações.
  • Aloje vídeos numa CDN célere. Ficheiros de vídeo são volumosos e tiram proveito substancial da distribuição por CDN. Uma CDN especializada em vídeo ou um serviço dedicado de streaming (Cloudflare Stream, Mux, Bunny.net) agrega ainda adaptive bitrate streaming, dispersão geográfica e entrega otimizada.
  • Configure obrigatoriamente o atributo poster nos elementos <video>. O browser pinta a imagem de poster no imediato enquanto o vídeo descarrega, podendo essa imagem corresponder ao elemento de LCP; trate por isso de a otimizar como faria com qualquer outra imagem do LCP.

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 KarelCore Web Vitals a vermelho em mobile?Envie-me o seu URL