O checklist definitivo de Core Web Vitals (2026)

Todas as otimizações que você deve conferir ao melhorar o desempenho do LCP, INP e CLS

Arjen Karel Core Web Vitals Consultant
Arjen Karel - linkedin
Last update: 2026-11-04

O checklist definitivo de Core Web Vitals

Este checklist de Core Web Vitals cobre todas as otimizações necessárias antes de colocar um site no ar, ao trabalhar no Largest Contentful Paint (LCP), Interaction to Next Paint (INP) ou Cumulative Layout Shift (CLS), e após qualquer grande mudança no site. Assim, você garante que as páginas fiquem rápidas e estáveis o bastante para passar na avaliação de Core Web Vitals do Google.

Mantenho este checklist atualizado conforme aprendo coisas novas. Faltou algo? Me avise.

Métricas do Core Web Vitals: carregamento do LCP abaixo de 2,5 s, interatividade do INP abaixo de 200 ms, estabilidade do CLS abaixo de 0,1

Checklist de otimização de Core Web Vitals

Avance seção por seção, começando pela métrica que falha no p75 no celular. Cada seção traz um link para o guia detalhado, permitindo entender por que o item importa antes de alterar qualquer coisa.

Otimize imagens

Uma imagem grande na viewport visível geralmente se torna o elemento do Largest Contentful Paint. Isso torna o trabalho com imagens uma das ações mais eficazes para o LCP. Para conferir a estratégia completa, leia como otimizar a imagem do LCP.

  • Redimensione as imagens para o tamanho máximo em que são exibidas na tela. Cada byte gasto em pixels invisíveis é desperdiçado, e imagens com o tamanho correto costumam ser 50% menores ou mais, sem perda perceptível de qualidade. Combine isso com imagens responsivas para telas menores.
  • Aplique lazy loading nas imagens abaixo da dobra. O navegador não as carrega até o visitante rolar a página para perto, liberando a largura de banda inicial para o conteúdo da tela — o que ajuda o First Contentful Paint (FCP) e o carregamento geral. Nunca use lazy loading na imagem do LCP: o navegador esperará pelo layout antes mesmo de iniciar o download.
  • Defina fetchpriority="high" na imagem do LCP e faça o preload apenas quando ela estiver oculta no HTML. Uma tag <img> no HTML já é encontrada pelo preload scanner; o atributo a move para a frente da fila. O preload com <link rel="preload" as="image" fetchpriority="high"> é para imagens de LCP definidas no CSS ou carregadas via JavaScript, que o navegador não consegue ver no HTML.
  • Defina width e height em todas as imagens. Navegadores modernos usam os dois atributos para calcular a proporção antes do carregamento da imagem, reservando o espaço exato e evitando que a página se mexa quando o arquivo chegar. É uma causa a menos de mudanças de layout.
  • Use WebP ou AVIF em vez de JPEG ou PNG. Com qualidade semelhante, um arquivo WebP costuma ser de 25 a 34% menor do que um JPEG, e o AVIF pode economizar até 50%. Um elemento <picture> com fallbacks garante suporte a todos os navegadores.
  • Use lazy loading nativo e desative qualquer lazy loading por JavaScript. O atributo loading="lazy" faz o mesmo trabalho sem precisar processar e executar um script primeiro.
  • Adicione srcset às imagens, com o atributo sizes para controle preciso. O navegador seleciona a imagem ideal para o dispositivo, e o celular deixa de baixar o arquivo feito para telas grandes de desktop.
  • Adicione decoding="async". O navegador decodifica a imagem em paralelo e continua renderizando o restante da página durante o processo.
  • Remova metadados das imagens. Dados EXIF e similares só adicionam bytes, e removê-los não afeta a qualidade da imagem. O ImageOptim e o Squoosh fazem isso manualmente, e o Sharp automatiza o processo no build.
  • Não use uma imagem de fundo em CSS para o elemento de LCP. O navegador encontra uma imagem de fundo no CSS bem mais tarde do que uma tag <img> no HTML. Se não houver outra opção, faça o preload com a tag <link rel="preload"> para que ela seja descoberta cedo. Saiba mais sobre o LCP resource load delay.

