A primeira tela do nosso primeiro miniprograma trazia quatro tópicos, uma sobreposição de tutorial em dois passos e um cartão de cadastro antes do menu. Achávamos que estávamos sendo generosos. Os números retrucaram: boa parte de quem chegava ali nunca alcançava o menu.
Num app nativo, essa porta de entrada se sobrevive. Alguém acabou de baixar você, então veio preparado para um ritual de configuração: conta, permissões, um passe pelas abas. Um miniprograma vive dentro de um anfitrião que o usuário já confia e já usa. Não veio por você; veio por uma corrida, uma conta, um cupom. No instante em que você começa a se explicar, está gastando uma atenção que ele não concordou em dar.
Por que a porta é mais estreita aqui
Uma web ou um app nativo ganham alguns segundos de paciência pelo simples fato da instalação. Um miniprograma, nenhum. O anfitrião entrega um arranque a frio, um círculo de carregamento e um usuário cujo polegar já se move. Se a primeira coisa que ele encontra é um muro de intenções, o gesto de voltar está a um deslize e não custa nada.
Por isso a tentação de sobre-explicar é o dobro de perigosa. Já vimos equipes enfiar uma proposta de valor, um carrossel de funções e três pedidos de permissão na primeira vista, convencidas de que clareza exige cobertura. Não é. Clareza exige uma única coisa a fazer.
| Erro de primeira execução | O que o usuário faz na prática | O que enviamos no lugar |
|---|---|---|
| Tutorial antes do conteúdo | Desliza ou sai | Conteúdo primeiro, tutorial em pressão longa |
| Cartão de cadastro ao entrar | Fecha o programa | Um toque na ação central, conta depois |
| Três permissões de uma vez | Negação total, para sempre | Pede a que precisa, o resto no contexto |
| Quatro tópicos de valor | Não lê nenhum | Uma frase, se houver espaço |
| Ação principal escondida | Toca no lugar errado | Um botão óbvio, o resto recua |
A tabela não é um guia de estilo: é o que nossa analítica gritava. Cada elemento a mais naquela primeira tela era um pequeno imposto, e impostos se acumulam.
A tentação de sobre-explicar
Aqui está o que tivemos de admitir: sobre-explicar parece diligência. Um gerente de produto pode apontar um tutorial e dizer que já explicamos como funciona. Mas explicar não é ativar. Ativar é o usuário fazer, na primeira sessão, a única coisa que faz o programa valer a pena guardar: fazer o pedido, enviar a mensagem, passar a fase.
Isso medimos agora, e medimos estreito. Não instalações, não aberturas, e sim ação-central-concluída dentro, digamos, noventa segundos da primeira execução. Quando cortamos a tela de boas-vindas a uma só ação principal e levamos toda explicação para trás de uma ajuda, esse número se mexeu mais que qualquer redesign anterior. Não acrescentamos clareza: tiramos fricção.
E sim, há um risco real em ficar magro demais. Se o valor do programa de verdade precisa de uma palavra de contexto — uma interação nova, uma categoria confusa —, esconder tudo pode deixar a gente presa. O teste que usamos é simples: um usuário que nos esqueceu consegue completar a ação central a frio? Se sim, a primeira execução pode ficar quase vazia. Se não, uma frase ganha seu lugar.
Adiar os pedidos
Os avisos de permissão são a armadilha mais fácil. Localização, contatos, notificações: cada um é uma pequena ocasião em que o usuário diz não para sempre, e uma permissão negada num miniprograma custa mais recuperar que num celular onde os ajustes estão um toque mais fundo. Pedimos a única permissão que a ação imediata precisa, e a pedimos dentro do momento em que se precisa, não à chegada. O resto espera o usuário ter um motivo para conceder.
Não é só cortesia. Muda a curva de ativação. Quem conclui a ação central antes de ver qualquer aviso está muito mais disposto a conceder o próximo, porque até então o programa já cumpriu uma promessa.
Uma primitiva, não cem reinvenções
Há um ângulo de plataforma que raramente se diz em voz alta. Hoje, cada comerciante que constrói um miniprograma reinventa a mesma dança de primeira execução: seu próprio tutorial, sua própria lógica de permissões adiadas, sua própria ideia de ação principal. Multiplique por anfitriões e obtém cem fluxos de onboarding levemente quebrados, cada um mantido por alguém que não pensa em onboarding em tempo integral.
Um runtime que aponta para vários anfitriões pode carregar uma primitiva de onboarding bem testada — divulgação progressiva, uma ação principal, pedidos de permissão por contexto — e deixar que cada miniprograma a herde. O comerciante para de resolver um problema para o qual não foi contratado, e o usuário para de re-aprender a porta cada vez que entra num programa novo. Antes veríamos essa primitiva receber mil horas de atenção de uma vez do que cem programas dedicarem cada um uma tarde.
Fontes
- web.dev — Aprenda — guia prático de desempenho e experiência na primeira carga.
- MDN — Documentos web — fundamentos de melhoria progressiva e design de interação.
- W3C — WCAG 2.2 — a base mensurável de interfaces usáveis e perceptíveis.
- Google — Think with Google — pesquisa sobre comportamento móvel e retenção.
- StatCounter — Estatísticas globais — dados de participação de dispositivos e plataformas por mercado.