Ir para o conteúdo
DevFlash

System design

System design front-end: como projetar interfaces e fluxos de dados

Decisões de arquitetura front-end conectadas ao comportamento da interface e aos contratos de dados.

  • 5 min de leitura
  • 6 seções
  • Atualizado em 2 de novembro de 2026

Este guia está em revisão editorial.

Em 1 minuto

  • Esclareça usuários, dispositivos, busca e compartilhamento antes de escolher bibliotecas.
  • Separe estado local, filtros na URL e dados remotos, evitando cópias sem necessidade.
  • Descreva fluxos de dados e o comportamento da interface diante de falhas e atualizações.

System design front-end é o exercício de organizar uma interface para atender requisitos de interação, dados e entrega. Você precisa explicar onde cada responsabilidade fica e como a tela se comporta antes, durante e depois de uma requisição. Um desenho de componentes sem estados de erro, navegação e acessibilidade deixa parte do problema sem resposta.

Use como cenário um catálogo com filtros, detalhes e favoritos. O objetivo aqui é decidir limites e contratos, sem implementar um produto inteiro. O guia de system design geral cobre serviços e persistência com mais amplitude. Nesta conversa, acompanhe aquilo que a pessoa vê e consegue fazer, inclusive numa conexão lenta ou ao voltar pelo histórico do navegador.

Como delimitar um problema de system design front-end

  1. Confirme o contexto

    Confirme quem usa o catálogo, quais dispositivos importam e se páginas precisam ser encontradas por buscadores.

  2. Defina filtros

    Pergunte se filtros devem sobreviver a um recarregamento e se uma busca pode ser compartilhada por URL.

  3. Diferencie favoritos

    Diferencie favorito local de favorito ligado a uma conta. Essas respostas alteram armazenamento, renderização e dependências; escolher uma biblioteca antes delas pode resolver o problema errado.

  • Liste ações principais e estados observáveis.
  • Registre requisitos de navegação e compartilhamento.
  • Defina o comportamento sem dados e sem conexão.
  • Separe o que cabe no navegador do que exige uma decisão do servidor.

Declare uma primeira versão: consultar, filtrar e abrir detalhes. Se favoritos ficarem para depois, explique como isso reduz o escopo. Não prometa sincronização offline ou atualização em tempo real sem discutir os custos e a necessidade dessas funções.

Componentes e limites de responsabilidade

Divida a interface por responsabilidades que mudam juntas. Uma rota coordena filtros e dados; a lista apresenta resultados; um item exibe informações e dispara intenções. O componente de item não precisa conhecer autenticação, cache e transporte. Ao mesmo tempo, extrair cada linha de marcação para um componente separado dificulta seguir o fluxo sem oferecer um limite útil.

Explique entradas, saídas e dono do estado de cada parte. Prefira passar dados e callbacks quando o caminho for curto. Use contexto quando consumidores distribuídos realmente compartilham uma dependência. As perguntas sobre React ajudam a aprofundar composição, mas o desenho deve continuar compreensível para alguém que usa outro framework. Nomeie responsabilidades de produto antes de mencionar hooks.

Estado local, URL e dados remotos

Faça

  • Guarde abertura de um painel perto do componente que a controla.
  • Coloque filtros compartilháveis e ordenação na URL, com valores padrão e validação.
  • Trate dados recebidos da API como uma representação temporária de dados do servidor.

Evite

  • Copiar automaticamente a resposta para outro estado local: duas cópias criam dúvidas sobre qual deve aparecer depois de uma atualização.

Defina uma chave de consulta que inclua os parâmetros capazes de mudar o resultado. Diferencie primeira carga de atualização em segundo plano. Se preservar resultados antigos durante uma nova busca, sinalize que eles ainda não correspondem aos filtros atuais. O contrato abaixo descreve estados de uma consulta, sem ditar biblioteca ou entregar a implementação da interação.

type CatalogItem = { id: string; title: string };
type CatalogState =
| { status: "loading" }
| { status: "error"; message: string }
| { status: "ready"; items: CatalogItem[]; refreshing: boolean };
function resultCount(state: CatalogState): number | null {
return state.status === "ready" ? state.items.length : null;
}
Caixas conectadas em um fluxo circular: interface, ação, store, API, cache e retorno à interface.
Acompanhe os dados até a interface e diferencie estado do componente, filtros na URL e representação dos dados do servidor.

Renderização, carregamento e desempenho

Decida o que precisa chegar no HTML inicial e o que depende de interação. Conteúdo público estável pode se beneficiar de renderização no servidor; controles interativos ainda precisam do comportamento no cliente. Considere também custo de hidratação, tamanho de JavaScript e carregamento de imagens. Renderizar no servidor não elimina automaticamente trabalho no navegador nem garante uma tela rápida.

Antes de sugerir virtualização, pergunte quantos elementos são exibidos e qual lentidão foi observada. Paginação pode simplificar navegação e reduzir volume. Virtualização exige cuidado com foco, leitura assistiva e busca na página. Reserve espaço para imagens e mensagens para evitar deslocamentos inesperados. Defina como medir o carregamento inicial e a resposta aos filtros em condições parecidas com as do público.

Contratos, falhas e acessibilidade

Combine formato da resposta, paginação, erros e permissões com o servidor. Um botão oculto não substitui autorização. Para favoritar, discuta se vale mostrar sucesso antes da confirmação: a atualização otimista melhora a sensação de resposta, mas precisa de recuperação quando a gravação falha. Preserve contexto e evite apagar a lista inteira por uma falha isolada num item.

Inclua teclado, nomes acessíveis e anúncio de resultados na proposta inicial. Ao abrir detalhes e voltar, considere restaurar posição e foco de forma previsível. Não mova o foco a cada resposta de rede. Compare esses fluxos com os exemplos de system design, especialmente quando respostas chegam fora da ordem esperada.

Validação da proposta e evolução

Percorra o catálogo com três histórias: primeiro acesso, filtro sem resultados e falha ao favoritar. Em cada história, diga qual estado muda, qual requisição ocorre e qual retorno aparece. Essa revisão expõe dependências escondidas e componentes com responsabilidade demais. Na entrevista técnica front-end, você também pode usar uma tela real do portfólio para explicar por que adotou um limite diferente.

Perguntas frequentes

O que é system design front-end?

É projetar a organização da interface, seus estados e seus fluxos de dados. A discussão conecta componentes, rede, renderização, navegação e acessibilidade aos requisitos do produto, sem depender de uma implementação completa.

Qual a diferença entre arquitetura front-end e back-end na entrevista?

O front-end aprofunda experiência no cliente e entrega da interface. O back-end aprofunda serviços, persistência e operação. Os contratos entre eles continuam sendo responsabilidade compartilhada na discussão.

Como decidir onde guardar cada tipo de estado?

Pergunte quem precisa ler, quem pode alterar e por quanto tempo o valor deve durar. Estado local, URL e cache remoto respondem a necessidades diferentes. Evite escolher uma store global antes de responder essas perguntas.

Preciso escolher um framework na resposta de system design?

Só quando a escolha fizer parte do pedido ou ajudar a explicar uma restrição concreta. Comece pelos comportamentos e responsabilidades. Depois mostre como a ferramenta escolhida atende esses limites e quais custos ela acrescenta.

Pratique com testes de verdade

Resolva exercícios de front-end no navegador, com os mesmos testes que um avaliador rodaria.

Ver os exercícios