Otimize fontes web

Fontes web podem atrasar o First Contentful Paint, causar mudanças de layout e disputar a pouca largura de banda disponível no início do carregamento. O guia sobre hospedar Google Fonts no próprio servidor explica onde manter os arquivos.

  • Defina font-display: swap nas regras @font-face para antecipar o primeiro paint. O navegador exibe uma fonte de fallback imediatamente e carrega a fonte web em segundo plano, aplicando a troca assim que estiver pronta. Leia mais sobre como garantir que o texto permaneça visível durante o carregamento de webfonts.
  • Combine font-display: optional com preload para eliminar mudanças de layout causadas por fontes. Com optional, o navegador espera cerca de 100 ms pela fonte web; se ela não chegar nesse intervalo, a fonte de fallback é mantida naquela visualização e nada se desloca. O preload torna muito mais provável que a fonte chegue dentro dessa janela.
  • Ajuste as dimensões da fonte de fallback para corresponderem às da fonte web usando descritores font-face. Configure size-adjust, ascent-override, descent-override e line-gap-override no fallback; o texto quase não se mexe quando a fonte web for aplicada, mantendo o CLS mínimo.
  • Faça subsetting das fontes apenas com os caracteres que o conteúdo usa. Uma fonte latina completa de mais de 100 KB costuma cair para menos de 20 KB após o subsetting correto. O Font Squirrel gera subsets online; pyftsubset e glyphhanger fazem isso na linha de comando.
  • Limite o número de pesos e estilos de fonte. Cada peso extra adiciona de 15 a 50 KB ao download. Limite-se a no máximo 2 fontes críticas (normalmente com preload) e 2 que carreguem depois, após a primeira renderização.

Otimize scripts

Scripts podem causar problemas de Interaction to Next Paint, provocar Cumulative Layout Shifts ou atrasar o Largest Contentful Paint. Mesmo um script pequeno e bem comportado no início da página disputa recursos e atrasa as métricas de pintura (LCP e FCP). Todas as opções disponíveis estão em 14 métodos para adiar JavaScript.

  • Remova o JavaScript que não é necessário. A aba Coverage do Chrome DevTools mostra o código não utilizado; cada trecho de código morto eliminado economiza tempo de download e de main thread.
  • Priorize scripts pelo que fazem. Um script que faz grandes mudanças na viewport visível deve ser render blocking. Scripts importantes devem ser adiados ou carregados como async, e os dispensáveis esperam até o navegador ficar ocioso. O guia de priorização de recursos traz a estratégia detalhada.
  • Divida o código e aplique lazy loading nas partes secundárias. Quebre bundles grandes de JavaScript em pedaços menores que carregam só quando necessários, aliviando o primeiro carregamento. Qualquer empacotador moderno (webpack, Rollup, esbuild) divide o código automaticamente com imports dinâmicos.
  • Minifique e recompile os arquivos JavaScript sempre, com ferramentas como SWC, Terser ou esbuild. Isso costuma reduzir de 30 a 50% do tamanho do arquivo.
  • Limite scripts de terceiros. Cada um adiciona consultas DNS, overhead de conexão e tempo de main thread; avalie se ele é realmente necessário e se existe alternativa mais leve. Verifique esses scripts periodicamente no painel Network do Chrome DevTools.
  • Carregue scripts de terceiros com async ou defer. Não dá para prever o que um serviço de terceiros fará; nunca deixe que ele bloqueie a renderização.
  • Monitore o custo dos scripts de terceiros para os visitantes reais. A API Long Animation Frames (LoAF) ou o CoreDash mostram o impacto no INP e no LCP em field data. Defina um orçamento de desempenho para JavaScript de terceiros e revise-o com frequência.

Otimize estilos

