Perguntas para Entrevista de Desenvolvedor Full Stack Sênior: Guia Completo

Introdução

O desenvolvimento full stack evoluiu para uma disciplina abrangente que exige expertise em frontend, backend, bancos de dados e infraestrutura. Espera-se que desenvolvedores full stack seniores arquitetem sistemas escaláveis, tomem decisões de tecnologia informadas e preencham a lacuna entre diferentes camadas de aplicações modernas.

Este guia aborda as principais perguntas de entrevista para Desenvolvedores Full Stack Seniores, abrangendo frameworks frontend, arquitetura backend, design de sistemas, bancos de dados e práticas de DevOps. Cada pergunta inclui respostas detalhadas, avaliação de raridade e classificações de dificuldade para ajudá-lo a se preparar de forma eficaz.

Desenvolvimento Frontend (6 Perguntas)

1. Explique o Virtual DOM do React e o algoritmo de Reconciliation.

Resposta: O Virtual DOM é uma representação JavaScript leve do DOM real. O React o usa para otimizar as atualizações.

• Processo: Quando o estado muda, o React cria uma nova árvore Virtual DOM e a compara com a anterior (diffing).
• Reconciliation: O algoritmo do React identifica o conjunto mínimo de alterações necessárias e atualiza apenas essas partes do DOM real.
• Otimização Chave: Usar props key ajuda o React a identificar quais itens foram alterados, adicionados ou removidos em listas, tornando a reconciliation mais eficiente.
• Arquitetura Fiber: O React moderno usa Fiber, que permite dividir o trabalho de renderização em partes e priorizar as atualizações.

Raridade: Muito Comum Dificuldade: Média

2. O que são React Hooks e por que foram introduzidos?

Resposta: Hooks são funções que permitem usar o estado e outros recursos do React em componentes funcionais.

• Motivação: Antes dos Hooks, a lógica stateful exigia componentes de classe. Os Hooks permitem reutilizar a lógica stateful sem alterar a hierarquia dos componentes.
• Hooks Comuns:
  • useState: Gerencia o estado local
  • useEffect: Lida com efeitos colaterais (busca de dados, assinaturas)
  • useContext: Acessa valores de contexto
  • useMemo/useCallback: Otimização de desempenho
• Hooks Customizados: Você pode criar hooks customizados para extrair e reutilizar a lógica do componente.

Raridade: Muito Comum Dificuldade: Fácil

3. Como você otimiza o desempenho de uma aplicação React?

Resposta: Múltiplas estratégias podem melhorar o desempenho do React:

1. Code Splitting: Use React.lazy() e Suspense para carregar componentes sob demanda.
2. Memoization: Use React.memo() para componentes, useMemo() para cálculos caros, useCallback() para referências de função.
3. Virtual Lists: Para listas longas, use bibliotecas como react-window ou react-virtualized.
4. Evite Funções Inline: Em métodos de renderização, pois eles criam novas referências em cada renderização.
5. Profiler: Use o React DevTools Profiler para identificar gargalos.
6. Gerenciamento de Estado: Mantenha o estado o mais local possível, use o contexto com sabedoria.

Raridade: Comum Dificuldade: Média

4. Explique a diferença entre Server-Side Rendering (SSR) e Client-Side Rendering (CSR).

Resposta:

• CSR: O JavaScript é executado no navegador para renderizar a página. O HTML inicial é mínimo. Navegação subsequente rápida, mas carregamento inicial mais lento e SEO ruim.
• SSR: O servidor gera HTML completo para cada solicitação. Melhor SEO e pintura inicial mais rápida, mas navegação subsequente mais lenta e maior carga do servidor.
• Abordagens Híbridas:
  • Static Site Generation (SSG): Pré-renderiza páginas no momento da construção (Next.js, Gatsby).
  • Incremental Static Regeneration (ISR): Atualiza páginas estáticas após a implantação sem reconstrução completa.

Raridade: Comum Dificuldade: Média

5. Qual é a diferença entre localStorage, sessionStorage e Cookies?

Resposta:

• localStorage: Persiste os dados sem expiração. Limite de ~5-10MB. Não é enviado para o servidor automaticamente.
• sessionStorage: Semelhante ao localStorage, mas é limpo quando a aba/navegador é fechado.
• Cookies: Pequenos dados (~4KB) enviados com cada requisição HTTP. Pode definir expiração. Usado para tokens de autenticação.
• Segurança: Os cookies podem ser HttpOnly (não acessíveis via JS) e Secure (somente HTTPS). Use para dados confidenciais.

Raridade: Comum Dificuldade: Fácil

6. Como funciona o CSS-in-JS e quais são suas desvantagens?

Resposta: As bibliotecas CSS-in-JS (styled-components, Emotion) permitem escrever CSS diretamente em JavaScript.

