Atualizado em outubro de 2026: este artigo agora conta dois cases. O primeiro é o original, em um grande ecossistema de pagamentos, onde o resultado foi medido no caixa (+10,9%). O segundo é o checkout da Voomp, onde apliquei o mesmo diagnóstico e trago os prints do Lighthouse, o A/B contra a
main, a validação no ambiente DEV2 com compras de teste, os testes de stress e o que ainda não foi provado.
Pense em um restaurante charmoso que funciona perfeitamente em uma terça-feira à tarde: fila zero, garçom atencioso e o prato chega à mesa em 10 minutos.
Agora imagine que no feriado um influenciador gastronômico faz um post elogiando o local. De repente, 500 pessoas chegam na porta ao mesmo tempo querendo almoçar. A cozinha não mudou e o cardápio é o mesmo. Mas os clientes esperam 50 minutos na calçada, ficam irritados, desistem e vão embora para o restaurante vizinho.
No dia seguinte, a diretoria se reúne e diz: "A campanha de marketing foi um fracasso total".
Checkouts de infoprodutos e e-commerces de alto tráfego sofrem exatamente do mesmo mal. Vivi isso duas vezes, em dois checkouts diferentes:
- Case 1, um grande ecossistema de pagamentos: a tela congelava no clique de pagar durante as lives. Resultado medido no caixa: +10,9% relativo de vendas no mês.
-
Case 2, o checkout da Voomp: o comprador esperava quase 9 segundos para ver qualquer coisa no celular. Resultado: Lighthouse mobile de 57 para 93 no A/B contra a
main, 96 no DEV2 (rede real, na nuvem) e primeira pintura de 8,7 s para 1,6 s. Conversão: ainda não medida, e eu explico por quê.
A doença é a mesma. O remédio muda conforme a arquitetura. E a forma de provar que funcionou também.
Case 1: a campanha morria no último clique
1. O sintoma
O erro mais comum ao analisar lentidão em aplicações web é confiar cegamente em relatórios de laboratório, como a pontuação do Google Lighthouse.
No laboratório, o desenvolvedor roda o teste em um Macbook de última geração conectado na fibra ótica e comemora a nota 95 verde. Mas o comprador real está em um celular intermediário, com rede 4G oscilante na rua.
No tráfego orgânico rotineiro, o checkout convertia bem. Mas no instante em que um grande produtor abria as vendas em uma live com milhares de acessos concorrentes em redes 4G, a taxa de conversão no passo final despencava.
[ O Funil de Conversão do Checkout ]
1. Acessa a página de vendas ─────────> OK (HTML leve)
2. Preenche Nome e E-mail ─────────> OK (Input rápido)
3. Escolhe Meio de Pagamento ─────────> OK (Seleção visual)
4. CLIQUE EM "FINALIZAR PAGAMENTO" ────> 💥 TIMEOUT / TRAVAMENTO!
O JavaScript não respondia!
O cliente clicava no botão de pagar, mas a thread principal do navegador estava travada processando scripts secundários. O POST de pagamento nem saía do celular. O backend nunca recebia a tentativa, a sessão expirava e a venda se perdia sem gerar sequer log de erro.
2. A causa raiz: código demais no momento errado
A aplicação era arquitetada como Micro Frontends (MFE). Ótimo para a organização interna (o time de cupons não dependia do time de checkout para fazer deploy), caro para o dispositivo do comprador:
[ O que o navegador baixava no clique de PAGAR: ]
┌────────────────────────────────────────────────────────┐
│ PayStep.js (Componente de Pagamento) │
│ dashboard.chunk.js <-- Código da área logada! │
│ admin-charts.js <-- Gráficos que o cliente nem vê│
│ pixel-scripts.js <-- 15 scripts de rastreamento │
│ vue.runtime.js x 3 <-- Três instâncias do framework!│
└────────────────────────────────────────────────────────┘
Cada módulo empacotava sua própria cópia do framework e trazia componentes que só deveriam existir em telas administrativas. O celular precisava baixar e processar 4 MB de JavaScript só para validar 16 dígitos de cartão.
A regra de ouro:
O passo atual só baixa o JavaScript do passo atual. Todo o resto espera o clique do usuário.
3. O plano de ação
Sem reescrever o sistema do zero, três frentes:
┌──────────────────────────────────────┐
│ Plano de Otimização Real │
└──────────────────┬───────────────────┘
│
┌──────────────────────────┼──────────────────────────┐
▼ ▼ ▼
[ 1. SSR Cirúrgico ] [ 2. Code Splitting ] [ 3. CDN de Borda ]
Servidor já entrega o Componentes pesados só Cache inteligente
HTML do botão pronto baixam sob demanda via próximo ao usuário
sem esperar hidratação `defineAsyncComponent` com Brotli ativado
SSR cirúrgico no passo crítico. Com um BFF, o servidor passou a devolver o HTML pronto do valor do produto e dos campos de pagamento.
Code splitting de verdade. Modais secundários, cupom e upsell viraram carregamento assíncrono:
import { defineAsyncComponent } from 'vue'
// O componente de pagamento só é importado quando a etapa é ativada
const PayStep = defineAsyncComponent(() => import('./PayStep.vue'))
Se o comprador não clica em "Adicionar Produto Extra", aquele código nunca viaja pela rede dele.
CDN com compressão. Assets estáticos em nós de borda próximos dos usuários brasileiros, Brotli e cache com hash no nome dos arquivos.
4. Como medimos: as cinco perguntas
- Sentry: o erro foi uma falha real na jornada de pagamento ou um pixel bloqueado por adblocker?
- Datadog / infra: com o pico da live, o TTFB se manteve abaixo de 200 ms?
- DevTools: a aba Network confirmou que o chunk do dashboard sumiu da tela de pagamento?
- Lighthouse (lab): serve para hipótese, o que bloqueia o first paint no laboratório. Não fecha receita. Não tem influenciador, não tem 4G na rua, não tem a fila da CDN.
- Backoffice (métrica final): o faturamento das campanhas subiu?
5. O resultado no caixa
- Janela de amostragem: duas janelas consecutivas de pico de 7 dias, com volume equivalente de tráfego (~180.000 sessões iniciadas no funil).
- Janela A (antes): 8,2% dos compradores que chegavam ao passo final concluíam o pagamento.
- Janela B (depois): 9,1%.
- Impacto: +10,9% relativo em faturamento, sem mudar copy nem aumentar um centavo em anúncios.
- Queda de 85% nos erros de timeout no envio do pagamento.
- Redução de 60% no peso do bundle inicial no mobile.
Case 2: Voomp, quase 9 segundos de tela branca
Na Voomp, a plataforma de infoprodutos da Cogna, o sintoma apareceu um passo antes do botão de pagar. O comprador chegava ao checkout e não via nada.
1. O diagnóstico
O checkout é Nuxt 3 rodando como SPA (ssr: false). A ordem das coisas no celular era:
[ Antes: tudo em fila ]
HTML vazio ──> baixa 725 KB de JS (249 KB gzip) ──> executa ──> só então pede /api/product ──> pinta
↑
o dado do produto era o último a sair
Medindo antes de mexer, o que pesava:
- ~39% do JS de entrada era o SDK do Sentry (o Replay sozinho, 17,5%).
- reCAPTCHA (347 KB) e GTM carregavam no page view, antes de qualquer interação.
- 21 bandeiras do seletor de idioma baixavam com o dropdown fechado.
- A imagem do produto vinha crua: 174 KB para um quadro de 120 px.
- HTML e JSON da API saíam sem compressão.
Resultado no Lighthouse mobile da main: nota 56 a 57, FCP de 8,7 s, LCP de 9,9 s.