Estilos bloqueiam a renderização por padrão; assim, toda folha de estilo no head atrasa o First Contentful Paint e aumenta o LCP element render delay. Mantenha as folhas de estilo pequenas e separadas, e dispense truques para dividir o CSS em dois. Para dicas de remoção de estilos não utilizados, veja como remover CSS não utilizado.

  • Minifique o CSS. Use cssnano ou PostCSS, ou a compressão nativa do pré-processador de CSS, para remover espaços em branco e comentários. É de graça, então faça, mas isso poupa poucos kilobytes e nenhum visitante vai notar.
  • Remova o CSS que as páginas não usam. Menos CSS significa menos dados para baixar e processar. O PurgeCSS ou a aba Coverage do Chrome DevTools ajudam a localizar CSS não utilizado. Faça isso no próprio build e deixe desligado o recurso de remover CSS não utilizado de plugins como WP Rocket, Perfmatters ou LiteSpeed: ele causa tanta dor de cabeça quanto o CSS crítico.
  • Não coloque CSS inline e evite CSS crítico. O CSS inline aumenta o HTML — e o HTML é o arquivo pelo qual todo o restante espera. O navegador geralmente também não consegue armazenar esse HTML em cache; assim, cada visualização de página baixa o mesmo CSS de novo, enquanto uma folha de estilo separada vem do cache a partir da segunda página. O CSS crítico economiza uma viagem de ida e volta na primeira visita, mas o restante do CSS chega depois da primeira pintura: o resultado é recálculo de estilos, repaint e, com frequência, uma mudança de layout.
  • Mantenha cada folha de estilo render blocking abaixo de cerca de 15 KB comprimida. Isso é aproximadamente o que cabe no primeiro round trip de uma nova conexão; encare esse valor como um teto a ser perseguido. Uma cascata de Slow 4G mostra dois jeitos de errar: uma folha de estilo de 60 KB demora demais, e uma fila de arquivos de 0,3 KB paga o tempo de início de conexão a cada requisição. Una os arquivos minúsculos e divida ou enxugue o maior.
  • Não transforme o carregamento assíncrono de CSS em hábito. O truque do media="print" só funciona para CSS que você tem certeza absoluta de que nunca é usado na primeira tela — e quase nunca dá para ter essa certeza. Separar o CSS da primeira tela do resto é apenas CSS crítico com outro nome.
  • Remova todo @import do CSS. Cada um inicia uma cadeia de folhas de estilo que o navegador só consegue buscar em sequência, e o preload scanner não enxerga os arquivos no fim da fila. Vincule-os pelo HTML ou junte-os durante o build.

Otimize resource hints

Resource hints ajudam o navegador a baixar recursos críticos primeiro. Um arquivo com preload geralmente entra na fila e fica disponível muito antes do que ficaria sem o hint. Usados corretamente, os hints reduzem o LCP resource load delay; para a versão avançada, leia sobre 103 Early Hints.

  • Remova hints de recursos que não são necessários na primeira visualização. A largura de banda inicial é escassa; qualquer preload ou conexão desnecessária rouba parte dela dos arquivos que realmente importam.
  • Faça preconnect para os domínios necessários logo no início, como CDNs ou provedores de fontes. A consulta DNS, a conexão TCP e o handshake TLS ficam concluídos antes do envio da primeira requisição para esse domínio. Use <link rel="preconnect" href="https://example.com"> para origens críticas de terceiros.
  • Considere o DNS prefetch quando o preconnect for exagero. O preconnect estabelece a conexão inteira, enquanto <link rel="dns-prefetch"> apenas resolve o domínio com antecedência. Isso basta para um domínio do qual você provavelmente precisará mais tarde, quando o custo de uma conexão completa ainda não vale a pena.
  • Faça o preload da imagem do LCP quando ela não estiver no HTML. O LCP mede quanto tempo o conteúdo principal leva para aparecer, e o preload do elemento LCP move esse recurso para a frente da fila. Para uma tag <img> que já está no HTML, o atributo fetchpriority="high" faz o mesmo sem precisar de tag adicional.
  • Faça preload de fontes críticas com <link rel="preload" as="font" type="font/woff2" crossorigin>. O navegador as busca mais cedo, exibindo o texto antes e diminuindo o risco de mudanças de layout na troca de fontes.
  • Envie resource hints como 103 Early Hints sempre que puder. Com o 103, o servidor envia os hints antes mesmo de a resposta completa ficar pronta — o momento mais precoce em que o navegador pode descobrir um recurso. Se o servidor não for compatível com 103, use cabeçalhos de resposta Link; se cabeçalhos também não forem uma opção, inclua elementos <link> no <head> da página como fallback.
  • Faça preload de fontes antes que o CSS as descubra. Uma fonte referenciada no CSS só é encontrada depois que o CSS foi baixado e processado. Um preload no <head> do HTML elimina essa espera, a fonte carrega em paralelo, e tanto o FCP quanto o risco de mudanças de layout diminuem.