• Benefícios:
  • Estilos com escopo (sem poluição do namespace global)
  • Estilização dinâmica baseada em props
  • Prefixo de fornecedor automático
  • Eliminação de código morto
• Desvantagens:
  • Sobrecarga de tempo de execução (estilos gerados em tempo de execução)
  • Tamanho do pacote maior
  • Curva de aprendizado
• Alternativas: CSS Modules, Tailwind CSS, CSS tradicional com metodologia BEM.

Raridade: Média Dificuldade: Média

Desenvolvimento Backend (6 Perguntas)

7. Explique o Event Loop no Node.js.

Resposta: O Node.js é single-threaded, mas lida com a concorrência por meio do event loop.

• Fases:
  1. Timers: Executa callbacks de setTimeout e setInterval
  2. Pending callbacks: Callbacks de I/O adiados para a próxima iteração
  3. Poll: Recupera novos eventos de I/O, executa callbacks de I/O
  4. Check: Callbacks de setImmediate
  5. Close callbacks: Eventos de fechamento de socket
• Non-blocking I/O: Quando as operações de I/O são iniciadas, o Node.js as delega ao kernel do sistema e continua executando outro código.

console.log('1');
setTimeout(() => console.log('2'), 0);
Promise.resolve().then(() => console.log('3'));
console.log('4');
// Output: 1, 4, 3, 2

Raridade: Muito Comum Dificuldade: Difícil

8. O que é Middleware no Express.js?

Resposta: As funções de middleware têm acesso à solicitação, resposta e à próxima função de middleware no ciclo de solicitação-resposta da aplicação.

• Tipos:
  • Application-level: app.use()
  • Router-level: router.use()
  • Error-handling: Tem 4 parâmetros (err, req, res, next)
  • Built-in: express.json(), express.static()
  • Third-party: cors, helmet, morgan
• A ordem importa: O middleware é executado na ordem em que é definido.

app.use((req, res, next) => {
  console.log('Time:', Date.now());
  next();
});

Raridade: Muito Comum Dificuldade: Fácil

9. Como você lida com a autenticação em uma API REST?

Resposta: Existem várias abordagens:

• JWT (Stateless):
  • O servidor gera um token assinado contendo informações do usuário
  • O cliente armazena o token (localStorage/cookie) e envia com cada solicitação
  • O servidor verifica a assinatura
  • Prós: Escalável, sem armazenamento de sessão no lado do servidor
  • Contras: Difícil de revogar, payload maior
• Session-based (Stateful):
  • O servidor cria uma sessão, armazena no DB/Redis
  • O cliente recebe o ID da sessão no cookie
  • Prós: Fácil de revogar
  • Contras: Requer armazenamento no lado do servidor
• OAuth 2.0: Para autenticação de terceiros
• Melhor Prática: Use refresh tokens para acesso de longa duração, access tokens de curta duração.

Raridade: Muito Comum Dificuldade: Média

10. Explique as Transações de Banco de Dados e as propriedades ACID.

Resposta: Uma transação é uma sequência de operações realizadas como uma única unidade lógica de trabalho.

• ACID:
  • Atomicity: Todas as operações são bem-sucedidas ou todas falham (tudo ou nada)
  • Consistency: O banco de dados passa de um estado válido para outro
  • Isolation: Transações simultâneas não interferem umas nas outras
  • Durability: As transações confirmadas persistem mesmo após uma falha do sistema
• Isolation Levels: Read Uncommitted, Read Committed, Repeatable Read, Serializable (trade-off entre consistência e desempenho).

Raridade: Comum Dificuldade: Média

11. Qual é a diferença entre bancos de dados SQL e NoSQL?

Resposta:

• SQL (Relacional):
  • Esquema estruturado, tabelas com linhas/colunas
  • Compatível com ACID
  • Escalonamento vertical (servidor maior)
  • Exemplos: PostgreSQL, MySQL
  • Caso de uso: Consultas complexas, transações, dados estruturados
• NoSQL:
  • Esquema flexível, documento/chave-valor/gráfico/família de colunas
  • BASE (Eventually consistent)
  • Escalonamento horizontal (mais servidores)
  • Exemplos: MongoDB, Redis, Cassandra
  • Caso de uso: Desenvolvimento rápido, escala massiva, dados não estruturados

Raridade: Comum Dificuldade: Fácil

12. Como você evita ataques de SQL Injection?

Resposta: Ocorre SQL Injection quando a entrada do usuário é concatenada diretamente em consultas SQL.

• Prevenção:
  1. Parameterized Queries/Prepared Statements: Use espaços reservados para entrada do usuário
  2. ORMs: Bibliotecas como Sequelize, TypeORM manipulam o escaping automaticamente
  3. Input Validation: Lista de permissões de caracteres permitidos
  4. Least Privilege: O usuário do banco de dados deve ter permissões mínimas
  5. Stored Procedures: Pode fornecer uma camada adicional

