DEV Community

Cover image for +10% de vendas no checkout no mês. A campanha quebrava na hora de pagar
Tiago Vilas Boas (Montanha)
Tiago Vilas Boas (Montanha)

Posted on Edited on

+10% de vendas no checkout no mês. A campanha quebrava na hora de pagar

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!
Enter fullscreen mode Exit fullscreen mode

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!│
└────────────────────────────────────────────────────────┘
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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'))
Enter fullscreen mode Exit fullscreen mode

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

  1. Sentry: o erro foi uma falha real na jornada de pagamento ou um pixel bloqueado por adblocker?
  2. Datadog / infra: com o pico da live, o TTFB se manteve abaixo de 200 ms?
  3. DevTools: a aba Network confirmou que o chunk do dashboard sumiu da tela de pagamento?
  4. 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.
  5. 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
Enter fullscreen mode Exit fullscreen mode

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.

Lighthouse mobile antes: nota 56, FCP 8,8 s, LCP 9,6 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 dataLayer enfileira 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_mvp on/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.

Lighthouse mobile depois: nota 95, FCP 1,5 s, LCP 2,9 s
Depois, mobile: um run representativo (95). Os dois primeiros quadros agora mostram a marca, não tela branca.

Lighthouse desktop antes: nota 81
Antes, desktop: 81.

Lighthouse desktop depois: nota 100
Depois, desktop: 100.

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

Lighthouse mobile no DEV2: nota 96, FCP 1,7 s, LCP 1,7 s
DEV2, mobile: 96 (run mediano). Os cinco primeiros quadros mostram a marca enquanto o JS e o dado chegam.

Lighthouse desktop no DEV2: nota 98
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 main contra a branch. No DEV2 não existe build da main, 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_mvp on 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:

  1. O passo atual só baixa o que o passo atual precisa. Terceiros (observabilidade, captcha, tag manager) são os primeiros suspeitos.
  2. 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.
  3. 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


O que você pode levar para o seu projeto

  1. Abra o DevTools no celular com a rede em Fast 3G e olhe o filmstrip: quantos quadros de tela branca?
  2. Procure intrusos no Network: código de outra tela, SDK de terceiros no page view, imagem maior que o quadro.
  3. 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)