Storyboard de Vídeo
Faça isso ANTES de um único frame ser animado. Um vídeo de demonstração vive ou morre pelo seu plano: a ordem errada, um gancho faltando ou uma duração de 40 segundos o mata, por mais limpo que seja o movimento. Você é a camada criativa que decide quais cenas existem, em que ordem, por quanto tempo e o que cada uma diz - e então entrega um plano de cenas concreto para o pacote de mecanismo (remotion-setup, remotion-compose, remotion-render) realmente construir.
Ative-se prontamente com intenção de planejamento: "storyboard da minha demo", "planejar o vídeo", "quais cenas eu preciso", "mapear o vídeo de lançamento", "dividir este recurso em cenas." Se o usuário pular direto para "animar isso", ainda assim execute a pauta de beats primeiro - um storyboard leva dois minutos e economiza um re-render.
Trabalhe com um exemplo durante todo o processo: um vídeo de lançamento de 30 segundos para uma ferramenta de revisão de código baseada em IA chamada Sentinel, que sinaliza diffs arriscados antes do merge.
Procedimento operacional
Execute-os em ordem. Não escreva cópia antes que os beats estejam fixos, e não defina durações antes que os beats existam - o ritmo é uma função da estrutura, não o contrário.
Etapa 1 - Fixar o objetivo em uma linha e a plataforma
Antes dos beats, fixe duas coisas:
- A única conclusão. Uma frase que o espectador deve lembrar: "Sentinel pega o bug que seu revisor perdeu." Se você não consegue dizer em uma linha, o vídeo não tem espinha dorsal. Tudo a jusante serve a esta linha.
- Plataforma e proporção. Paisagem 16:9 (1920×1080) para um herói do site ou YouTube; vertical 9:16 (1080×1920) para redes sociais/Shorts; quadrado 1:1 para feed. Isso define a tela que
remotion-composevai autorar e limita a duração - redes sociais querem 15-30s, um loop herói 20-40s, um passo a passo de recurso até 60s.
Etapa 2 - Montar a pauta de beats (a espinha dorsal de cinco beats)
Toda demo, anúncio e vídeo de lançamento é uma versão destes cinco beats. Remova um beat apenas com uma razão; nunca reordene antes do gancho.
- Gancho (primeiros 3 segundos). Os 3 segundos mais importantes do vídeo - os espectadores decidem continuar assistindo aqui. Abra no resultado, na tensão ou em uma afirmação ousada, NÃO no seu logotipo. "Seu revisor acabou de aprovar um bug" vence "Apresentando o Sentinel." O logotipo pode ficar no canto; não é o gancho.
- Problema. Nomeie a dor que o espectador já sente, de forma concreta. "Diffs arriscados passam pela revisão às 17h de uma sexta-feira." Um beat, uma dor.
- Revelação. Apresente o produto como a virada. É aqui que o nome e o mecanismo principal aparecem. Mostre a coisa fazendo a coisa.
- Prova. Torne a afirmação crível - um antes/depois real, um número real, uma tela real. Este é o beat que a maioria dos vídeos pula e o que converte. Use dados reais do produto, nunca métricas inventadas.
- CTA. Uma ação, uma URL. "Experimente o Sentinel grátis → sentinel.dev." Nunca dois pedidos.
Para um passo a passo mais longo, os beats de Revelação e Prova repetem por recurso (revelar recurso 1 → prova, revelar recurso 2 → prova). O gancho, o problema e o CTA permanecem únicos.
Etapa 3 - Atribuir um tipo de cena e duração alvo a cada beat
Cada beat se torna uma ou mais cenas. O tipo de cena dita o ritmo - texto precisa de tempo de leitura, uma demonstração de UI precisa de tempo de permanência, um logotipo é rápido. Use estes alvos (a 30fps; durationInFrames = segundos × fps):
| Tipo de cena | Duração alvo | Por quê |
|---|---|---|
| Gancho / cartão de título | 2.5-3.5s | Longo o suficiente para ler uma linha, curto o suficiente para manter a abertura enxuta |
| Declaração de texto | 2.5-4s | ~2.5 palavras/seg de velocidade de leitura; uma linha de 7 palavras precisa ~3s na tela |
| UI / demonstração do produto | 4-6s | O olho precisa de tempo de permanência para analisar uma tela e o movimento dentro dela |
| Prova / dados | 3-5s | Um número ou antes/depois precisa de um beat para ser registrado |
| Logotipo / CTA final | 2.5-4s | Leia a URL, deixe respirar, termine |
Regra de ritmo: o gancho é o corte mais rápido, a prova é o mais lento. Se o total ficar longo, corte uma cena - não acelere todas as cenas. Uma demo apressada parece nervosa.
Etapa 4 - Escrever a lista de cenas (cópia + visual por cena)
Para cada cena, fixe quatro campos: o beat que ela serve, o tipo de cena, a cópia na tela (as palavras reais - pergunte ao usuário, nunca invente afirmações) e uma descrição visual de uma linha que diga ao remotion-compose o que renderizar. Esta é a entrega. A linha visual é uma diretriz, não código: "terminal digita um git diff, uma linha arriscada destaca-se em vermelho" - remotion-compose decide os mecanismos interpolate/spring.
Etapa 5 - Emitir o plano de cenas JSON
Execute o gerador abaixo para transformar a lista de cenas em um scene-plan.json estruturado. Este é o artefato que faz a transição: remotion-compose o lê como o plano de cenas (um <Sequence> por cena, com from/durationInFrames já calculados), e a dica de motion por cena é onde uma decisão de motion-design-principles ou motion-color-and-light se conecta. Salve-o ao lado do projeto para que o pacote de mecanismo possa pegá-lo.
Etapa 6 - Entregar
Dê ao usuário a pauta de beats, a tabela de lista de cenas e o JSON. Em seguida, entregue explicitamente: "Aqui está o plano de cenas. Execute remotion-setup se o projeto ainda não estiver estruturado, depois remotion-compose transformará este JSON na composição e remotion-render o exportará. Quer que eu ajuste o ritmo ou a cópia antes de animarmos?" Se o vídeo for especificamente uma demonstração de produto e você quiser um olhar de diretor sobre o que mostrar na tela por cena, associe-se ao product-demo-director. Tratamentos cinéticos de título vão para kinetic-typography; a base sonora e os cortes sincronizados com o beat vão para sound-and-music-sync; um recorte vertical para redes sociais vai para social-video-formatter.
Barra de qualidade
Um storyboard é nota A+ apenas quando tudo se mantém:
- O gancho chega nos primeiros 3 segundos e NÃO é o logotipo - abre no resultado, tensão ou afirmação.
- Todos os cinco beats estão presentes, ou cada beat ausente tem uma razão declarada (um teaser pode legitimamente pular a Prova).
- Toda cena tem uma linha de cópia com palavras reais e uma diretriz visual concreta - sem "alguma UI aqui," sem métricas inventadas.
- A duração total se encaixa no teto da plataforma, e as durações seguem a tabela de tipo de cena (gancho rápido, prova lenta), não um corte fixo a cada 3s.
- O CTA é uma ação única com uma única URL.
- O JSON é válido e suas durações somadas são iguais ao total da composição que
remotion-composeregistrará - uma incompatibilidade é a #1 surpresa de render.
NÃO FAÇA
- NÃO abra com um logotipo ou um fade-in de título lento - você perde o espectador antes do gancho.
- NÃO invente números, depoimentos ou afirmações de produto para o beat de Prova; peça dados reais ou corte o beat.
- NÃO escreva o
.tsx, escolha intervalos deinterpolateou definadampingde spring aqui - isso éremotion-compose. Esta skill gera um plano, não código. - NÃO dê ritmo igual a todas as cenas; um corte fixo de 3s faz a demo parecer uma apresentação de slides.
- NÃO coloque dois CTAs ou duas URLs; um pedido converte, dois dividem a atenção.
- NÃO deixe a duração ultrapassar o teto da plataforma para caber mais - corte uma cena.
Gerador
Script Node.js auto-contido. Salve como scene_plan.js, edite o array beats para o vídeo em questão e execute node scene_plan.js > scene-plan.json. Sem dependências. Ele calcula offsets de frames, valida o total e emite o plano que remotion-compose consome.
// Storyboard -> plano de cenas. Edite `meta` e `beats`, depois:
// node scene_plan.js > scene-plan.json
const meta = {
title: 'Lançamento Sentinel',
fps: 30,
width: 1920, // 1080 para 9:16 vertical, 1080 quadrado
height: 1080, // 1920 para 9:16 vertical, 1080 quadrado
}
// Uma linha por cena. `seconds` segue a tabela de tipo de cena.
// `motion` é uma dica para motion-design-principles / motion-color-and-light;
// é uma diretriz, não código.
const beats = [
{ beat: 'hook', type: 'title', seconds: 3.0, copy: 'Seu revisor acabou de aprovar um bug.', visual: 'Tela escura, linha de código digitada; uma linha fica vermelha.', motion: 'rápido, baixo damping na bandeira vermelha' },
{ beat: 'problem', type: 'text', seconds: 3.5, copy: 'Diffs arriscados passam pela revisão às 17h de uma sexta-feira.', visual: 'Motivo calendário/relógio, um PR marcado como merged.', motion: 'fade calmo, sem overshoot' },
{ beat: 'reveal', type: 'ui', seconds: 5.0, copy: 'Sentinel revisa cada diff antes do merge.', visual: 'Sentinel escaneia o mesmo diff, revela a linha arriscada com uma razão.', motion: 'varredura de escaneamento, depois estabiliza' },
{ beat: 'proof', type: 'proof', seconds: 4.5, copy: 'Pego em PRs reais. Antes de ser enviado.', visual: 'Antes/depois: bandeira vermelha -> diff corrigido, screenshot real.', motion: 'cross-dissolve lento, segura' },
{ beat: 'cta', type: 'cta', seconds: 3.0, copy: 'Experimente o Sentinel grátis -> sentinel.dev', visual: 'Logotipo + URL na cor da marca.', motion: 'pop suave, termina limpo' },
]
const fps = meta.fps
let from = 0
const scenes = beats.map((b, i) => {
const durationInFrames = Math.round(b.seconds * fps)
const scene = {
id: `${i + 1}-${b.beat}`,
beat: b.beat,
type: b.type,
from,
durationInFrames,
seconds: b.seconds,
copy: b.copy,
visual: b.visual,
motion: b.motion,
}
from += durationInFrames
return scene
})
const durationInFrames = from
const totalSeconds = durationInFrames / fps
const hook = scenes[0]
const warnings = []
if (hook.beat !== 'hook') warnings.push('A primeira cena não é o gancho.')
if (hook.seconds > 3.5) warnings.push('Gancho é maior que 3.5s - aperte a abertura.')
if (scenes.filter((s) => s.beat === 'cta').length > 1) warnings.push('Mais de um CTA.')
if (!scenes.some((s) => s.beat === 'proof')) warnings.push('Nenhum beat de prova - a afirmação pode não converter.')
if (totalSeconds > 60) warnings.push(`Duração ${totalSeconds}s excede o teto de 60s - corte uma cena.`)
const plan = {
composition: {
id: meta.title.replace(/[^A-Za-z0-9]/g, ''),
fps,
width: meta.width,
height: meta.height,
durationInFrames, // remotion-compose registra exatamente isto no <Composition>
},
scenes,
meta: { totalSeconds, sceneCount: scenes.length, warnings },
}
process.stdout.write(JSON.stringify(plan, null, 2) + '\n')
if (warnings.length) console.error('AVISOS:\n - ' + warnings.join('\n - '))
Exemplo de saída trabalhada
Com os beats acima, o script escreve scene-plan.json:
{
"composition": {
"id": "SentinelLaunch",
"fps": 30,
"width": 1920,
"height": 1080,
"durationInFrames": 570
},
"scenes": [
{ "id": "1-hook", "beat": "hook", "type": "title", "from": 0, "durationInFrames": 90, "seconds": 3.0, "copy": "Seu revisor acabou de aprovar um bug.", "visual": "Tela escura, linha de código digitada; uma linha fica vermelha.", "motion": "rápido, baixo damping na bandeira vermelha" },
{ "id": "2-problem", "beat": "problem", "type": "text", "from": 90, "durationInFrames": 105, "seconds": 3.5, "copy": "Diffs arriscados passam pela revisão às 17h de uma sexta-feira.", "visual": "Motivo calendário/relógio, um PR marcado como merged.", "motion": "fade calmo, sem overshoot" },
{ "id": "3-reveal", "beat": "reveal", "type": "ui", "from": 195, "durationInFrames": 150, "seconds": 5.0, "copy": "Sentinel revisa cada diff antes do merge.", "visual": "Sentinel escaneia o mesmo diff, revela a linha arriscada com uma razão.", "motion": "varredura de escaneamento, depois estabiliza" },
{ "id": "4-proof", "beat": "proof", "type": "proof", "from": 345, "durationInFrames": 135, "seconds": 4.5, "copy": "Pego em PRs reais. Antes de ser enviado.", "visual": "Antes/depois: bandeira vermelha -> diff corrigido, screenshot real.", "motion": "cross-dissolve lento, segura" },
{ "id": "5-cta", "beat": "cta", "type": "cta", "from": 480, "durationInFrames": 90, "seconds": 3.0, "copy": "Experimente o Sentinel grátis -> sentinel.dev", "visual": "Logotipo + URL na cor da marca.", "motion": "pop suave, termina limpo" }
],
"meta": { "totalSeconds": 19, "sceneCount": 5, "warnings": [] }
}
Leia: 5 cenas, 570 frames = 19s a 30fps, bem abaixo do teto para redes sociais. O gancho tem 3s e abre com tensão, não com um logotipo. O beat de prova (4.5s) é o corte mais lento; o gancho e o CTA (3s) são os mais apertados. Sem avisos, então está pronto para remotion-compose - que registra um <Composition durationInFrames={570}> e um <Sequence from={…} durationInFrames={…}> por cena, lendo from e durationInFrames diretamente deste arquivo.
Modelo: lista de cenas
Use isto quando quiser a tabela legível por humanos junto com o JSON. Substitua os campos PREENCHER pelo vídeo real.
STORYBOARD DE VÍDEO. [PREENCHER: nome do vídeo]. [PREENCHER: plataforma / proporção]
Objetivo (uma linha): [PREENCHER: a única conclusão]
Duração alvo: [PREENCHER: 15-30s redes sociais / 20-40s herói / até 60s passo a passo]
BEAT TIPO DE CENA DURAÇÃO CÓPIA NA TELA (palavras reais) DIRETRIZ VISUAL
Gancho título [PREENCHER]s [PREENCHER: resultado/tensão/afirmação][PREENCHER]
Problema texto [PREENCHER]s [PREENCHER: uma dor concreta] [PREENCHER]
Revelação ui [PREENCHER]s [PREENCHER: produto + mecanismo principal][PREENCHER]
Prova prova [PREENCHER]s [PREENCHER: número real / antes-depois][PREENCHER]
CTA cta [PREENCHER]s [PREENCHER: uma ação + uma URL] [PREENCHER]
(repita Revelação + Prova por recurso para um passo a passo)
TOTAL: [PREENCHER]s (deve ser igual a JSON composition.durationInFrames / fps)
ENTREGA: scene-plan.json -> remotion-compose
referências/por-que-os-primeiros-3-segundos
Os espectadores decidem se continuarão assistindo nos primeiros ~3 segundos, então o gancho não é o lugar para seu logotipo ou um fade lento. Abra no resultado ou na tensão: o bug que foi enviado, o número que caiu, a afirmação que para a rolagem. O logotipo pode ficar em um canto o tempo todo; torná-lo o beat de abertura gasta seus segundos mais valiosos no conteúdo menos persuasivo. Se você acertar apenas um beat, acerte este.
referências/ritmo-por-tipo-de-cena
Cenas diferentes precisam de tempo diferente na tela, e um corte fixo a cada N segundos parece uma apresentação de slides:
- Título/gancho - rápido. Uma linha, entrada rápida, corte antes que fique obsoleto.
- Texto - dê tempo de leitura. As pessoas leem ~2.5 palavras/seg; uma linha de 7 palavras precisa ~3s, uma linha de 12 palavras ~5s. Cronometrar mal o texto é o erro mais comum de ritmo.
- UI/demo - o olho precisa de ~4-6s para entender o layout e a animação. Cortar antes disso perde o ponto.
- Prova - o mais lento. Um número, um antes/depois ou uma citação precisa de tempo para ser registrado. Acelere aqui e você perde a credibilidade.
- CTA - rápido, mas não abrupto. Deixe a URL respirar por ~1s antes do fade final.
referências/por-que-um-beat-de-prova-real
Um espectador vê centenas de afirmações de produtos por dia. O que converte não é a afirmação - é a demonstração de que é verdade. Um beat de prova com dados reais é a diferença entre "parece legal" e "preciso disso." Se você não tem um número concreto, um antes/depois ou um screenshot real, remova o beat de Prova e doe seu tempo para a Revelação. Afirmações inventadas quebram a confiança no primeiro "isso não parece real."