Antes (main), mobile: um run representativo. Repare nos dois primeiros quadros do filmstrip: tela branca.
2. A mesma regra, outro remédio
A regra do Case 1 vale igual: o passo atual só baixa o que o passo atual precisa. Mas aqui o gargalo não era framework duplicado. Era fila: tudo esperava tudo.
Tirar o dado do produto da fila. Um plugin Nitro injeta no HTML um <link rel="preload"> de /api/product, com a mesma URL que o client vai pedir. A busca começa junto com o HTML: de 245 ms para 44 ms.
Pintar a marca antes do JavaScript. Um shell estático com o logo aparece antes do bundle. Ninguém mais olha para tela branca.
Adiar o que não é do passo atual:
- Sentry e Replay carregam no idle, com uma fila que guarda os erros até o SDK subir. JS de entrada: 249,5 KB → 150,5 KB gzip (−40%).
- reCAPTCHA, GTM e bandeiras carregam na primeira interação ou no idle. O
dataLayerenfileira os eventos; nenhum se perde. - Modal do Pix e QR code só quando o comprador escolhe Pix.
Emagrecer o que fica. Imagem do produto pelo IPX em webp (170 KB → 5,5 a 12,5 KB) e compressão brotli/gzip do HTML e do JSON.
3. Ligar sem apostar a empresa
Checkout é dinheiro. Nada disso foi para todo mundo de uma vez:
- Feature toggle por seller e rollout por porcentagem, com bucket estável por hash do seller. Ausente = desligado. Rollback sem deploy.
- Cada evento do Sentry leva a tag
perf_mvpon/off, para comparar os dois grupos em erro e conversão. - PWA instalável, sem Service Worker de propósito. Em fluxo de pagamento, cache pode servir preço velho ou script de gateway velho. Resiliência offline ficou para uma história própria.
4. O que testei e joguei fora
Testei um SSR-lite: buscar o produto no servidor e embutir no HTML. Zerou a chamada no navegador. Mas o TTFB foi de 4 ms para cerca de 1 s, e com throttling real (CPU 4x, RTT 150 ms) a primeira pintura piorou de 0,46 s para 1,68 s. Descartado com número. O que sobrou de bom, um cache curto do produto no BFF, vai numa próxima leva.
No Case 1, SSR foi parte da cura. No Case 2, o SSR ingênuo piorava. Por isso a regra é medir, não copiar a receita.
5. O resultado: A/B, DEV2 e stress
A prova veio em três camadas, cada uma respondendo uma pergunta diferente.
A/B: quanto melhorou em relação à main?
No mesmo dia e na mesma sessão, o build da main contra o build da branch com tudo aplicado, os dois servidos da minha máquina e falando com o backend de HML. Lighthouse 12.8.2, mobile com 4G lento simulado e CPU 4x, mediana de 5 runs por versão (a branch em duas passadas, 10 runs). É a única comparação antes e depois que existe, porque a main não tem build no DEV2.
| Métrica | Mobile antes | Mobile depois | Desktop antes | Desktop depois |
|---|---|---|---|---|
| Nota (mediana) | 57 | 93 (faixa 91 a 97) | 80 | 100 |
| FCP | 8,66 s | 1,59 s (−82%) | 1,85 s¹ | 0,41 s¹ |
| LCP | 9,89 s | 3,03 s (−69%) | 2,12 s | 0,69 s (−67%) |
| Requisições | 104 | 85 (−18%) | 108¹ | 89¹ |
¹ Desktop FCP e requisições vêm da rodada anterior (um dia antes), não do A/B final.