// Ruim
const query = `SELECT * FROM users WHERE id = ${userId}`;

// Bom
const query = 'SELECT * FROM users WHERE id = ?';
db.execute(query, [userId]);

Raridade: Muito Comum Dificuldade: Fácil

Design de Sistemas e Arquitetura (6 Perguntas)

13. Como você projetaria um sistema de notificação escalável?

Resposta: Um sistema de notificação precisa lidar com vários canais (e-mail, SMS, push) em escala.

• Componentes:
  • API Service: Recebe solicitações de notificação
  • Message Queue: RabbitMQ/Kafka para processamento assíncrono
  • Workers: Serviços separados para cada canal
  • Database: Armazena histórico de notificações, preferências do usuário
  • Rate Limiting: Evitar spam
• Considerações:
  • Lógica de repetição para falhas
  • Filas de prioridade para notificações urgentes
  • Gerenciamento de templates
  • Preferências do usuário (opt-out)

Raridade: Comum Dificuldade: Difícil

14. Explique a arquitetura de Microsserviços e seus desafios.

Resposta: Microsserviços decompõem uma aplicação em serviços pequenos e independentes.

• Benefícios:
  • Implantação e escalonamento independentes
  • Diversidade de tecnologia
  • Isolamento de falhas
  • Autonomia da equipe
• Desafios:
  • Distributed Transactions: Difícil de manter a consistência entre os serviços
  • Network Latency: Sobrecarga de comunicação entre serviços
  • Monitoring: Necessidade de distributed tracing (Jaeger, Zipkin)
  • Data Management: Cada serviço possui seu banco de dados
  • Testing: O teste de integração é complexo
• Patterns: API Gateway, Service Mesh, Circuit Breaker, Saga pattern para transações.

Raridade: Muito Comum Dificuldade: Difícil

15. O que é Caching e quais são as estratégias de caching comuns?

Resposta: O caching armazena dados acessados ​​com frequência no armazenamento rápido para reduzir a latência.

• Layers:
  • Browser cache
  • CDN (CloudFlare, Akamai)
  • Application cache (Redis, Memcached)
  • Database query cache
• Strategies:
  • Cache-Aside: O aplicativo verifica o cache primeiro, carrega do DB em caso de falta
  • Write-Through: Grava no cache e no DB simultaneamente
  • Write-Behind: Grava no cache, gravação assíncrona no DB
  • Read-Through: Cache carrega dados do DB automaticamente
• Eviction Policies: LRU (Least Recently Used), LFU (Least Frequently Used), TTL (Time To Live).

Raridade: Muito Comum Dificuldade: Média

16. Como você garante o versionamento da API?

Resposta: O versionamento da API permite compatibilidade com versões anteriores ao fazer alterações.

• Strategies:
  • URI Versioning: /api/v1/users, /api/v2/users
  • Header Versioning: Accept: application/vnd.api.v1+json
  • Query Parameter: /api/users?version=1
• Best Practices:
  • Deprecation warnings
  • Manter pelo menos 2 versões
  • Guias de migração claros
  • Semantic versioning
• GraphQL Alternative: Schema evolution without versioning (deprecated fields).

Raridade: Comum Dificuldade: Média

17. Explique o Teorema CAP.

Resposta: Em sistemas distribuídos, você só pode garantir 2 de 3:

• Consistency: Todos os nós veem os mesmos dados ao mesmo tempo
• Availability: Cada solicitação recebe uma resposta (sucesso/falha)
• Partition Tolerance: O sistema continua operando apesar das falhas de rede
• Reality: As partições de rede acontecerão, então você deve escolher entre CP (Consistência) ou AP (Disponibilidade).
• Examples:
  • CP: MongoDB, HBase (sacrificar a disponibilidade durante a partição)
  • AP: Cassandra, DynamoDB (consistência eventual)

Raridade: Comum Dificuldade: Difícil

18. O que é Load Balancing e quais algoritmos são usados?

Resposta: O balanceamento de carga distribui o tráfego entre vários servidores.

• Algorithms:
  • Round Robin: Distribuição sequencial
  • Least Connections: Enviar para o servidor com menos conexões ativas
  • IP Hash: Hash do IP do cliente para determinar o servidor (persistência da sessão)
  • Weighted Round Robin: Servidores com maior capacidade recebem mais solicitações
• Types:
  • Layer 4 (Transport): Com base em IP/Porta, mais rápido
  • Layer 7 (Application): Com base no conteúdo (URL, cabeçalhos), mais inteligente
• Tools: Nginx, HAProxy, AWS ELB, Google Cloud Load Balancer.

Raridade: Comum Dificuldade: Média

DevOps e Nuvem (4 Perguntas)

