A checklist definitiva dos Core Web Vitals (2026)
Todas as otimizações a verificar ao melhorar o desempenho do LCP, INP e CLS
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.

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
srcsetnas imagens, com o atributosizespara 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: swapnas regras@font-facepara 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: optionalcom 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-overrideeline-gap-overrideno 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
pyftsubsete oglyphhangerfazem-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
asyncoudefer. 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
@importdo 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
widtheheightnos 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-Svcou 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
requestIdleCallbacke, 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 asetTimeout(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()ousetTimeout) e execute a parte exigente em seguida. Um estilo:activeou 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á chamarpreventDefault(), 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
fetchprioritye 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
.importantem vez dep.importantpara 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 .contentforç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
querySelectorAllabrangente, 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: autoem 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 decrossorigin, o preload não coincidirá com a invocação defetch()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
requestIdleCallbackou quando o visitante efetuar scroll. - Oculte o widget de chat até estar operacional. Caso provoque um layout shift, mantenha-o com
opacity: 0até 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
posternos 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.

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
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 URLSem programador para fazer o fix? Faço eu o trabalho, numa cópia do seu site.