Depois, mobile: um run representativo (95). Os dois primeiros quadros agora mostram a marca, não tela branca.
DEV2: o depois se sustenta fora da minha máquina?
A branch foi implantada no DEV2, o ambiente de desenvolvimento na nuvem (AWS EKS, deploy por GitHub Actions e ArgoCD), com rede real, backend e banco próprios. Lá rodei o mesmo Lighthouse e as suítes e2e:
| DEV2 | Resultado |
|---|---|
| Lighthouse mobile (mediana de 5 runs) | 96 (FCP e LCP 1,7 s, TBT 70 ms) |
| Lighthouse desktop (mediana de 5 runs) | 98 (FCP e LCP 0,6 s, TBT 0 ms) |
Requisições a /api/product
|
exatamente 1 por carregamento |
| HTML entregue com brotli | 2,8 KB, contra 6,8 KB antes |
| Suíte de preenchimento desktop e mobile | 86 aprovados, 0 falhas |
| Compras de teste ponta a ponta | 3 vendas pagas no gateway em modo de teste |
| Duplo clique no botão de pagar | 1 venda, sem duplicidade |

DEV2, mobile: 96 (run mediano). Os cinco primeiros quadros mostram a marca enquanto o JS e o dado chegam.

DEV2, desktop: 98 (run mediano).
Detalhe importante: no DEV2 o preload e o toggle por seller estavam desligados. O 96 vem só das mudanças que valem para todo mundo (shell, terceiros adiados, compressão).
Stress: aguenta pico sem misturar comprador?
Preload com dado de produto é o tipo de otimização que, se errar a URL, mostra o produto de um para outro. Então o servidor do checkout (o processo Node do Nuxt, rodando na minha máquina) apanhou de propósito, com carga sintética:
- O preload não custa throughput: 1.082 contra 1.084 req/s, p95 de 54 ms nos dois.
- Nenhum 5xx, erro de rede ou timeout até 100 conexões simultâneas.
- Zero preloads trocados entre compradores em cerca de 750 mil respostas sob carga.
- Memória estável: 5 minutos e cerca de 259 mil requisições entre 118 e 144 MB, voltando a ~50 MB em repouso.
Tudo isso virou suíte versionada no repositório de e2e: Lighthouse, preenchimento e stress podem rodar de novo antes de cada liberação.
6. O que esses números não provam
Aqui está a diferença honesta entre os dois cases:
-
O antes e depois é o A/B da
maincontra a branch. No DEV2 não existe build damain, então lá não há comparação: há a confirmação de que o depois se sustenta em rede real. - O DEV2 não tem o Akamai que fica na frente da produção, e o 4G do Lighthouse é simulado. Nenhum desses números é dado de campo de comprador de verdade.
- A nota é uma faixa (91 a 97), não uma promessa. O print de 95 é um run; a mediana é 93.
- O LCP do depois é o logo do shell, não o formulário. O formulário pronto para preencher melhorou menos: de 1,43 s para 1,12 s no e2e mobile.
- O TBT piorou (de ~12 ms para ~30 ms), ainda muito abaixo do orçamento de 300 ms.
-
Conversão ainda não foi medida. O rollout por seller é justamente o experimento:
perf_mvpon contra off, em conversão, erro no Sentry e LCP de campo.
No Case 1 eu tenho o caixa. No Case 2 eu tenho o A/B, o DEV2, o stress e o desenho do experimento. Os benchmarks públicos e o próprio Case 1 apontam para algo entre +10% e +14% no mobile, mas quem decide é o rollout, não a projeção.
O que os dois cases têm em comum
| Case 1 | Case 2 (Voomp) | |
|---|---|---|
| Sintoma | Tela congela no clique de pagar | Tela branca por quase 9 s ao abrir |
| Causa | JS de outros passos e framework duplicado no MFE | Tudo em fila: HTML vazio → JS → dado |
| Remédio | SSR no BFF, code splitting, CDN | Preload do dado, shell, terceiros no idle, imagem e compressão |
| Prova | Faturamento no caixa (+10,9%) | A/B 57 → 93, DEV2 96, stress sem erro; conversão pelo rollout |
Três lições que valem para qualquer checkout:
- O passo atual só baixa o que o passo atual precisa. Terceiros (observabilidade, captcha, tag manager) são os primeiros suspeitos.
- Mudança de performance em checkout entra atrás de toggle, com grupo de controle. Sem isso você não sabe se ganhou, e não volta sem deploy se perdeu.
- Lighthouse gera hipótese. O caixa fecha a conta. Publique a nota com a faixa e com os limites, e diga o que ainda falta provar.
Onde agentes de código pioram o problema sem sensores
Com assistentes e agentes de código, desenvolvedores pedem features com frequência: "adicione um banner de cupom", "inclua um componente de upsell", "integre a biblioteca do pixel X".
O agente atende, os testes passam e o build compila. Mas ele não sente o celular na ponta. Se o harness não tiver um sensor de orçamento de bundle ou de tempo de bloqueio (TBT / INP via automação de browser), o agente continua empilhando dependência no passo crítico. No Case 2, a suíte de Lighthouse automatizada é exatamente esse sensor: a próxima mudança que inflar o checkout aparece no número antes de aparecer no caixa.
Referências
- 📖 web.dev: Interaction to Next Paint (INP)
- 📖 web.dev: Optimize Largest Contentful Paint
- 📖 Martin Fowler: Micro Frontends
- 📖 Sentry: Distributed Tracing
O que você pode levar para o seu projeto
- Abra o DevTools no celular com a rede em Fast 3G e olhe o filmstrip: quantos quadros de tela branca?
- Procure intrusos no Network: código de outra tela, SDK de terceiros no page view, imagem maior que o quadro.
- Ligue por toggle e meça por grupo. A melhor métrica de performance não é um gráfico bonito: é dinheiro entrando no caixa.


Top comments (0)