Otimize ícones

É fácil cometer excessos com ícones: carregar um pacote completo para usar cinco ícones na página. Ícones grandes em SVG inline inflam o HTML, e uma fonte de ícones costuma trazer milhares de glifos nunca utilizados. Tratar ícones corretamente melhora o LCP (menos HTML e CSS para carregar) e o CLS (espaço reservado para cada ícone).

  • Não coloque ícones SVG grandes inline no HTML. Eles aumentam o tamanho do HTML, deixam a página mais lenta e não podem ser armazenados em cache de forma isolada. Um sprite sheet externo de SVG geralmente oferece o melhor equilíbrio entre desempenho e flexibilidade, embora arquivos individuais ou uma fonte de ícones (com cautela) também mantenham o HTML enxuto.
  • Nunca carregue um pacote grande como o Font Awesome por inteiro. O conjunto completo pode ultrapassar 100 KB, enquanto um subset com 20 ícones fica abaixo de 5 KB. Crie um subset em uma fonte menor ou use arquivos SVG individuais.
  • Reserve largura e altura para os ícones, assim como nas imagens. O navegador mantém o espaço reservado e os ícones não provocam mudanças de layout ao carregar. Defina os atributos width e height nos elementos SVG ou determine dimensões explícitas no CSS.
  • Não faça preload nem insira inline ícones dispensáveis na primeira tela, deixando o conteúdo essencial carregar primeiro. Aplique lazy loading nos ícones que ficam abaixo da dobra.

Otimize o tempo de resposta do servidor

O tempo de resposta do servidor, medido como Time to First Byte (TTFB), vem antes de qualquer métrica de pintura; um servidor lento atrasa tudo o que vem a seguir. Para estratégias detalhadas, veja os guias sobre como diagnosticar problemas de TTFB e como configurar o Cloudflare para alto desempenho.

  • Escolha um serviço de hospedagem rápido, confiável e com infraestrutura sólida. Compare os provedores pelo TTFB medido por você no mundo real. Os números de peças de marketing são sintéticos.
  • Monitore o tempo que o código e as consultas ao banco levam para rodar, e faça isso com frequência. Ferramentas de profiling de queries e monitoramento de desempenho de aplicações (APM) apontam diretamente para os endpoints lentos.
  • Configure cache no navegador e no servidor, evitando que dados requisitados com frequência precisem ser buscados do zero toda vez. O cache de página inteira pode reduzir o TTFB de vários segundos para menos de 100 ms. O guia de otimização da duração do cache traz os detalhes.
  • Renderize pequenos blocos personalizados no cliente ou na edge. Contagem de itens no carrinho, status de login ou uma pequena alteração no menu não devem invalidar o cache da página toda. Mantenha o cache de página inteira e preencha esses detalhes no client-side ou com renderização na edge.
  • Ajuste o servidor web: configurações de keep-alive, quantidade de worker processes, alocação de memória e valores de timeout. Um servidor mal configurado desperdiça recursos e responde mais devagar.
  • Use uma CDN (Content Delivery Network). Ela distribui o conteúdo estático a partir de nós de borda (servidores) próximos ao visitante, encurtando a distância percorrida pelos dados e acelerando o carregamento para visitantes do mundo todo. Uma CDN costuma ser também mais bem configurada que um servidor próprio. Consulte o guia sobre configuração do Cloudflare para um passo a passo prático.
  • Reduza o processamento por requisição. Pré-calcule operações pesadas, utilize algoritmos eficientes e envie o que não for essencial para tarefas em segundo plano. Depois, examine mais uma vez o ciclo de vida das requisições na aplicação e elimine qualquer etapa dispensável.
  • Use HTTP/3. O QUIC estabelece a conexão em um único round trip, enquanto TCP com TLS precisa de dois ou mais, e a perda de um pacote não trava as demais requisições na mesma conexão. Isso faz a maior diferença em redes móveis. O ganho acontece na conexão, refletindo no TTFB e, através dele, no LCP. A primeira visita costuma ainda ocorrer via HTTP/2, pois o navegador descobre o HTTP/3 pelo cabeçalho Alt-Svc ou por um registro DNS HTTPS. Veja mais em otimização da duração da conexão.
  • Adicione cabeçalhos Server-Timing. Eles informam quanto tempo cada etapa do processamento no servidor levou para a página, permitindo identificar gargalos e atuar na parte que atrasa o Largest Contentful Paint (LCP). Você pode visualizá-los no painel Network do Chrome DevTools, e ferramentas de RUM como o CoreDash conseguem coletá-los.
  • Registre consultas lentas no banco de dados e resolva-as com frequência. Ative o log de queries lentas (todos os principais bancos contam com isso) e avalie o registro toda semana. Índices melhores, consultas reescritas e uma camada de cache para as requisições frequentes reduzem bastante o TTFB.
  • Comprima arquivos de texto (HTML, CSS, JavaScript) com GZIP ou, de preferência, Brotli. O servidor compacta esses arquivos dinamicamente antes do envio, gerando uma redução de cerca de 70%. O Brotli costuma compactar de 15 a 20% melhor que o GZIP.