19. Explique o Docker e os benefícios da conteinerização.

Resposta: O Docker empacota aplicações com suas dependências em contêineres.

• Benefícios:
  • Consistency: Mesmo ambiente em dev/staging/prod
  • Isolation: Cada contêiner é isolado
  • Lightweight: Compartilhar o kernel do SO host (vs VMs)
  • Fast startup: Segundos vs minutos para VMs
  • Portability: Execute em qualquer lugar onde o Docker esteja instalado
• Componentes:
  • Image: Template somente leitura
  • Container: Instância em execução de uma imagem
  • Dockerfile: Instruções para construir uma imagem
  • Registry: Docker Hub, private registries

Raridade: Muito Comum Dificuldade: Fácil

20. O que é CI/CD e por que é importante?

Resposta:

• Continuous Integration: Os desenvolvedores mesclam o código com frequência, os testes automatizados são executados em cada commit
• Continuous Deployment: Implanta automaticamente na produção após passar nos testes
• Benefícios:
  • Feedback mais rápido
  • Problemas de integração reduzidos
  • Código de maior qualidade
  • Tempo de lançamento no mercado mais rápido
• Tools: Jenkins, GitLab CI, GitHub Actions, CircleCI
• Pipeline Stages: Build → Test → Deploy
• Best Practices: Automated testing, feature flags, rollback mechanisms.

Raridade: Muito Comum Dificuldade: Fácil

21. Como você monitora e depura aplicações de produção?

Resposta: O monitoramento abrangente é fundamental para os sistemas de produção.

• Logging:
  • Structured logging (formato JSON)
  • Centralized logging (ELK Stack, Splunk)
  • Log levels (ERROR, WARN, INFO, DEBUG)
• Metrics:
  • Application metrics (response time, throughput)
  • Infrastructure metrics (CPU, memory, disk)
  • Tools: Prometheus, Grafana, DataDog
• Tracing:
  • Distributed tracing para microsserviços
  • Tools: Jaeger, Zipkin, AWS X-Ray
• Alerting: PagerDuty, Opsgenie para problemas críticos
• Error Tracking: Sentry, Rollbar para monitoramento de exceção.

Raridade: Comum Dificuldade: Média

22. O que é Infrastructure as Code (IaC)?

Resposta: O IaC gerencia a infraestrutura por meio de código, em vez de processos manuais.

• Benefícios:
  • Version control para infraestrutura
  • Ambientes reproduzíveis
  • Provisionamento mais rápido
  • Erro humano reduzido
• Tools:
  • Terraform: Cloud-agnostic, declarative
  • CloudFormation: AWS-specific
  • Ansible: Configuration management
  • Pulumi: Use programming languages
• Best Practices:
  • Store in version control
  • Modular, reusable components
  • Separate environments (dev/staging/prod)
  • Automated testing of infrastructure.

Raridade: Média Dificuldade: Média

Testes e Melhores Práticas (3 Perguntas)

23. Explique a Pirâmide de Testes.

Resposta: A pirâmide de testes representa a distribuição ideal de diferentes tipos de testes.

• Unit Tests: Teste funções/componentes individuais isoladamente. Rápido, muitos deles.
• Integration Tests: Teste como os componentes funcionam juntos. Velocidade média, número moderado.
• E2E Tests: Teste fluxos de usuário inteiros. Lento, caro, poucos deles.
• Rationale: Mais testes de unidade porque são rápidos e detectam bugs precocemente. Menos testes E2E porque são lentos e frágeis.

Raridade: Comum Dificuldade: Fácil

24. O que são os princípios SOLID?

Resposta: SOLID é um acrônimo para cinco princípios de design:

• S - Single Responsibility: Uma classe deve ter um motivo para mudar
• O - Open/Closed: Aberto para extensão, fechado para modificação
• L - Liskov Substitution: Os subtipos devem ser substituíveis por seus tipos base
• I - Interface Segregation: Muitas interfaces específicas são melhores do que uma geral
• D - Dependency Inversion: Dependa de abstrações, não de concretizações
• Benefícios: Código mais fácil de manter, testar e flexível.

Raridade: Comum Dificuldade: Média

25. Como você lida com erros em JavaScript assíncrono?

Resposta: Existem vários padrões para tratamento de erros assíncronos:

• Promises:

fetch('/api/data')
  .then(response => response.json())
  .catch(error => console.error('Error:', error));

• Async/Await:

try {
  const response = await fetch('/api/data');
  const data = await response.json();
} catch (error) {
  console.error('Error:', error);
}

• Global Error Handlers:
  • window.addEventListener('unhandledrejection', ...) para rejeições de promessas não tratadas
  • Express error middleware para backend
• Best Practice: Sempre trate os erros, use o tratamento de erros centralizado, registre os erros corretamente.

Raridade: Muito Comum Dificuldade: Fácil