Otimize a interatividade

O Interaction to Next Paint (INP) mede a velocidade de resposta do site às interações dos usuários. Um INP ruim geralmente é resultado de long tasks em JavaScript que bloqueiam a main thread. Cada uma das três fases do INP tem seu próprio guia: input delay, processing time e presentation delay.

  • Use o padrão idle-until-urgent em scripts pesados. O trabalho crítico roda primeiro e o JavaScript secundário espera até a main thread ficar livre; assim, a renderização e as entradas do usuário nunca ficam travadas atrás de um script longo. Agende tarefas secundárias com requestIdleCallback e, se o resultado for necessário antes, execute na hora. Saiba mais sobre como otimizar o processing time.
  • Divida long tasks fazendo yield para a main thread. Uma long task bloqueia a main thread e a página para de responder. Divida a tarefa em blocos menores e devolva o controle ao navegador entre eles, permitindo que ele processe cliques ou digitação nos intervalos. Use scheduler.yield() onde houver suporte, ou setTimeout(0). Consulte o guia sobre como melhorar o INP eliminando a rolagem por JavaScript.
  • Exiba o feedback visual antes do processamento pesado. O INP conta o tempo até o próximo paint; portanto, altere o estado do botão ou mostre um indicador de carregamento primeiro, faça o yield (scheduler.yield() ou setTimeout) e execute a parte pesada depois. Um estilo :active ou uma transição em CSS só aparecem quando a main thread está livre para renderizar; um handler que ocupa a thread congela esses elementos junto com o restante da página.`
  • Defina os listeners de scroll e toque como passivos com { passive: true }. Isso avisa ao navegador que o handler nunca chamará preventDefault(), liberando o início imediato da rolagem sem ter que esperar pelo JavaScript. A diferença é sentida principalmente no celular. A rolagem em si não é uma interação medida pelo INP; trata-se de fluidez de rolagem, e não do índice do INP diretamente.

Monitoramento de Core Web Vitals

Continue monitorando os Core Web Vitals: é assim que você detecta regressões cedo e confirma se um ajuste funcionou como esperado. O que vale é o field data no p75; testes em laboratório ajudam a descobrir o porquê. Comece pelo p75 de cada métrica no celular, pelos grupos de páginas sinalizados no Search Console e pela tendência das últimas semanas: uma queda brusca costuma apontar para um deploy, enquanto uma queda gradual geralmente reflete o acúmulo contínuo de scripts de terceiros.

  • Execute o Lighthouse com frequência. Ele é a ferramenta gratuita e de código aberto do Google para encontrar problemas de desempenho em páginas. O Lighthouse não mede os Core Web Vitals da forma como usuários reais os vivenciam, mas é ótimo para testar e comparar o site sempre nas mesmas condições padronizadas. Um teste padrão do Lighthouse não mede o INP de forma alguma, já que ninguém clica em nada durante a execução; o Total Blocking Time é a aproximação mais próxima disponível. Coloque o Lighthouse na esteira de CI/CD para barrar regressões antes de irem para o ar.
  • Analise o histórico do CrUX regularmente. O CrUX (Chrome User Experience Report) é o conjunto de dados públicos do Google sobre desempenho no mundo real, e são esses dados que o Google usa para definir se o site passa nos Core Web Vitals. Cada número do CrUX representa o p75 dos últimos 28 dias; por isso, regressões avançam ao longo de semanas e correções levam cerca de quatro semanas para aparecer por completo. O PageSpeed Insights mostra apenas a janela atual de 28 dias; o histórico fica no CrUX Vis e na CrUX History API.
  • Configure o rastreamento por RUM. O Real User Monitoring mede quanto tempo as páginas realmente levam para os visitantes, nas localidades e nos dispositivos deles. O Lighthouse é um teste de laboratório e o CrUX fornece o p75 dos últimos 28 dias sem apontar qual elemento ou script causou o problema. O RUM preenche essa lacuna. Recomendo o CoreDash, que desenvolvi para obter dados detalhados de atribuição dos Core Web Vitals.
  • Defina orçamentos de desempenho: metas concretas por métrica no p75 no celular — por exemplo, LCP abaixo de 2,5 segundos, INP abaixo de 200 ms e CLS abaixo de 0,1. Monitore essas metas regularmente para ver na hora quais áreas exigem prioridade.
  • Segmente os dados. Acompanhe os perfis de visitantes mais valiosos e os tipos de página separadamente, pois o restante do tráfego pode esconder um problema que atinge apenas esses públicos. Separe primeiro por dispositivo e modelo de página; depois, avalie por velocidade de conexão e país.

Otimize o caminho crítico de renderização

O caminho crítico de renderização reúne todas as etapas pelas quais o navegador passa para transformar HTML e CSS (e JavaScript) em pixels na tela. Um caminho mais curto resulta em um First Contentful Paint mais rápido e menor LCP element render delay. Veja também como evitar tamanho excessivo de DOM.

  • Minimize a quantidade de recursos críticos. Todo recurso render blocking, seja CSS ou JavaScript síncrono, precisa ser baixado e processado antes de o navegador pintar a tela. Adie os scripts secundários e mantenha as folhas de estilo poucas e pequenas.
  • Acerte a ordem de carregamento: primeiro as folhas de estilo, depois a imagem de LCP e as fontes da primeira tela, seguidas pelas demais imagens acima da dobra e, por último, os scripts adiados. O atributo fetchpriority e as dicas de priorização de recursos dizem ao navegador o que mais importa.
  • Mantenha a árvore do DOM rasa. Aninhamento profundo significa mais cálculos de estilo e mais trabalho de layout. Busque não ultrapassar 32 níveis e mantenha o total abaixo de 1.500 elementos sempre que possível; um DOM mais raso renderiza mais rápido e reduz o INP presentation delay.
  • Prefira classes e IDs em vez de tags e atributos nos seletores. Escreva .important em vez de p.important; o navegador faz menos verificações no style matching e recalcula estilos mais rapidamente.
  • Evite seletores profundamente aninhados. Cada nível extra significa mais trabalho para o navegador. Reestruture o HTML para diminuir o aninhamento ou use uma classe mais específica mais perto do elemento, mantendo no máximo 3 níveis.
  • Reduza o uso de seletores descendentes. Um seletor como .container .content faz o navegador percorrer todos os ancestrais de cada elemento .content até encontrar o container. Uma classe aplicada diretamente no elemento resolve a correspondência mais rápido.
  • Agrupe seletores que compartilham os mesmos estilos em uma única classe ou adote o padrão BEM (Block Element Modifier). Isso facilita a manutenção e reduz o CSS.

Otimize o consentimento de cookies

O GDPR e regulamentações semelhantes exigem um banner de consentimento de cookies, mas um banner carregado sem cuidado pode atrasar o LCP, causar CLS e elevar o INP. Para mais detalhes, leia sobre como otimizar widgets de terceiros para os Core Web Vitals.

  • Renderize o banner de consentimento no servidor quando a página já for gerada lá. Ele chega na primeira resposta HTML, o que costuma ser mais rápido do que uma solução separada em JavaScript: nenhuma requisição extra de rede e nenhum script para processar.
  • Carregue o script de consentimento de forma assíncrona em páginas em cache e avalie usar fetchpriority="high" nele, garantindo que ele apareça antes de qualquer interação.
  • Exiba o banner como uma sobreposição em posição fixa. Um banner inserido no topo da página empurra todo o conteúdo para baixo, gerando uma mudança de layout em cada primeira visita. Fixado na parte inferior da tela, ele fica sobreposto ao conteúdo e nada se mexe.
  • Hospede os scripts e folhas de estilo do aviso de cookies no próprio servidor sempre que possível e configure cache. Você economiza as consultas DNS e as conexões com a plataforma de consentimento, mantendo o controle total sobre o carregamento.

Otimize Single Page Applications

Single Page Applications (SPAs) construídas com React ou Vue têm seus próprios problemas de Core Web Vitals: a renderização no cliente atrasa tanto o FCP quanto o LCP, e a hidratação pode travar o INP.

  • Sempre use renderização no servidor ou pré-renderização. Uma SPA que renderiza apenas no cliente faz o navegador baixar e executar todo o JavaScript antes que qualquer conteúdo fique visível. Com SSR (Next.js, Nuxt, SvelteKit) ou pré-renderização estática, você entrega HTML pronto para o navegador pintar de imediato.
  • Prefira pré-renderizações estáticas às dinâmicas. Uma página estática pré-renderizada é gerada no momento do build e servida diretamente de uma CDN, sem processamento no servidor, o que a torna muito mais rápida do que uma gerada a cada requisição. Use geração estática em todas as páginas que não precisarem de dados específicos por requisição.
  • Carregue scripts de terceiros após a hidratação. A hidratação já consome muito tempo da main thread para tornar a página interativa, e scripts de terceiros executados ao mesmo tempo pioram o input delay. Adie qualquer script não essencial até a hidratação terminar.

Evite tamanho excessivo de DOM

Um DOM grande (mais de 1.500 elementos ou profundidade superior a 32 níveis) consome mais memória, desacelera o cálculo de estilos e causa reflows caros de layout. O reflexo aparece no INP presentation delay e nas métricas de pintura. Veja como corrigir o tamanho excessivo de DOM.

  • Remova os elementos do DOM que você não usa. Procure elementos wrapper que não servem para estilização ou estrutura e troque blocos de <div> profundamente aninhados por HTML semântico. Listas longas podem ser virtualizadas com bibliotecas como react-window ou virtual-scroller, mantendo pequeno o DOM em execução.
  • Mantenha seletores e consultas ao DOM eficientes. Seletores CSS complexos e consultas genéricas em JavaScript (um querySelectorAll abrangente, por exemplo) ficam cada vez mais lentos conforme o DOM cresce. Use seletores de classe específicos e restrinja as consultas a uma subárvore sempre que possível.
  • Use content-visibility: auto para conteúdos fora da tela. O navegador pula a renderização desses elementos até que eles entrem na área visível, o que pode reduzir drasticamente o trabalho inicial de renderização em páginas com seções longas.

Otimize requisições de API

Requisições de API que bloqueiam a renderização ou seguram o conteúdo prejudicam o LCP e o TTFB; em single page applications, dados buscados no cliente são um dos motivos mais comuns para um LCP lento.

  • Faça menos requisições de API. Cada uma pesa no carregamento da página; analise o que a primeira tela realmente precisa e corte o resto. Batching (várias requisições combinadas em uma) e GraphQL economizam viagens de ida e volta.
  • Torne as próprias APIs rápidas. O design e a construção de uma API afetam a página que espera por ela. Adicione cache do lado da API para dados frequentemente solicitados.
  • Faça preload de requisições críticas de API com <link rel="preload" as="fetch" crossorigin>. Assim como no preload de imagens, a requisição começa mais cedo e os dados já estão disponíveis quando a primeira renderização precisa deles. Sem o crossorigin, o preload não corresponde à chamada fetch() e o navegador baixa os dados duas vezes. O guia de priorização de recursos traz mais técnicas.

Otimize widgets de chat

Widgets de chat são causas comuns de mudanças de layout e podem até atrasar o LCP se carregarem cedo demais. Para um passo a passo completo, leia como implementar um widget de chat com Core Web Vitals impecáveis.

  • Carregue o widget de chat depois do conteúdo principal. Ninguém na história da internet precisou do chat antes de a página carregar o conteúdo principal. Inicie-o após o primeiro render, com requestIdleCallback ou quando o visitante rolar a tela.
  • Mantenha o widget de chat oculto até que esteja pronto. Se ele causar mudança de layout, deixe-o com opacity: 0 até que a renderização termine; assim, ele monta a estrutura em segundo plano sem deslocar o conteúdo visível. Em seguida, aplique um fade in com transição CSS.
  • Procure um widget de chat leve. Algumas soluções causam muito menos problemas de Core Web Vitals do que outras. Antes de contratar, compare o tamanho do bundle JavaScript, a quantidade de requisições de rede e o impacto no INP de cada fornecedor.

Otimize o desempenho de service workers

Um service worker pode acelerar bastante visitas recorrentes fazendo cache de assets e até de páginas inteiras, o que reduz o TTFB para quem retorna ao site. Se for mal construído, ele faz o oposto e deixa a navegação lenta. Saiba mais sobre otimização da duração do cache.

  • Guarde assets críticos no cache do service worker. Uma estratégia de cache-first para assets estáticos (CSS, JavaScript, fontes, imagens) permite que visitantes recorrentes carreguem o site quase instantaneamente a partir do cache local. Faça o precache dos recursos mais importantes no evento install.
  • Mantenha o código do service worker enxuto. Lógica de roteamento complexa, uso excessivo de event.waitUntil() e manifestos de precache gigantes atrasam a instalação. Para recursos que mudam com frequência, mas não precisam estar atualizados no exato segundo da mudança, use stale-while-revalidate.

Otimize conteúdo em vídeo

O vídeo se torna o elemento LCP quando é o maior conteúdo visível na viewport — e um arquivo pesado também consome largura de banda de outros recursos críticos.

  • Comprima vídeos com um codec moderno (H.264, VP9 ou AV1) e um ajuste equilibrado de qualidade. Codifique no tamanho exato em que o vídeo será exibido: se aparece com 400 px de largura, não precisa ter 1920 px. Codificação em dois passos (two-pass) oferece a melhor qualidade para o tamanho do arquivo.
  • Faça lazy loading de vídeos abaixo da dobra. Use loading="lazy" no <iframe> ou segure o vídeo com a Intersection Observer API. Troque vídeos de fundo com autoplay por uma imagem de poster e carregue o vídeo apenas quando o visitante rolar a tela para perto dele.
  • Hospede vídeos em uma CDN rápida. Arquivos de vídeo são pesados e ganham muito com a distribuição via CDN. Uma CDN dedicada para vídeo ou serviço de hospedagem especializado (Cloudflare Stream, Mux, Bunny.net) acrescenta streaming com bitrate adaptativo, distribuição geográfica e entrega otimizada.
  • Sempre defina o atributo poster nos elementos <video>. O navegador renderiza o poster imediatamente enquanto o vídeo carrega, e ele próprio pode se tornar o elemento LCP — portanto, otimize-o como 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 conserto sites lentos. Se você está com problemas que não consegue resolver sozinho, me envie sua URL e vamos conversar.

Me envie sua URL
Arjen Karel
Arjen Karel, Consultor de web performance desde 2009

Por que nosso fix não está funcionando?

Às vezes a CDN ainda entrega o HTML antigo, ou o fix entrou no template de desktop e o celular usa outro. Me envie sua URL e o problema, e eu respondo com alguns horários. Primeiro analiso o field data, depois dedicamos uma hora ao seu site, e em até um dia você tem minhas anotações por escrito. €350 sem IVA.

Me envie sua URL

Sem desenvolvedor para fazer o fix? Eu mesmo faço o trabalho, em uma cópia do seu site.

O checklist definitivo de Core Web Vitals (2026) Core Web Vitals O checklist definitivo de Core Web Vitals (2026)