Prompt

Criar um questionário de RFP, a ser enviado para uma consultoria de software, para desenvolvimento de uma aplicação em Java, Angular, API First, Spring Boot e melhores práticas de desenvolvimento. Vou informando os tópicos a serem avaliados e gerando pelo menos 15 questões mais importantes/usadas. Continue me perguntando se há mais tópicos até que eu responda “não há mais tópicos” Entendeu?

Resposta A

Claro! Para o tópico “Linguagem, Experiência e Portfólio”, elaborei as seguintes questões essenciais para avaliar a capacidade técnica e a relevância da consultoria:

1. Experiência com Java:
   Quantos anos de experiência a empresa possui com Java? Especifique as versões com as quais já trabalhou (ex.: Java 8, 11, 17) e destaque projetos relevantes que utilizem recursos avançados (ex.: Stream API, Records, Virtual Threads).

2. Experiência com Angular:
   Qual é a experiência da equipe com Angular? Mencione as versões utilizadas (ex.: Angular 14, 16) e exemplos de aplicação de RxJS, Ngrx, Lazy Loading ou SSR (Angular Universal).

3. Spring Boot:
   Quantos projetos em Spring Boot a consultoria já concluiu? Podem destacar 1 projeto com foco em:

   • Microserviços?
   • Segurança (OAuth2, JWT)?
   • Integração com bancos de dados (JPA/Hibernate)?

4. API First:
   Vocês têm experiência com desenvolvimento API First (REST/GraphQL)? Descreva:

   • Como definem specifications (ex.: OpenAPI/Swagger)?
   • Como garantem versionamento e documentação automática?

5. Portfólio:
   Podem compartilhar links ou descrições de 2-3 projetos similares ao solicitado (com foco em Java, Angular, Spring Boot e API First)? Inclua:

   • Escopo e complexidade.
   • Tecnologias específicas utilizadas.
   • Resultados alcançados (ex.: redução de tempo, escalabilidade).

6. Equipe Técnica:
   Qual é o tamanho e a estrutura da equipe proposta para este projeto?

   • Quantos desenvolvedores Java, Angular e especialistas em Spring Boot?
   • Qual é a experiência média da equipe com as tecnologias exigidas?

7. Certificações e Atualização:

   • A consultoria possui certificações oficiais nas tecnologias mencionadas (ex.: Spring Professional, Oracle Certified Java)?
   • Como a equipe se mantém atualizada com as tendências das linguagens (ex.: cursos, comunidades, proof of concept)?

Total de questões geradas até o momento: 7

👉 Pergunta para você:
Há mais tópicos a serem avaliados (ex.: Metodologia, Arquitetura, Segurança, Suporte)?
(Responda com “não há mais tópicos” quando terminar).

(Continuação do questionário RFP)

8. Abordagem de Arquitetura:
   Como a consultoria define a arquitetura técnica para projetos similares? Utilizam microserviços, monolítico ou híbrido? Podem explicar a escolha com base em requisitos de escalabilidade, manutenção e complexidade?

9. Escalabilidade:
   Quais estratégias são adotadas para garantir a escalabilidade horizontal e vertical da aplicação? Como lidam com picos de tráfego (ex.: load balancing, auto-scaling)?

10. Microserviços (se aplicável):
    Para projetos com microserviços, como é gerenciada a comunicação entre serviços (ex.: REST, gRPC, mensagens)? Quais ferramentas utilizam para service discovery (ex.: Eureka, Consul), circuit breakers (ex.: Resilience4j) e distributed tracing (ex.: Jaeger, Zipkin)?

11. Estratégia de Banco de Dados:
    Qual banco de dados (SQL/NoSQL) é recomendado para este projeto? Como é configurada a conexão (ex.: HikariCP), caching (Redis) e replicação? Como lidam com transações distribuídas?

12. Design de API:
    Como estruturam APIs REST/GraphQL? Utilizam HATEOAS, versionamento (URL, headers) e padrões de error handling (ex.: códigos HTTP específicos)? Como garantem consistência entre a especificação (OpenAPI/Swagger) e a implementação?

13. Testes Automatizados:
    Quais tipos de testes são realizados (unitários, integração, e2e)? Quais frameworks são utilizados (ex.: JUnit 5, Mockito, Testcontainers, Selenium)? Qual é a cobertura mínima esperada? Como é tratada a testabilidade da arquitetura?

14. Pipeline CI/CD:
    Quais ferramentas são empregadas para integração contínua e entrega contínua (ex.: Jenkins, GitLab CI, GitHub Actions)? Como são configuradas as etapas (build, testes, infrastructure as code)? Qual é a estratégia de canary releases ou blue-green deployment?

15. Segurança:
    Como abordam autenticação (OAuth2, JWT, SAML) e autorização (RBAC, ABAC)? Quais medidas são tomadas para mitigar riscos do OWASP Top 10 (ex.: injeção SQL, XSS, broken access control)? Como é tratada a criptografia de dados em repouso e em trânsito?

Total de questões geradas até o momento: 15

👉 Pergunta para você:
Há mais tópicos a serem avaliados (ex.: Metodologia, Suporte, Orçamento, Gestão de Projetos)?
(Responda com “não há mais tópicos” quando terminar).

(Continuação do questionário RFP)

16. Estrutura de Projetos:
    Como é organizada a estrutura de um projeto Spring Boot na consultoria? Vocês seguem padrões como Clean Architecture, Hexagonal Architecture ou DDD? Descreva a divisão em camadas (controller, service, repository, domain) e como lidam com dependências entre elas.

17. Gestão de Dependências:
    Quais ferramentas de gestão de dependências são utilizadas (Maven/Gradle)? Como garantem compatibilidade de versões e evitam conflitos? Existe política para uso de dependency management (ex.: Spring Boot Starter Parent, BOM)?

18. Transações e Integridade de Dados:
    Como são configuradas as transações em Spring Boot (@Transactional)? Quais estratégias adotam para propagation, isolation levels e rollbacks? Como garantem a integridade de dados em operações complexas (ex.: sagas para transações distribuídas)?

19. Validação de Dados:
    Qual abordagem utilizam para validação de dados (ex.: Bean Validation – JSR-380)? Como implementam validadores personalizados e como são integrados às APIs (ex.: @Valid, global validation filters)?

20. Tratamento de Erros:
    Como estruturam o tratamento de erros no back-end? Utilizam @ControllerAdvice, global exception handlers ou outras estratégias? Como são formatadas as respostas de erro (ex.: JSON com código HTTP, mensagem, detalhes, stack trace em ambiente de desenvolvimento)?

21. Performance e Otimização:
    Quais técnicas são aplicadas para otimizar o desempenho (ex.: caching com Redis, connection pooling com HikariCP)? Como identificam bottlenecks (ex.: perfilamento com VisualVM, JFR, Micrometer)? Como lidam com query optimization (ex.: N+1 problem)?

22. Testes no Back-end:
    Quais tipos de testes são realizados no back-end (unitários, integração)? Quais frameworks são utilizados (JUnit 5, Mockito, Testcontainers)? Qual é a cobertura mínima esperada e como é garantida a testabilidade (ex.: dependency injection para mocks)?

Total de questões geradas até o momento: 22

👉 Pergunta para você:
Há mais tópicos a serem avaliados (ex.: Desenvolvimento Front-end (Angular), Metodologia, Suporte, Orçamento, Gestão de Projetos)?
(Responda com “não há mais tópicos” quando terminar).

(Continuação do questionário RFP)

23. Estrutura do Projeto Angular:
    Como é organizada a estrutura de um projeto Angular na consultoria? Vocês seguem padrões como Feature Modules, Shared Modules ou Nx Workspace? Descreva a divisão em camadas (componentes, serviços, diretivas) e como implementam lazy loading e dependency injection.

24. Gestão de Estado:
    Utilizam bibliotecas de gestão de estado (ex.: NgRx, Akita, Zustand)? Como estruturam actions, reducers, effects (no caso do NgRx) e como garantem a consistência do estado entre componentes? Como lidam com cenários de state persistence (ex.: armazenamento local)?

25. Comunicação entre Componentes:
    Qual abordagem adotam para comunicação entre componentes (ex.: @Input/@Output, services, BehaviorSubject)? Como resolvêm problemas complexos de interação (ex.: fluxos assíncronos, event emitters)?

26. Desempenho e Otimização:
    Quais técnicas são aplicadas para otimizar o desempenho (ex.: OnPush change detection, virtual scrolling, code splitting)? Como identificam bottlenecks (ex.: Chrome DevTools, Lighthouse) e como lidam com N+1 queries no front-end (ex.: batching)?

27. Testes Automatizados:
    Quais tipos de testes são realizados no front-end (unitários, integração, e2e)? Quais frameworks são utilizados (Jasmine, Karma, Cypress)? Qual é a cobertura mínima esperada e como é tratada a testabilidade (ex.: dependency injection para mocks)?

28. Integração com APIs:
    Como é feita a integração com as APIs do back-end (ex.: uso do HttpClient, interceptors para autenticação/log)? Como tratam erros de rede, respostas inválidas ou timeouts? Como garantem a consistência dos dados entre o front-end e o back-end?

29. Segurança:
    Quais medidas são adotadas para mitigar riscos de segurança no front-end (ex.: prevenção de XSS, CSRF tokens, content security policy – CSP)? Como lidam com sensitive data (ex.: mascarar campos, evitar hardcoding)?

30. Design Responsivo e Acessibilidade:
    Como implementam design responsivo (ex.: Angular Material, Bootstrap, CSS Grid)? Qual é o compromisso com acessibilidade (WCAG 2.1) e como validam (ex.: axe-core, Lighthouse)?

Total de questões geradas até o momento: 30

👉 Pergunta para você:
Há mais tópicos a serem avaliados (ex.: Metodologia, Suporte, Orçamento, Gestão de Projetos)?
(Responda com “não há mais tópicos” quando terminar).

(Continuação do questionário RFP)

31. Processo de QA Integrado:
    Como a consultoria integra o processo de Quality Assurance (QA) ao ciclo de desenvolvimento (ex.: Agile/Scrum)? Qual é a proporção entre testes manuais e automatizados, e como são definidos os critérios para priorização?

32. Ferramentas de Testes de Performance:
    Quais ferramentas específicas são utilizadas para testes de performance (ex.: JMeter, Gatling, Locust)? Como são configurados os cenários de teste (ex.: carga, estresse, endurance) e como são validados os resultados?

33. Metrícas de Performance:
    Como são definidos os critérios de performance aceitáveis (ex.: tempo de resposta ≤ 2s, throughput ≥ 100 req/s)? Como são validados em ambiente de staging e produção?

34. Testes de Carga e Estresse:
    Qual é o número máximo de usuários simulados nos testes de carga? Como é modelado o tráfego real (ex.: distribuição geográfica, picos sazonais)? Como lidam com bottlenecks identificados?

35. Monitoramento de Performance em Produção:
    Quais ferramentas são utilizadas para monitoramento em tempo real (ex.: Prometheus, Grafana, Datadog)? Como são configurados os alerts críticos (ex.: CPU > 80%, erros > 5%)?

36. Análise Estática de Código:
    Quais ferramentas são empregadas para análise estática (ex.: SonarQube, PMD, Checkstyle)? Quais métricas são monitoradas (ex.: complexidade ciclomática, duplicação de código, code smells)?

37. Metas de Cobertura de Testes:
    Quais são as metas específicas de cobertura para este projeto (ex.: unitários ≥ 80%, integração ≥ 70%, e2e ≥ 50%)? Como são medidos e validados?

38. Manutenção de Testes Automatizados:
    Como garantem a manutenção dos testes automatizados? Qual é o processo para atualizá-los após mudanças na aplicação (ex.: refactoring, novas funcionalidades)?

39. Tratamento de Testes “Flaky”:
    Como identificam e resolvem testes intermitentes (flaky tests)? Qual é a estratégia para reduzir sua ocorrência (ex.: retries, isolamento de dependências)?

40. Estratégia de Logging:
    Qual é a estrutura padrão de logs (ex.: JSON, formato estruturado)? Quais níveis de log são utilizados (DEBUG, INFO, ERROR)? Quais ferramentas são usadas para coleta/análise (ex.: ELK Stack, Sentry, Splunk)?

41. Procedimentos de Rollback:
    Qual é o processo para rollback em produção em caso de falha? Como é testado o rollback antes da implantação (ex.: dry-run)?

42. Resposta a Incidentes:
    Como é estruturado o incident response? Qual é o tempo médio de detecção (MTTD) e resolução (MTTR) esperado? Há playbooks definidos para cenários comuns?

43. Análise Pós-Incidente (Post-Mortem):
    Após um incidente, como é realizada a análise post-mortem? Quais lições são documentadas e incorporadas ao processo de desenvolvimento?

44. Testes de Segurança Integrados:
    Como os testes de segurança (ex.: OWASP Top 10) são integrados aos testes automatizados? Quais ferramentas são usadas (ex.: OWASP ZAP, Snyk, Trivy)?

45. Validação de Acessibilidade (WCAG):
    Como garantem a conformidade com padrões de acessibilidade (ex.: WCAG 2.1)? Quais ferramentas são utilizadas para validação (ex.: axe-core, Lighthouse)?

Total de questões geradas até o momento: 45

👉 Pergunta para você:
Há mais tópicos a serem avaliados (ex.: Metodologia, Suporte, Orçamento, Gestão de Projetos)?
(Responda com “não há mais tópicos” quando terminar).

(Continuação do questionário RFP)

46. Tipos de Documentação:
    Quais tipos de documentação serão fornecidos durante o projeto (ex.: técnica, de API, arquitetural, de usuário, de treinamento)? Descreva brevemente o conteúdo de cada um e como serão organizados.

47. Padrões e Ferramentas:
    Quais padrões ou frameworks são seguidos para a documentação (ex.: IEEE 830 para requisitos, OpenAPI para APIs)? Quais ferramentas serão utilizadas (ex.: Confluence, Markdown, Sphinx, PlantUML)?

48. Documentação de API (API First):
    Como será documentada a API (ex.: OpenAPI/Swagger, Redoc, Postman Collection)? Podem compartilhar um exemplo de especificação real ou simulada (com campos-chave como endpoints, parâmetros, respostas de exemplo)?

49. Diagramas Arquiteturais:
    Quais diagramas serão produzidos (ex.: arquitetura de alto nível, fluxo de dados, componentes, sequência)? Quais ferramentas serão usadas (ex.: Lucidchart, Draw.io, Mermaid.js)? Como serão integrados à documentação técnica?

50. Documentação do Código:
    Quais padrões de comentários e documentação no código serão adotados (ex.: Javadoc, JSDoc, docstrings)? Como garantem a qualidade e a consistência (ex.: ferramentas de validação, code reviews)?

51. Documentação do Usuário Final:
    Que tipos de materiais para usuários finais serão fornecidos (ex.: manuais, guias rápidos, FAQs, vídeos)? Como serão estruturados e validados com o público-alvo?

52. Documentação de Treinamento:
    Serão oferecidos materiais de treinamento para a equipe do cliente (ex.: apresentações, tutoriais interativos, playbooks)? Qual é o formato e a profundidade técnica prevista?

53. Entregas por Fase:
    Quais são as principais entregas em cada fase do projeto (ex.: análise de requisitos, design, desenvolvimento, teste, implantação)? Inclua detalhes sobre prazos e formatos esperados.

54. Processo de Revisão e Aprovação:
    Qual é o fluxo para revisão e aprovação da documentação e entregas (ex.: etapas, responsáveis, prazos)? Como são resolvidas divergências entre a equipe e o cliente?

55. Atualização da Documentação:
    Como a documentação será mantida atualizada após a entrega? Será incluída no suporte pós-implantação? Qual é o compromisso com versionamento e histórico de alterações?

56. Controle de Versão:
    Como será gerenciado o controle de versão da documentação (ex.: integração com repositórios de código como Git, branches dedicadas)?

57. Exemplos de Entregas Anteriores:
    Podem compartilhar exemplos anônimos ou com confidencialidade mantida de documentos ou entregas similares de projetos anteriores (ex.: especificação de API, diagramas, manuais)?

58. Captura e Documentação de Requisitos:
    Como os requisitos serão documentados (ex.: user stories, casos de uso, acceptance criteria)? Qual é o formato e as ferramentas utilizadas (ex.: Jira, Confluence)?

59. Impacto de Mudanças:
    Como mudanças nos requisitos afetarão a documentação e as entregas? Qual é o processo para atualizá-las e comunicar impactos ao cliente?

60. Formato Final de Entrega:
    Qual é o formato final das entregas (ex.: PDF, HTML, repositório GitHub, pacote ZIP)? Como serão organizadas (ex.: pastas por módulo, indexação clara)?

Total de questões geradas até o momento: 60

👉 Pergunta para você:
Há mais tópicos a serem avaliados (ex.: Metodologia, Suporte, Orçamento, Gestão de Projetos)?
(Responda com “não há mais tópicos” quando terminar).

(Continuação do questionário RFP)

61. Plataformas de Nuvem:
    Quais plataformas de nuvem (AWS, Azure, GCP, etc.) são especializadas? Quais critérios são utilizados para recomendar uma plataforma específica para este projeto (ex.: custos, requisitos técnicos, compliance)?

62. Infraestrutura como Código (IaC):
    Utilizam ferramentas de IaC (ex.: Terraform, AWS CloudFormation, Azure Resource Manager)? Como versionam e validam a infraestrutura antes da implantação? Como lidam com drift entre o código e o ambiente real?

63. Pipeline CI/CD:
    Qual pipeline de CI/CD propõem para este projeto? Quais ferramentas serão utilizadas (ex.: Jenkins, GitLab CI, GitHub Actions)? Como são configuradas as etapas de build, testes, deploy e rollback? Como a infraestrutura é provisionada automaticamente durante o pipeline?

64. Containerização e Orquestração:
    Como utilizam Docker para containerização? Possuem experiência com Kubernetes (ou alternativas como Docker Swarm) para orquestração? Como gerenciam scaling, rolling updates e resource allocation?

65. Monitoramento e Logging:
    Quais ferramentas são empregadas para monitoramento em tempo real (ex.: Prometheus, Grafana, Datadog) e coleta de logs (ex.: ELK Stack, Splunk)? Quais métricas críticas são monitoradas (ex.: CPU, memória, tempo de resposta)? Como são configurados os alerts?

66. Segurança na Infraestrutura (SecOps):
    Como garantem a segurança da infraestrutura (ex.: firewalls, IAM, network segmentation)? Quais práticas de hardening são adotadas? Como lidam com vulnerabilities identificadas (ex.: SAST/DAST, patch management)?

67. Serverless e Event-Driven:
    Possuem experiência com arquiteturas serverless (ex.: AWS Lambda, Azure Functions, Google Cloud Functions)? Em quais cenários recomendariam essa abordagem? Como gerenciam cold starts e cost optimization?

68. Gestão de Ambientes:
    Como são configurados os ambientes (desenvolvimento, staging, produção)? Como garantem o isolation entre eles? Como são sincronizados dados e configurações entre ambientes?

69. Recuperação de Desastres (DR):
    Qual é o plano de recuperação de desastres? Como são configurados backups, replication e failover? Com que frequência são testados os cenários de DR?

70. Gestão de Custos na Nuvem:
    Quais estratégias são adotadas para otimizar custos (ex.: right-sizing, reserved instances, spot instances)? Como monitoram e relatam os gastos com infraestrutura?

71. Automação de Deployments:
    Qual é a frequência de deployments esperada? Como são gerenciados canary releases, blue-green deployment ou feature toggles? Como garantem a repeatability dos deployments?

72. Configuração de Redes:
    Como projetam a rede (ex.: VPC, sub-redes, security groups)? Como configuram load balancers, CDNs e DNS? Como lidam com cross-region ou multi-cloud?

73. Bancos de Dados na Nuvem:
    Quais serviços de banco de dados gerenciados são recomendados (ex.: Amazon RDS, Azure Cosmos DB, Google Cloud Spanner)? Como são configurados backups, replication e scaling? Como lidam com transações distribuídas?

74. Atualizações e Patches:
    Qual é o processo para aplicação de atualizações e patches na infraestrutura? Como mitigar riscos de downtime durante atualizações? Como são testadas as atualizações antes da implantação?

75. Compliance e Auditoria:
    Como garantem conformidade com padrões como GDPR, LGPD, PCI-DSS? Quais ferramentas são utilizadas para auditing e geração de relatórios? Como lidam com data residency?

Total de questões geradas até o momento: 75

👉 Pergunta para você:
Há mais tópicos a serem avaliados (ex.: Metodologia, Suporte, Orçamento, Gestão de Projetos)?
(Responda com “não há mais tópicos” quando terminar).

(Continuação do questionário RFP)

76. Experiência com PostgreSQL: Quantos projetos a consultoria já executou utilizando PostgreSQL? Quais versões foram empregadas (ex.: 12, 14, 15) e quais recursos avançados foram utilizados (ex.: JSONB, partições, logical replication, materialized views, extension PL/pgSQL)?

77. Design de Esquema: Qual é a abordagem para projetar o esquema do banco de dados (ex.: normalização até a 3FN, desnormalização controlada)? Como definem estratégias de indexing (ex.: índices B-tree, GIN, GiST) e chaves estrangeiras? Como lidam com relacionamentos complexos (ex.: many-to-many, hierarchical data)?

78. Otimização de Consultas: Como identificam e resolvem consultas lentas (ex.: uso de EXPLAIN ANALYZE, pg_stat_statements, query hints)? Quais práticas adotam para evitar N+1 queries, full table scans ou lock contention?

79. Replicação e Alta Disponibilidade: Quais estratégias de replicação são utilizadas (ex.: streaming replication, logical replication)? Como é configurado o failover automático (ex.: Patroni, repmgr, AWS RDS Multi-AZ)? Como garantem data consistency entre réplicas?

80. Backups e Recuperação: Qual é a estratégia de backups (ex.: full, incremental, WAL archiving)? Como garantem Point-in-Time Recovery (PITR)? Com que frequência são testados os cenários de recuperação (ex.: chaos engineering)?

81. Segurança: Como gerenciam usuários, funções e permissões (ex.: RBAC, row-level security)? Quais medidas são tomadas para criptografia de dados em trânsito (TLS) e em repouso (TDE, pgcrypto)? Como auditam acessos e modificações (ex.: pgAudit, ALTER TABLE … SET DEFAULT)?

82. Migração para PostgreSQL: Possuem experiência em migrar dados de outros bancos (ex.: Oracle, SQL Server, MySQL) para PostgreSQL? Quais ferramentas são utilizadas (ex.: pgloader, AWS DMS, ETL customizado)? Como lidam com diferenças sintáticas, tipos de dados e stored procedures?

83. Integração com Spring Boot: Como configuram a conexão com PostgreSQL no Spring Boot (ex.: HikariCP, JPA properties)? Qual é o fluxo para migrações de esquema (ex.: Flyway, Liquibase)? Como utilizam Entity Graphs para otimizar fetching e evitar lazy loading em excesso?

84. Monitoramento e Performance: Quais ferramentas são empregadas para monitoramento (ex.: pgAdmin, Datadog, Prometheus)? Quais métricas críticas são acompanhadas (ex.: lock contention, I/O wait, connection pool usage, cache hit ratio)?

85. Escalabilidade: Como escalam PostgreSQL verticalmente (ex.: connection pooling, read replicas) ou horizontalmente (ex.: sharding com Citus, partitioning)? Como lidam com picos de carga (ex.: auto-scaling de réplicas)?

86. Particionamento: Quais tipos de partição são recomendados para grandes tabelas (ex.: range, list, hash)? Como gerenciam partition pruning, maintenance (ex.: REINDEX, VACUUM) e data retention?

87. Governança de Dados: Como definem e aplicam políticas de qualidade de dados (ex.: validação de campos, data cleansing, data validation rules)? Quais ferramentas são utilizadas para gestão de metadata (ex.: Apache Atlas, AWS Glue, custom catalog)?

88. Compliance: Como garantem conformidade com regulamentações (ex.: GDPR, LGPD, PCI-DSS)? Quais práticas adotam para data residency, anonymization (ex.: dynamic data masking), data retention e right to be forgotten?

89. Linhagem de Dados: Qual é a abordagem para rastrear a origem e transformação dos dados (ex.: Apache Atlas, Collibra, custom lineage tracking)? Como isso é integrado ao processo de desenvolvimento (ex.: data pipelines, ETL)?

90. Controle de Acesso e Audit Trail: Como implementam RBAC ou ABAC? Qual é o processo para geração de audit logs (ex.: pgAudit, JSONB logs) e relatórios de conformidade? Como definem data ownership e stewardship?

91. Atualizações de Versão: Qual é o processo para atualizar versões do PostgreSQL (ex.: pg_upgrade, dump/restore, cloud-managed services)? Como mitigam riscos de downtime ou incompatibilidades (ex.: testing in staging)?

92. Ferramentas de Administração: Quais ferramentas são utilizadas para administração diária (ex.: DBeaver, pgAdmin, psql)? Como automatizam tarefas repetitivas (ex.: cron jobs, pgAgent, Ansible)?

93. Catálogo de Dados: Possuem experiência na criação de um data catalog? Como organizam informações sobre tabelas, colunas, proprietários e dependências (ex.: schema registry, custom UI)?

94. Gestão de Custos na Nuvem: Como otimizam custos com PostgreSQL na nuvem (ex.: right-sizing, reserved instances, auto-scaling)? Como monitoram e relatam gastos com infraestrutura (ex.: AWS Cost Explorer, Azure Cost Management)?

Total de questões geradas até o momento: 94

👉 Pergunta para você:
Há mais tópicos a serem avaliados (ex.: Metodologia, Suporte, Orçamento, Gestão de Projetos)?
(Responda com “não há mais tópicos” quando terminar).

(Continuação do questionário RFP)

95. Modelagem de Ameaças:
    Vocês realizam modelagem de ameaças durante a fase de projeto? Quais metodologias utilizam (ex.: STRIDE, PASTA)? Podem compartilhar um exemplo de como ameaças foram identificadas e mitigadas em um projeto anterior?

96. Testes de Segurança:
    Quais tipos de testes de segurança estão incluídos em seu processo (ex.: SAST, DAST, IAST, penetration testing)? Quais ferramentas utilizam (ex.: OWASP ZAP, SonarQube, Burp Suite)? Com que frequência esses testes são executados?

97. Experiência com Frameworks de Compliance:
    Podem detalhar sua experiência com frameworks específicos (ex.: GDPR, LGPD, PCI-DSS, HIPAA)? Forneçam exemplos de projetos em que alcançaram compliance e os principais desafios enfrentados.

98. Plano de Resposta a Incidentes:
    Vocês possuem um plano formal de resposta a incidentes? Quais são as etapas-chave, papéis e responsabilidades? Com que frequência o plano é testado (ex.: exercícios de mesa)?

99. Medidas de Proteção de Dados:
    Quais medidas implementam para anonymização ou pseudonimização de dados? Como lidam com solicitações de retenção/exclusão de dados (ex.: “direito ao esquecimento” sob GDPR)?

100. Gestão de Riscos de Terceiros:
     Como avaliam a postura de segurança de bibliotecas, APIs e fornecedores externos? Realizam Análise de Composição de Software (SCA) (ex.: Snyk, Dependabot)?

101. Práticas de Codificação Segura:
     Quais práticas de codificação segura são integradas ao processo de desenvolvimento? Como garantem que os desenvolvedores as sigam (ex.: revisões de código, checks automatizados)?

102. Documentação de Compliance:
     Qual documentação relacionada à segurança é fornecida (ex.: políticas de segurança, trilhas de auditoria, risk assessments)? Como é mantida e atualizada?

103. Privacidade por Design:
     Como incorporam os princípios de “Privacy by Design” no ciclo de vida do desenvolvimento? Podem fornecer um exemplo prático?

104. Autenticação e Autorização Avançada:
     Além do abordado em seções anteriores, quais estratégias utilizam para gestão de sessões, tokens (ex.: refresh tokens) ou autenticação multifator (MFA)?

105. Gestão de Segredos:
     Como gerenciam dados sensíveis (ex.: API keys, senhas) no ambiente de desenvolvimento? Utilizam ferramentas de gestão de segredos (ex.: HashiCorp Vault, AWS Secrets Manager)?

106. Treinamento em Segurança:
     Que treinamento em segurança os desenvolvedores e a equipe recebem? Como medem a eficácia desse treinamento?

107. Compliance com provedores de nuvem:
     Como garantem compliance ao usar serviços em nuvem (ex.: AWS Well-Architected Framework, Azure Security Center)?

108. Auditorias de Segurança Regulares:
     Realizam auditorias internas ou externas de segurança? Como as descobertas são tratadas e acompanhadas?

109. Consultoria Jurídica e Regulatória:
     Colaboram com especialistas jurídicos para garantir compliance com leis relevantes? Como se mantêm atualizados sobre mudanças regulatórias?

Total de questões geradas até o momento: 109

👉 Pergunta para você:
Há mais tópicos a serem avaliados (ex.: Metodologia, Suporte, Orçamento, Gestão de Projetos)?
(Responda com “não há mais tópicos” quando terminar).

(Continuação do questionário RFP)

95. Padrões de Codificação:
    Quais padrões de estilo e codificação são seguidos (ex.: Google Style Guide, SonarQube rules, Airbnb Style Guide)? Como são aplicados (ex.: linters, formatters como Prettier, Checkstyle)? Como garantem a consistência entre a equipe?

96. Estratégia de Controle de Versão (Git):
    Qual é a estratégia de Git utilizada (ex.: Git Flow, GitHub Flow, Trunk-Based Development)? Como gerenciam branches (ex.: feature/, hotfix/), pull requests e merges (ex.: squash, rebase)? Como lidam com merge conflicts?

97. Processo de Revisão de Código (Code Review):
    Qual é o fluxo para code reviews? Quantos revisores são necessários? Quais critérios são usados para aprovação (ex.: cobertura de testes, aderência a padrões)? Como lidam com feedbacks divergentes?

98. Padrões de Projeto:
    Quais padrões de projeto são comumente aplicados (ex.: Singleton, Factory, MVC, MVVM, CQRS)? Como decidem quando adotá-los? Podem compartilhar um exemplo de problema resolvido com um padrão específico?

99. Gestão de Dívida Técnica:
    Como identificam e priorizam dívidas técnicas (ex.: technical debt backlog)? Existe um processo para alocar tempo para refactoring (ex.: % do sprint)? Como medem o impacto da dívida na produtividade?

100. Test-Driven Development (TDD) / Behavior-Driven Development (BDD):
     Utilizam TDD ou BDD? Como integraram essas práticas ao fluxo de trabalho (ex.: red-green-refactor)? Quais frameworks são usados (ex.: JUnit 5 + Mockito para TDD, Cucumber para BDD)?

101. Programação em Dupla (Pair Programming):
     Adotam pair programming ou mob programming? Em quais cenários (ex.: resolução de problemas complexos, onboarding)? Qual é a divisão de papéis (ex.: driver e navigator)?

102. Refatoração de Código:
     Qual é o processo para refactoring? Como garantem que não introduzam regressões (ex.: testes automatizados, rollback)? Como documentam as mudanças?

103. Sistemas de Design (Front-end):
     Para projetos Angular, utilizam design systems (ex.: Angular Material, NG-ZORRO, custom)? Como são mantidos (ex.: versionamento, documentação)? Como garantem consistência visual e funcional?

104. Gestão de Dependências:
     Como gerenciam dependências de bibliotecas (ex.: evitar version drift, transitive dependencies)? Utilizam BOMs (ex.: Spring Boot Starter Parent)? Como lidam com breaking changes?

105. Documentação de Código (In-Code):
     Quais padrões seguem para comentários e documentação (ex.: Javadoc, JSDoc, docstrings)? Como garantem a qualidade e a atualização (ex.: integração com linters)?

106. Métricas de Qualidade de Código:
     Quais métricas são monitoradas (ex.: complexidade ciclomática, duplicação de código, coesão)? Como são definidos os quality gates (ex.: SonarQube thresholds)?

107. Integração Contínua (CI) – Foco no Desenvolvedor:
     Como configuram os builds automatizados? Quais etapas são executadas antes do commit (ex.: testes unitários, análise estática)? Como lidam com build failures?

108. Deployment Contínuo (CD) – Foco no Desenvolvedor:
     Como garantem que as mudanças sejam deployadas de forma segura (ex.: feature toggles, canary releases)? Qual é a frequência média de deploys para ambientes de staging?

109. Gestão de Requisitos durante o Desenvolvimento:
     Como lidam com mudanças nos requisitos durante o desenvolvimento (ex.: user stories, acceptance criteria)? Qual é o processo para atualização e validação com o cliente?

110. Padrões de Erros e Logging:
     Como estruturam error handling no código (ex.: custom exceptions, error codes)? Como garantem que logs sejam úteis para debugging (ex.: contexto adicional, structured logging)?

111. Segurança no Código-Fonte:
     Como evitam anti-patterns de segurança (ex.: hardcoded secrets, SQL injection)? Quais práticas são adotadas para input validation (ex.: regex, validators)?

112. Testabilidade do Código:
     Como projetam o código para ser testável (ex.: dependency injection, avoiding singletons)? Como lidam com legacy code não testável?

113. Métricas de Produtividade:
     Quais métricas são usadas para avaliar a produtividade da equipe (ex.: velocity, lead time)? Como evitam gaming dessas métricas?

114. Padrões de Comunicação:
     Como a equipe se comunica sobre decisões técnicas (ex.: design decisions, trade-offs)? Utilizam ferramentas específicas (ex.: Confluence, ADRs – Architecture Decision Records)?

115. Atualização Contínua de Conhecimento:
     Como a equipe se mantém atualizada com as melhores práticas (ex.: workshops, comunidades, proof of concept)? Como compartilham knowledge (ex.: *sessions de brown bag)?

Total de questões geradas até o momento: 115

👉 Pergunta para você:
Há mais tópicos a serem avaliados (ex.: Metodologia, Suporte, Orçamento, Gestão de Projetos)?
(Responda com “não há mais tópicos” quando terminar).

(Continuação do questionário RFP)

116. Experiência com SSO:
     Quantos projetos de SSO a consultoria já implementou? Podem detalhar os protocolos utilizados (ex.: SAML, OAuth 2.0, OpenID Connect) e os provedores de identidade (IdP) integrados (ex.: Azure AD, Okta, Ping Identity, Keycloak)?

117. Estratégia de IAM:
     Qual é a experiência da equipe com frameworks/ferramentas de IAM (Identity and Access Management)? Utilizam soluções personalizadas ou plataformas como Keycloak, Auth0, AWS IAM ou Azure AD B2C? Como gerenciam papéis (roles), permissões (policies) e políticas de acesso (RBAC/ABAC)?

118. Integração SAML:
     Como a consultoria aborda a integração de SAML 2.0? Vocês têm experiência com fluxos SP-initiated (Service Provider) e IdP-initiated (Identity Provider)? Como gerenciam o intercâmbio de metadados (SAML metadata files) e a rotação de certificados?

119. Implementação OAuth 2.0:
     Qual é a experiência com OAuth 2.0? Quais tipos de grant types já implementaram (ex.: authorization code, client credentials, password, PKCE)? Como lidam com refresh tokens, token revocation e limites de taxa (rate limiting)?

120. Segurança em SSO/OAuth 2.0:
     Como garantem a segurança na implementação? Quais medidas adotam para evitar:
     – Token interception (ex.: uso de HTTPS, state parameter)?
     – Replay attacks (ex.: nonce, timestamps)?
     – CSRF (ex.: CSRF tokens em redirecionamentos)?
     Como configuram CORS e cookies seguros?

121. Integração com Spring Boot:
     Como a consultoria integra SSO/OAuth 2.0 com Spring Boot? Utilizam bibliotecas como Spring Security OAuth2, Spring Security SAML ou Micronaut Security? Como configuram:
     – Comunicação entre backend (Java) e frontend (Angular)?
     – Mapeamento de claims (ex.: sub, email, roles) para autorização?
     – Tratamento de error responses (ex.: 401 Unauthorized, 403 Forbidden)?

122. Integração com Angular:
     No frontend (Angular), qual é a estratégia para:
     – Armazenamento e proteção de tokens (ex.: HttpOnly cookies, sessionStorage, secure localStorage)?
     – Tratamento de redirecionamentos (ex.: redirect_uri, post_login_uri)?
     – Recuperação de tokens expirados (ex.: refresh token flow)?
     – Uso de bibliotecas (ex.: angular-oauth2-oidc, ngx-auth0)?

123. Provisionamento de Usuários:
     Como a consultoria lida com provisionamento/desprovisionamento de usuários (ex.: SCIM, LDAP, APIs de IdP)? Podem compartilhar um exemplo de integração com um sistema de diretório (ex.: Active Directory, OpenLDAP)?

124. Personalização de Fluxos:
     Qual é a abordagem para personalização de fluxos de autenticação (ex.: branding, campos adicionais, multi-factor authentication)? Como lidam com requisitos específicos do cliente (ex.: custom login pages)?

125. Conformidade Regulatória:
     Como garantem a conformidade com regulamentações (ex.: GDPR, LGPD) em implementações de IAM/SSO? Como gerenciam:
     – Dados sensíveis (ex.: CPF, e-mail)?
     – Right to be forgotten (ex.: exclusão de tokens/registros)?
     – Auditoria de acesso (ex.: audit logs)?

126. Testes de Autenticação:
     Como a consultoria testa implementações de SSO/OAuth 2.0? Utilizam ferramentas específicas (ex.: Postman, curl, tests automatizados com Selenium/Cypress)? Como validam cenários como:
     – Expiração de token?
     – Acesso não autorizado?
     – Fluxos com múltiplos IdPs?

127. Gestão de Múltiplos IdPs:
     Como lidam com a integração de vários provedores de identidade (ex.: Azure AD para clientes corporativos, Google/Facebook para usuários externos)? Qual é a arquitetura proposta para escalabilidade (ex.: dynamic client registration)?

128. Recuperação de Conta:
     Como a consultoria aborda a recuperação de conta (ex.: reset de senha) em sistemas com SSO? Como é integrado ao fluxo do IdP (ex.: password reset endpoint)?

129. OpenID Connect (OIDC):
     Qual é a experiência com OpenID Connect (camada sobre OAuth 2.0)? Como utilizam claims para autorização (ex.: scopes, permissions)? Como validam a integridade dos ID tokens?

130. Monitoramento e Diagnóstico:
     Como a consultoria monitora e diagnostica problemas em implementações de SSO/OAuth 2.0? Quais métricas ou logs são coletados (ex.: token issuance rate, failure rates)? Como integram com ferramentas de observabilidade (ex.: Prometheus, ELK Stack)?

Total de questões geradas até o momento: 130

👉 Pergunta para você:
Há mais tópicos a serem avaliados (ex.: Metodologia, Suporte, Orçamento, Gestão de Projetos)?
(Responda com “não há mais tópicos” quando terminar).

(Continuação do questionário RFP)

131. Estratégias de Resiliência:
     Como a consultoria implementa estratégias de resiliência (ex.: circuit breakers, retries, timeouts)? Podem compartilhar exemplos de uso de bibliotecas como Resilience4j, Hystrix ou Spring Cloud Circuit Breaker? Como definem fallbacks e bulkheads para evitar cascading failures?

132. Engenharia do Caos:
     Vocês têm experiência com chaos engineering (ex.: Chaos Monkey, Gremlin)? Como são planejados e executados chaos experiments para testar a resiliência do sistema? Podem compartilhar um exemplo de experiment realizado e os aprendizados obtidos?

133. Tolerância a Falhas em Microsserviços:
     Como garantem a tolerância a falhas em arquiteturas de microsserviços? Como lidam com falhas em chamadas inter-serviços (ex.: idempotency, distributed tracing)? Como são gerenciados timeouts e retries com exponential backoff?

134. Gestão de Serviços com Estado:
     Como são projetados e escalados serviços com estado (ex.: stateful services)? Utilizam técnicas como session affinity (sticky sessions), state replication ou distributed state stores (ex.: Redis Cluster)? Como lidam com failover em serviços com estado?

135. Abordagem de Escalabilidade:
     Qual é a estratégia preferida para escalabilidade (horizontal vs. vertical)? Como decidem quando adotar cada uma? Podem explicar como equilibraram essa escolha em um projeto anterior (ex.: custos, complexidade, requisitos)?

136. Configuração de Auto-Scaling:
     Como configuram o auto-scaling em ambientes de nuvem (ex.: AWS Auto Scaling Groups, Kubernetes HPA)? Quais métricas são utilizadas para acionar o scaling (ex.: CPU, memória, filas de mensagens, latency)? Como evitam thrashing (escalonamento excessivo)?

137. Gerenciamento de Picos de Tráfego:
     Como lidam com picos de tráfego inesperados (ex.: load balancing, cache, rate limiting)? Podem compartilhar um exemplo de projeto onde isso foi crítico (ex.: Black Friday, eventos sazonais)? Como configuram queues para backpressure?

138. Escalabilidade de Bancos de Dados:
     Quais estratégias são adotadas para escalar bancos de dados (ex.: sharding, replication, read replicas)? Como lidam com transações distribuídas durante a escalabilidade? Como garantem data consistency em sistemas sharded?

139. Experiência com Arquitetura Event-Driven:
     Quantos projetos com arquitetura event-driven a consultoria já implementou? Podem descrever um exemplo (ex.: uso de events para integração entre serviços, real-time analytics)? Como decidiram adotar essa abordagem em vez de request-response?

140. Message Brokers Utilizados:
     Quais message brokers são especializados (ex.: Apache Kafka, RabbitMQ, Amazon SQS, Google Pub/Sub)? Como configuram topics, queues, durability (ex.: persistence), message retention e ordering guarantees? Como lidam com message duplication?

141. Event Sourcing e CQRS:
     Possuem experiência com Event Sourcing ou CQRS (Command Query Responsibility Segregation)? Como são implementados (ex.: event store, projections) e como garantem a consistência dos dados? Como lidam com versioning de eventos?

142. Estratégias de Consistência de Eventos:
     Como lidam com eventual consistency em sistemas event-driven? Utilizam padrões como Sagas (compensating transactions), Idempotency Keys ou Outbox Pattern? Como garantem que events não sejam perdidos durante falhas?

143. Monitoramento de Resiliência e Escalabilidade:
     Quais métricas são monitoradas para garantir resiliência e escalabilidade (ex.: error rates, latency, throughput, queue depth)? Como são integradas às ferramentas de observabilidade (ex.: Prometheus, Grafana, Datadog)? Como configuram alerts críticos?

144. Recuperação de Desastres em Sistemas Event-Driven:
     Como são planejados cenários de disaster recovery para sistemas event-driven? Como garantem que events não sejam perdidos durante falhas (ex.: exactly-once processing, dead-letter queues)? Como são testados os cenários de DR?

145. Exemplos Práticos:
     Podem compartilhar exemplos anônimos ou com confidencialidade mantida de projetos anteriores que tenham envolvido resiliência, escalabilidade ou arquitetura event-driven? Inclua:
     – Tecnologias utilizadas.
     – Desafios específicos (ex.: high throughput, low latency).
     – Métricas de sucesso (ex.: redução de downtime, aumento de throughput).

Total de questões geradas até o momento: 145

👉 Pergunta para você:
Há mais tópicos a serem avaliados (ex.: Metodologia, Suporte, Orçamento, Gestão de Projetos)?
(Responda com “não há mais tópicos” quando terminar).

Resposta Final:

✅ Questionário RFP concluído com 145 questões distribuídas nos seguintes tópicos:

1. Linguagem, Experiência e Portfólio
2. Arquitetura Técnica e Melhores Práticas
3. Desenvolvimento Back-end (Java)
4. Desenvolvimento Front-end (Angular)
5. Qualidade, Performance e Testes Automatizados
6. Documentação e Entregas
7. Infraestrutura e DevOps
8. Banco de Dados (PostgreSQL) e Governança de Dados
9. Segurança e Compliance
10. Melhores Práticas de Desenvolvimento de Software
11. SSO, IAM, SAML e OAuth 2.0
12. Resiliência, Escalabilidade e Event Driven

1. Formatação Final:

   • Posso organizar o questionário em um documento profissional (PDF/Word) com:
     • Capa e índice.
     • Seções numeradas e formatação padronizada.
     • Espaço para respostas da consultoria (ex.: campos para Sim/Não, descrições, links).

2. Personalização:

   • Gostaria de ajustar alguma questão (ex.: remover, adicionar detalhes específicos do seu projeto)?
   • Precisa incluir critérios de avaliação (ex.: peso para cada tópico, escala de pontuação)?

3. Inclusão de Tópicos Adicionais:

   • Embora tenha confirmado “não há mais tópicos”, posso revisar rapidamente se algo crítico foi omitido (ex.: Metodologia Ágil, Gestão de Projetos, Orçamento, Suporte Pós-Implantação).

4. Exportação:

   • Posso gerar o questionário em formato:
     • Markdown (para edição fácil).
     • Google Forms (para envio automatizado).
     • PDF (para compartilhamento final).

## [Tópico 12: Resiliência, Escalabilidade e Event Driven]  

### 131. Estratégias de Resiliência  
**Pergunta**: Como a consultoria implementa estratégias de resiliência (ex.: *circuit breakers*, *retries*, *timeouts*)? Podem compartilhar exemplos de uso de bibliotecas como **Resilience4j**, **Hystrix** ou **Spring Cloud Circuit Breaker**? Como definem *fallbacks* e *bulkheads* para evitar *cascading failures*?  

**Resposta da Consultoria**:  
[ ] Sim / [ ] Não  
*Descrição*: [________________________________________________________________]  
*Exemplo*: [________________________________________________________________]

Por favor, informe:

• Formato desejado (PDF, Word, Google Forms, etc.).
• Qualquer ajuste específico (ex.: incluir/excluir questões, adicionar critérios).
• Prazo para entrega do questionário finalizado.

Estou à disposição para finalizar o documento conforme suas necessidades! 😊

Exemplo de solicitação:

“Por favor, formate o questionário em PDF com capa, índice e espaço para respostas. Adicione um critério de avaliação de 1 a 5 para cada questão.”

Aguardando sua orientação! 📥

Resposta B

Entendi perfeitamente! Vou criar um questionário completo de RFP (Request for Proposal) para avaliação de consultorias de desenvolvimento de software.

Para cada tópico que você informar, gerarei no mínimo 15 questões relevantes e frequentemente utilizadas em processos de seleção de fornecedores.

Estou pronto para começar!

Por favor, informe o primeiro tópico que deseja avaliar na consultoria de software.

(Exemplos de tópicos comuns: Experiência Técnica, Metodologia de Desenvolvimento, Qualidade de Código, Segurança, Suporte e Manutenção, Gestão de Projetos, Equipe, Precificação, etc.)

Qual é o primeiro tópico?

1. Há quantos anos a empresa atua no desenvolvimento de software com as tecnologias Java e Angular?

2. Quantos projetos utilizando Java, Spring Boot e Angular foram entregues pela empresa nos últimos 3 anos?

3. Qual o porte médio dos projetos desenvolvidos (pequeno, médio, grande porte)? Descreva em termos de duração, tamanho da equipe e complexidade.

4. A empresa possui experiência comprovada com a abordagem API First no desenvolvimento de aplicações? Descreva como essa metodologia é aplicada.

5. Quais certificações técnicas em Java, Spring e Angular a equipe possui? (Ex: Oracle Certified Professional, Spring Professional, etc.)

6. Quais versões do Java a empresa tem experiência? A equipe está atualizada com as versões LTS mais recentes (Java 17, 21)?

7. Descreva a experiência da equipe com o ecossistema Spring (Spring Boot, Spring Security, Spring Data, Spring Cloud, etc.).

8. Qual a experiência da equipe com Angular? Quais versões foram utilizadas em projetos anteriores?

9. A empresa possui experiência com ferramentas de design e documentação de APIs como OpenAPI/Swagger, Postman ou similares?

10. Quais ferramentas e frameworks complementares a equipe domina para o stack proposto? (Ex: Hibernate, Liquibase, RxJS, NgRx, etc.)

11. Apresente 3 a 5 projetos de referência (cases) que utilizaram o stack Java + Spring Boot + Angular. Inclua: escopo, desafios, soluções e resultados alcançados.

12. É possível fornecer contatos de clientes anteriores para validação de referências?

13. A empresa já desenvolveu soluções para o segmento/indústria em que nossa organização atua? Se sim, descreva.

14. Apresente exemplos de APIs desenvolvidas seguindo a abordagem API First. Como foi o processo de design e documentação?

15. A empresa já trabalhou com integrações complexas entre sistemas legados e novas aplicações? Descreva um caso.

16. Como a empresa mantém sua equipe atualizada em relação às evoluções do Java, Spring Boot e Angular?

17. A empresa contribui ou participa de comunidades open source relacionadas às tecnologias mencionadas?

18. Quais práticas de melhoria contínua e inovação tecnológica são adotadas pela empresa?

Total de questões neste tópico: 18

Há mais tópicos a serem avaliados?

Se sim, por favor informe o próximo tópico.

1. Quais padrões arquiteturais a empresa utiliza no desenvolvimento de aplicações Java/Angular? (Ex: Clean Architecture, Hexagonal, Layered, MVC, etc.)

2. A empresa possui experiência com arquitetura de microsserviços? Descreva como é feita a decomposição, comunicação e orquestração entre os serviços.

3. Como é definida a arquitetura de uma nova aplicação? Existe um processo formal de design e documentação arquitetural?

4. Quais ferramentas são utilizadas para documentação de arquitetura? (Ex: C4 Model, ArchiMate, draw.io, etc.)

5. Como a empresa aborda a separação de responsabilidades entre frontend (Angular) e backend (Spring Boot)?

6. A empresa tem experiência com arquitetura orientada a eventos (Event-Driven Architecture)? Quais tecnologias são utilizadas? (Ex: Kafka, RabbitMQ, etc.)

7. Descreva detalhadamente o processo de desenvolvimento utilizando a abordagem API First. Quais ferramentas são utilizadas para design, mock e validação?

8. Como é garantida a consistência entre a especificação OpenAPI e a implementação do código?

9. Quais padrões e boas práticas de design de APIs RESTful são seguidos? (Ex: versionamento, nomenclatura, códigos de status HTTP, HATEOAS, etc.)

10. Como é tratada a evolução e versionamento das APIs sem quebra de compatibilidade (backward compatibility)?

11. A empresa utiliza ferramentas de geração automática de código a partir de especificações OpenAPI? Quais?

12. Quais princípios e práticas de Clean Code são adotados pela equipe de desenvolvimento?

13. A empresa segue os princípios SOLID no desenvolvimento? Como isso é garantido e validado no código?

14. Existem guias de estilo de código (coding standards) definidos para Java e Angular/TypeScript? Como são aplicados?

15. Quais Design Patterns são mais utilizados pela equipe no desenvolvimento com Spring Boot e Angular?

16. Como é feita a revisão de código (code review)? Existem critérios e checklists definidos?

17. Quais tipos de testes são implementados nos projetos? (Ex: unitários, integração, E2E, contrato, performance, etc.)

18. Quais frameworks de testes são utilizados para Java/Spring Boot? (Ex: JUnit 5, Mockito, TestContainers, etc.)

19. Quais frameworks de testes são utilizados para Angular? (Ex: Jasmine, Karma, Jest, Cypress, etc.)

20. Qual a meta de cobertura de código (code coverage) adotada pela empresa? Como é monitorada?

21. A empresa pratica TDD (Test-Driven Development) ou BDD (Behavior-Driven Development)? Descreva o processo.

22. Como são realizados os testes de contrato de APIs? (Ex: Pact, Spring Cloud Contract, etc.)

23. Quais padrões são utilizados para tratamento centralizado de exceções e erros nas aplicações Spring Boot?

24. Como é estruturado o sistema de logs das aplicações? Quais ferramentas e formatos são utilizados? (Ex: SLF4J, Logback, JSON structured logging, etc.)

25. A empresa utiliza ferramentas de centralização e análise de logs? (Ex: ELK Stack, Splunk, Datadog, etc.)

26. Quais práticas são adotadas para garantir a performance das aplicações Java/Angular?

27. Como é feito o profiling e identificação de gargalos de performance?

28. A empresa tem experiência com estratégias de caching? Quais tecnologias são utilizadas? (Ex: Redis, Ehcache, etc.)

29. Como a arquitetura proposta garante escalabilidade horizontal e vertical da aplicação?

30. Quais práticas são adotadas para design e modelagem de banco de dados?

31. Como é feito o gerenciamento de migrations e versionamento do schema do banco? (Ex: Flyway, Liquibase, etc.)

32. A empresa tem experiência com bancos de dados relacionais e NoSQL? Quais tecnologias?

33. Como é garantida a otimização de queries e uso eficiente do banco de dados?

Total de questões neste tópico: 33

Há mais tópicos a serem avaliados?

Se sim, por favor informe o próximo tópico.

1. Quais versões do Java a equipe utiliza ativamente em projetos? A empresa adota as versões LTS (Long Term Support) como padrão?

2. Como a equipe se mantém atualizada sobre as novas features do Java? (Ex: Records, Pattern Matching, Virtual Threads, etc.)

3. A empresa possui experiência com programação reativa em Java? Quais frameworks são utilizados? (Ex: Project Reactor, RxJava, WebFlux, etc.)

4. Como é gerenciado o ciclo de vida das dependências e bibliotecas Java nos projetos? (Ex: Maven, Gradle)

5. A equipe tem experiência com GraalVM e compilação nativa para aplicações Java? Em quais cenários foi aplicado?

6. Descreva a experiência da equipe com os principais módulos do Spring: Spring Boot, Spring MVC, Spring Data, Spring Security e Spring Cloud.

7. Quais versões do Spring Boot a empresa tem utilizado? A equipe está preparada para trabalhar com Spring Boot 3.x?

8. Como é feita a configuração e gerenciamento de propriedades em diferentes ambientes (dev, homologação, produção)?

9. A empresa utiliza Spring Profiles para gerenciamento de configurações por ambiente? Descreva a abordagem.

10. Como é implementada a injeção de dependências nos projetos? Quais práticas são seguidas para garantir baixo acoplamento?

11. Quais práticas são adotadas para construção de APIs RESTful robustas e escaláveis com Spring Boot?

12. Como é implementada a validação de dados de entrada nas APIs? (Ex: Bean Validation, validações customizadas, etc.)

13. Descreva como é feita a serialização/deserialização de objetos JSON. Quais bibliotecas são utilizadas? (Ex: Jackson, Gson)

14. Como são tratados os diferentes formatos de data/hora nas APIs? A equipe utiliza os padrões ISO 8601?

15. A empresa implementa paginação, ordenação e filtros dinâmicos nas APIs? Descreva a abordagem técnica.

16. Como é implementado o upload e download de arquivos nas APIs? Quais limites e validações são aplicados?

17. Qual a experiência da equipe com JPA/Hibernate? Quais práticas são adotadas para evitar problemas comuns como N+1 queries?

18. A empresa utiliza Spring Data JPA? Como são implementados repositórios customizados e queries complexas?

19. Como é gerenciado o controle transacional nas aplicações? Quais estratégias de propagação são utilizadas?

20. A equipe tem experiência com múltiplas fontes de dados (multi-datasource) em uma mesma aplicação?

21. Como é feita a auditoria de entidades? (Ex: campos de criação, atualização, usuário responsável)

22. A empresa tem experiência com bancos NoSQL integrados a aplicações Spring Boot? (Ex: MongoDB, Redis, Elasticsearch)

23. Como é implementada a autenticação e autorização nas aplicações Spring Boot? (Ex: JWT, OAuth2, OpenID Connect)

24. A empresa tem experiência com integração a provedores de identidade (Identity Providers)? Quais? (Ex: Keycloak, Auth0, Azure AD, etc.)

25. Quais práticas são adotadas para proteção contra vulnerabilidades comuns? (Ex: SQL Injection, XSS, CSRF, etc.)

26. Como é feito o gerenciamento seguro de credenciais e secrets nas aplicações? (Ex: Vault, AWS Secrets Manager, etc.)

27. A empresa implementa rate limiting e throttling nas APIs? Quais ferramentas são utilizadas?

28. Como são tratados os logs de segurança e auditoria de acessos?

29. A empresa tem experiência com sistemas de mensageria? Quais tecnologias? (Ex: Apache Kafka, RabbitMQ, Amazon SQS, etc.)

30. Como é garantida a confiabilidade na entrega e processamento de mensagens? (Ex: retry, dead letter queue, idempotência)

31. A equipe tem experiência com padrões como Saga, Event Sourcing ou CQRS?

32. Como é feito o monitoramento e troubleshooting de filas e tópicos de mensagens?

33. Como a empresa implementa integrações com sistemas externos via REST, SOAP ou outros protocolos?

34. A equipe utiliza clientes HTTP como RestTemplate, WebClient ou Feign? Qual a preferência e por quê?

35. Como são tratados timeouts, retries e circuit breakers em chamadas a serviços externos? (Ex: Resilience4j, Hystrix)

36. A empresa tem experiência com gRPC para comunicação entre microsserviços?

37. Como é implementado service discovery em arquiteturas distribuídas? (Ex: Eureka, Consul, Kubernetes DNS)

38. Como são implementados jobs agendados e tarefas em background nas aplicações Spring Boot? (Ex: @Scheduled, Quartz)

39. A empresa tem experiência com Spring Batch para processamento em lote? Descreva casos de uso.

40. Como é garantida a execução única de jobs em ambientes clusterizados?

41. Como é feito o monitoramento e alertas de falhas em jobs agendados?

42. Quais métricas de aplicação são expostas e monitoradas? (Ex: Spring Actuator, Micrometer)

43. A empresa implementa distributed tracing em aplicações distribuídas? Quais ferramentas são utilizadas? (Ex: Jaeger, Zipkin, OpenTelemetry)

44. Como são implementados health checks e readiness/liveness probes para orquestração em containers?

45. Quais dashboards e ferramentas de visualização são utilizados para monitoramento? (Ex: Grafana, Prometheus, Datadog)

Total de questões neste tópico: 45

Há mais tópicos a serem avaliados?

Se sim, por favor informe o próximo tópico.

1. Quais versões do Angular a equipe possui experiência? A empresa está atualizada com as versões mais recentes (Angular 16, 17, 18)?

2. Como a equipe acompanha e se adapta às atualizações e breaking changes do Angular?

3. A equipe tem experiência com o processo de migração entre versões do Angular? Descreva como é conduzido.

4. Qual o nível de domínio da equipe em TypeScript? A empresa adota configurações estritas (strict mode)?

5. A equipe possui experiência com as novas funcionalidades do Angular, como Standalone Components, Signals e novas APIs de controle de fluxo?

6. Qual a estrutura de organização de projetos Angular adotada pela empresa? (Ex: feature modules, core/shared modules, etc.)

7. A empresa tem experiência com arquitetura de monorepo utilizando Nx ou Angular Workspaces?

8. Como é feita a separação de responsabilidades entre componentes, serviços e módulos?

9. A empresa utiliza bibliotecas de componentes compartilhados (component libraries) entre projetos? Como são gerenciadas?

10. Quais padrões arquiteturais são adotados no front-end? (Ex: Smart/Dumb Components, Container/Presentational, etc.)

11. Como é tratada a modularização e lazy loading de funcionalidades para otimização de performance?

12. Quais soluções de gerenciamento de estado a equipe utiliza? (Ex: NgRx, NGXS, Akita, RxJS + Services, Signals)

13. Como é decidida a necessidade de uma biblioteca de gerenciamento de estado versus soluções mais simples?

14. A equipe tem experiência com padrões Redux (actions, reducers, effects, selectors)? Descreva a abordagem.

15. Como é feito o debug e monitoramento do estado da aplicação em desenvolvimento?

16. Como são tratados os side effects e operações assíncronas no gerenciamento de estado?

17. Qual o nível de experiência da equipe com RxJS e programação reativa?

18. Quais operadores RxJS são mais utilizados pela equipe? Descreva cenários de aplicação.

19. Como a equipe evita problemas comuns com Observables, como memory leaks e subscrições não finalizadas?

20. A equipe utiliza padrões como async pipe de forma consistente? Quais práticas são adotadas?

21. Como são tratados cenários complexos de combinação de streams (Ex: combineLatest, forkJoin, switchMap, etc.)?

22. Quais bibliotecas de componentes UI a equipe tem experiência? (Ex: Angular Material, PrimeNG, NgBootstrap, Taiga UI, etc.)

23. A empresa desenvolve design systems e bibliotecas de componentes customizados? Descreva a abordagem.

24. Como é garantida a consistência visual e de experiência do usuário entre diferentes módulos da aplicação?

25. A equipe tem experiência com Angular CDK (Component Dev Kit) para criação de componentes acessíveis?

26. Como são implementados componentes reutilizáveis e configuráveis (Ex: uso de @Input, @Output, ng-content, templates)?

27. A empresa adota a metodologia de Atomic Design ou similar para construção de interfaces?

28. Quais abordagens de estilização são utilizadas? (Ex: SCSS, CSS Modules, BEM, Tailwind CSS, etc.)

29. Como é feito o gerenciamento de temas (theming) e suporte a dark mode nas aplicações?

30. A empresa utiliza estratégias de encapsulamento de estilos do Angular (ViewEncapsulation)? Qual a abordagem padrão?

31. Como é garantida a responsividade e adaptação a diferentes tamanhos de tela e dispositivos?

32. Quais ferramentas são utilizadas para garantir consistência de estilos? (Ex: Stylelint, Prettier)

33. A equipe tem experiência com Reactive Forms e Template-driven Forms? Qual a abordagem preferencial e por quê?

34. Como são implementadas validações complexas e customizadas em formulários?

35. Como é tratada a exibição de mensagens de erro de forma consistente e amigável ao usuário?

36. A equipe tem experiência com formulários dinâmicos (dynamic forms) gerados a partir de metadados?

37. Como são implementados formulários multi-step (wizards) com validação parcial?

38. Como é estruturada a camada de serviços para comunicação com APIs REST?

39. Quais práticas são adotadas para tratamento centralizado de erros HTTP?

40. Como são implementados interceptors para tratamento de autenticação, headers e logging?

41. A equipe utiliza cache de requisições HTTP? Quais estratégias são aplicadas?

42. Como é feito o tratamento de loading states e feedback visual durante requisições?

43. A empresa tem experiência com GraphQL em aplicações Angular? (Ex: Apollo Client)

44. Como é estruturado o roteamento em aplicações Angular de médio e grande porte?

45. A equipe implementa guards de rotas para controle de acesso e autorização? Descreva a abordagem.

46. Como são tratados resolvers para pré-carregamento de dados em rotas?

47. Quais estratégias de preloading são utilizadas para otimização de carregamento? (Ex: PreloadAllModules, custom strategies)

48. Como é implementada a navegação com preservação de estado e parâmetros de query?

49. Quais frameworks de testes unitários são utilizados para Angular? (Ex: Jasmine, Jest, Karma)

50. Como são escritos testes unitários para componentes, serviços e pipes?

51. A equipe utiliza testes de integração e E2E? Quais ferramentas? (Ex: Cypress, Playwright, Protractor)

52. Qual a meta de cobertura de testes para o código front-end?

53. Como são mockados serviços e dependências externas nos testes?

54. A equipe pratica testes de acessibilidade automatizados? Quais ferramentas são utilizadas?

55. Quais práticas são adotadas para otimização de performance em aplicações Angular?

56. A equipe utiliza estratégias de Change Detection otimizadas? (Ex: OnPush, detach)

57. Como é feita a análise e redução do bundle size da aplicação?

58. A empresa implementa virtual scrolling para listas longas e grandes volumes de dados?

59. Quais ferramentas são utilizadas para análise de performance? (Ex: Lighthouse, Chrome DevTools, webpack-bundle-analyzer)

60. A equipe tem experiência com Service Workers e PWA (Progressive Web Apps)?

61. Quais práticas e padrões de acessibilidade são seguidos? (Ex: WCAG 2.1, WAI-ARIA)

62. Como é garantida a navegação por teclado e suporte a leitores de tela?

63. A empresa realiza auditorias de acessibilidade? Quais ferramentas são utilizadas? (Ex: axe, WAVE, Lighthouse)

64. Como a acessibilidade é incorporada no processo de desenvolvimento desde o início (shift-left)?

65. A equipe tem experiência com internacionalização de aplicações Angular?

66. Quais bibliotecas são utilizadas para i18n? (Ex: @angular/localize, ngx-translate, Transloco)

67. Como é feito o gerenciamento de arquivos de tradução e fluxo de atualização?

68. A empresa tem experiência com suporte a RTL (Right-to-Left) e múltiplos formatos de data/número?

Total de questões neste tópico: 68

Há mais tópicos a serem avaliados?

Se sim, por favor informe o próximo tópico.

1. Qual a estratégia geral de qualidade adotada pela empresa no ciclo de desenvolvimento de software?

2. A empresa possui uma área ou equipe dedicada a Quality Assurance (QA)? Como ela está estruturada?

3. Como a qualidade é incorporada desde as fases iniciais do desenvolvimento (shift-left testing)?

4. Quais métricas de qualidade são acompanhadas e reportadas durante o projeto? (Ex: densidade de defeitos, cobertura de testes, MTTR, etc.)

5. A empresa adota práticas de Quality Engineering ou Quality Coaching junto aos times de desenvolvimento?

6. Como é feita a gestão de defeitos e bugs? Quais ferramentas são utilizadas? (Ex: Jira, Azure DevOps, Bugzilla)

7. A empresa segue o conceito de Pirâmide de Testes? Como é distribuído o esforço entre testes unitários, integração e E2E?

8. Qual o percentual aproximado de testes automatizados versus manuais nos projetos?

9. Como é definido o escopo e priorização dos testes a serem automatizados?

10. A empresa pratica o conceito de Continuous Testing integrado ao pipeline de CI/CD?

11. Como é tratado o equilíbrio entre velocidade de desenvolvimento e cobertura de testes?

12. Quais frameworks são utilizados para testes unitários no back-end Java? (Ex: JUnit 5, Mockito, AssertJ)

13. Quais frameworks são utilizados para testes unitários no front-end Angular? (Ex: Jasmine, Jest, Karma)

14. Qual a meta de cobertura de código (code coverage) estabelecida para os projetos?

15. Como é garantido que a cobertura de código reflita testes de qualidade e não apenas métricas superficiais?

16. A equipe pratica Test-Driven Development (TDD)? Em quais cenários é aplicado?

17. Como são tratados os mocks, stubs e fakes para isolamento de dependências nos testes unitários?

18. Quais práticas são adotadas para garantir que os testes sejam rápidos, confiáveis e independentes?

19. Como são implementados testes de integração para APIs Spring Boot?

20. A empresa utiliza Testcontainers ou ferramentas similares para testes com bancos de dados e serviços externos?

21. Como são testadas as integrações com sistemas de mensageria (Kafka, RabbitMQ, etc.)?

22. A equipe implementa testes de integração entre módulos do front-end e serviços mockados?

23. Como é garantido o isolamento e a repetibilidade dos testes de integração?

24. Quais estratégias são utilizadas para gerenciamento de dados de teste em testes de integração?

25. A empresa pratica testes de contrato para validar a comunicação entre serviços? Quais ferramentas são utilizadas? (Ex: Pact, Spring Cloud Contract)

26. Como é garantida a compatibilidade de contratos entre produtores e consumidores de APIs?

27. Como os testes de contrato são integrados ao pipeline de CI/CD?

28. A empresa utiliza consumer-driven contracts? Descreva o processo.

29. Quais ferramentas são utilizadas para testes E2E? (Ex: Cypress, Playwright, Selenium, Protractor)

30. Como é definido o escopo dos testes E2E para evitar fragilidade e lentidão?

31. A empresa implementa testes E2E em múltiplos navegadores e dispositivos?

32. Como são gerenciados os dados de teste e ambientes para execução de testes E2E?

33. Quais estratégias são utilizadas para tornar os testes E2E mais estáveis e menos propensos a falsos positivos/negativos?

34. Como são tratados testes de fluxos críticos de negócio (happy paths e edge cases)?

35. Quais ferramentas são utilizadas para testes automatizados de APIs? (Ex: Postman/Newman, REST Assured, Karate, Insomnia)

36. Como são validados os schemas de resposta das APIs? (Ex: JSON Schema validation)

37. A empresa automatiza testes de cenários negativos e tratamento de erros nas APIs?

38. Como são testados cenários de autenticação e autorização nas APIs?

39. Os testes de API são executados como parte do pipeline de CI/CD?

40. A empresa pratica BDD (Behavior-Driven Development)? Descreva o processo.

41. Quais ferramentas são utilizadas para BDD? (Ex: Cucumber, SpecFlow, Behave)

42. Como é feita a colaboração entre QA, desenvolvedores e stakeholders na escrita de cenários BDD?

43. Os cenários Gherkin são mantidos como documentação viva do sistema?

44. A empresa realiza testes de performance e carga como parte do processo de desenvolvimento? Em quais fases?

45. Quais ferramentas são utilizadas para testes de performance? (Ex: JMeter, Gatling, k6, Locust, Artillery)

46. Como são definidos os requisitos e metas de performance (SLAs, tempo de resposta, throughput)?

47. A empresa realiza testes de stress e testes de pico para avaliar os limites da aplicação?

48. Como são identificados e diagnosticados gargalos de performance?

49. Os testes de performance são automatizados e integrados ao pipeline de CI/CD?

50. A empresa tem experiência com testes de performance em ambientes cloud e arquiteturas distribuídas?

51. Como são simulados cenários de carga realistas com base em padrões de uso esperados?

52. Quais ferramentas são utilizadas para profiling de aplicações Java? (Ex: VisualVM, YourKit, JProfiler, async-profiler)

53. Como é feita a análise de consumo de memória e detecção de memory leaks?

54. Quais ferramentas são utilizadas para análise de performance no front-end? (Ex: Lighthouse, Chrome DevTools, WebPageTest)

55. Como são tratados os Core Web Vitals (LCP, FID, CLS) para otimização de experiência do usuário?

56. A empresa realiza otimização de queries e análise de planos de execução de banco de dados?

57. A empresa integra testes de segurança automatizados no processo de desenvolvimento?

58. Quais ferramentas de SAST (Static Application Security Testing) são utilizadas? (Ex: SonarQube, Checkmarx, Fortify, Snyk)

59. Quais ferramentas de DAST (Dynamic Application Security Testing) são utilizadas? (Ex: OWASP ZAP, Burp Suite)

60. Como são tratadas as vulnerabilidades identificadas? Existe um processo de triagem e correção?

61. A empresa realiza análise de vulnerabilidades em dependências (SCA – Software Composition Analysis)? (Ex: OWASP Dependency-Check, Snyk, Dependabot)

62. A equipe tem experiência com Penetration Testing? É realizado internamente ou por terceiros?

63. A empresa realiza testes de acessibilidade automatizados? Quais ferramentas são utilizadas? (Ex: axe, Pa11y, Lighthouse)

64. Como os testes de acessibilidade são integrados ao pipeline de desenvolvimento?

65. Qual o nível de conformidade com WCAG a empresa busca atingir? (Ex: WCAG 2.1 AA)

66. São realizados testes manuais de acessibilidade com tecnologias assistivas? (Ex: leitores de tela)

67. A empresa realiza testes de compatibilidade entre navegadores? Quais navegadores e versões são considerados?

68. São realizados testes em diferentes dispositivos e resoluções de tela?

69. Quais ferramentas são utilizadas para testes cross-browser? (Ex: BrowserStack, Sauce Labs, LambdaTest)

70. Como é definida a matriz de compatibilidade para cada projeto?

71. Quais ferramentas de análise estática de código são utilizadas? (Ex: SonarQube, ESLint, Checkstyle, PMD, SpotBugs)

72. A empresa define quality gates no pipeline de CI/CD? Quais critérios são avaliados?

73. Como são tratados os code smells, débitos técnicos e violações de padrões?

74. Qual a frequência de revisão e atualização das regras de análise estática?

75. A empresa utiliza ferramentas de formatação automática de código? (Ex: Prettier, Google Java Format, Spotless)

76. Como são gerenciados os ambientes de teste (desenvolvimento, QA, staging, homologação)?

77. A empresa utiliza infraestrutura como código para provisionamento de ambientes de teste?

78. Como é garantida a paridade entre ambientes de teste e produção?

79. A empresa tem experiência com ambientes efêmeros para testes (ephemeral environments)?

80. Como são gerenciados e mascarados os dados sensíveis nos ambientes de teste?

81. Quais relatórios de qualidade são gerados e disponibilizados durante o projeto?

82. Como é feito o acompanhamento da evolução da qualidade ao longo do tempo?

83. A empresa utiliza dashboards para visualização de métricas de qualidade? Quais ferramentas? (Ex: SonarQube, Grafana, Allure)

84. Como são reportados os resultados de testes de regressão após cada release?

85. A empresa calcula e monitora o custo da qualidade (cost of quality)?

Total de questões neste tópico: 85

Há mais tópicos a serem avaliados?

Se sim, por favor informe o próximo tópico.

1. Qual a abordagem geral da empresa em relação à documentação de software? Como é equilibrado o esforço entre documentação e desenvolvimento?

2. A empresa segue o princípio de “Documentation as Code”? Descreva como é implementado.

3. Quais tipos de documentação são produzidos ao longo do ciclo de desenvolvimento? (Ex: técnica, funcional, operacional, usuário final)

4. Como é garantido que a documentação se mantenha atualizada ao longo da evolução do projeto?

5. A documentação é versionada junto com o código-fonte? Qual ferramenta é utilizada?

6. A empresa adota práticas de documentação colaborativa? Como os diferentes stakeholders contribuem?

7. Quais artefatos de documentação de arquitetura são produzidos? (Ex: diagramas de contexto, containers, componentes, decisões arquiteturais)

8. A empresa utiliza o modelo C4 ou similar para documentação de arquitetura? Descreva a abordagem.

9. Como são documentadas as decisões arquiteturais (ADRs – Architecture Decision Records)?

10. Quais ferramentas são utilizadas para criação de diagramas de arquitetura? (Ex: draw.io, Lucidchart, PlantUML, Structurizr, Mermaid)

11. A empresa documenta os requisitos não-funcionais e como a arquitetura os endereça?

12. Como é documentada a arquitetura de integração entre sistemas e serviços externos?

13. Como a abordagem API First é refletida na documentação das APIs?

14. A empresa utiliza OpenAPI/Swagger como fonte primária de documentação de APIs? As especificações são mantidas atualizadas?

15. Quais ferramentas são utilizadas para geração e publicação de documentação de APIs? (Ex: Swagger UI, ReDoc, Stoplight)

16. A documentação de APIs inclui exemplos de requests e responses para cada endpoint?

17. Como são documentados os códigos de erro, mensagens e cenários de exceção das APIs?

18. A empresa disponibiliza ambientes de sandbox ou mocks para consumidores testarem as APIs documentadas?

19. Como é documentado o processo de autenticação e autorização para consumo das APIs?

20. A documentação de APIs inclui guias de quickstart para novos consumidores?

21. A empresa adota padrões de documentação inline no código? (Ex: Javadoc, TSDoc, JSDoc)

22. Qual o nível de cobertura de documentação esperado para classes, métodos e funções públicas?

23. São gerados sites de documentação automática a partir do código? (Ex: Javadoc site, Compodoc para Angular)

24. Como são documentadas as configurações e variáveis de ambiente necessárias para a aplicação?

25. A empresa documenta os padrões de código (coding standards) e guias de estilo adotados?

26. Como são documentados os workarounds e débitos técnicos no código?

27. Como são documentados os requisitos funcionais e regras de negócio?

28. A empresa produz documentação de casos de uso ou user stories detalhadas?

29. São criados fluxogramas ou diagramas de processos de negócio? Quais ferramentas são utilizadas? (Ex: BPMN, UML Activity Diagrams)

30. Como é feita a rastreabilidade entre requisitos, implementação e testes?

31. A empresa utiliza ferramentas de gestão de requisitos? Quais? (Ex: Jira, Azure DevOps, Confluence, Notion)

32. Como é documentado o modelo de dados (modelo conceitual, lógico e físico)?

33. Quais ferramentas são utilizadas para documentação de banco de dados? (Ex: dbdiagram.io, ERDPlus, DBeaver, DataGrip)

34. A documentação inclui dicionário de dados com descrição de tabelas e campos?

35. Como são documentadas as migrations e evoluções do schema do banco?

36. São documentados índices, constraints e regras de integridade referencial?

37. A empresa produz runbooks e playbooks para operação da aplicação?

38. Como são documentados os processos de deploy e rollback?

39. A documentação inclui procedimentos de troubleshooting e resolução de incidentes?

40. Como são documentadas as configurações de infraestrutura? (Ex: Infrastructure as Code com Terraform, Ansible)

41. A empresa documenta os SLIs, SLOs e SLAs da aplicação?

42. Como são documentados os alertas, thresholds e procedimentos de escalação?

43. A documentação inclui diagramas de infraestrutura e topologia de rede?

44. A empresa produz manuais de usuário final para as aplicações desenvolvidas?

45. São criados guias de onboarding para novos desenvolvedores no projeto?

46. A empresa produz tutoriais ou guias passo-a-passo para funcionalidades complexas?

47. Quais formatos são utilizados para documentação de usuário? (Ex: texto, vídeo, screenshots anotados)

48. A documentação de usuário é disponibilizada em múltiplos idiomas quando necessário?

49. Quais ferramentas são utilizadas para criação e gestão de documentação? (Ex: Confluence, Notion, GitBook, ReadTheDocs, Docusaurus)

50. A empresa utiliza wikis ou bases de conhecimento centralizadas?

51. Como é organizada e categorizada a documentação para facilitar a busca e navegação?

52. A documentação é publicada em portais de desenvolvedores ou intranets?

53. Como é controlado o acesso a documentos sensíveis ou confidenciais?

54. Quais são os artefatos de entrega padrão em cada fase do projeto? (Ex: inception, desenvolvimento, homologação, go-live)

55. Como é estruturado o pacote de entrega final do projeto?

56. A empresa fornece código-fonte completo e documentado ao final do projeto?

57. Como são entregues os scripts de banco de dados, migrations e dados iniciais?

58. A empresa entrega documentação de instalação e configuração do ambiente?

59. São entregues os pipelines de CI/CD configurados e documentados?

60. Como são entregues os artefatos de testes (casos de teste, scripts automatizados, relatórios)?

61. A empresa realiza sessões de transferência de conhecimento (Knowledge Transfer) ao final do projeto?

62. Como é estruturado o processo de handover para equipes internas do cliente?

63. São realizados treinamentos técnicos para a equipe do cliente? Qual a carga horária típica?

64. A empresa disponibiliza gravações de sessões de transferência de conhecimento?

65. Como é tratado o suporte pós-transferência para esclarecimento de dúvidas?

66. A empresa oferece período de acompanhamento (shadowing) durante a transição?

67. Como é feito o versionamento semântico (SemVer) das entregas?

68. A empresa mantém changelogs detalhados das versões entregues?

69. Como são documentadas as breaking changes entre versões?

70. A empresa utiliza release notes para comunicar mudanças aos stakeholders?

71. Como é feita a gestão de branches e a documentação de releases?

72. A empresa realiza revisões de qualidade da documentação antes das entregas?

73. Existem templates e padrões definidos para os diferentes tipos de documentação?

74. Como é medida a completude e qualidade da documentação entregue?

75. A documentação é validada pelos stakeholders antes da entrega final?

76. A empresa utiliza ferramentas de verificação gramatical e de estilo? (Ex: Grammarly, Vale, LanguageTool)

77. Como são definidos e documentados os critérios de aceitação para cada entrega?

78. A empresa possui uma Definition of Done (DoD) clara que inclui requisitos de documentação?

79. Como é feita a validação formal de entregas junto ao cliente?

80. A empresa utiliza checklists de entrega para garantir completude dos artefatos?

81. Como são tratadas e documentadas as pendências ou ressalvas nas entregas?

82. Como é feita a gestão de configuração dos artefatos do projeto?

83. A empresa mantém baseline de configuração para cada release entregue?

84. Como são rastreadas as mudanças nos artefatos de entrega?

85. A empresa utiliza ferramentas específicas para gestão de configuração? Quais?

Total de questões neste tópico: 85

Há mais tópicos a serem avaliados?

Se sim, por favor informe o próximo tópico.

1. Qual o nível de maturidade da empresa em práticas DevOps? Como essa maturidade é avaliada?

2. A empresa adota os princípios de DevOps (colaboração, automação, melhoria contínua)? Descreva como são aplicados.

3. A equipe de desenvolvimento tem responsabilidade sobre operações (modelo “You Build It, You Run It”)?

4. A empresa pratica Site Reliability Engineering (SRE)? Quais princípios são adotados?

5. Como é promovida a cultura de colaboração entre desenvolvimento, operações e segurança (DevSecOps)?

6. A empresa possui profissionais certificados em práticas DevOps ou plataformas cloud? Quais certificações?

7. Quais ferramentas de integração contínua são utilizadas? (Ex: Jenkins, GitLab CI, GitHub Actions, Azure DevOps, CircleCI, TeamCity)

8. Descreva o pipeline de CI padrão adotado pela empresa. Quais etapas são incluídas?

9. Como é garantida a execução de testes automatizados a cada commit ou pull request?

10. A empresa implementa análise estática de código e quality gates no pipeline de CI?

11. Como são tratadas as falhas no pipeline de CI? Existe política de bloqueio de merge?

12. Qual o tempo médio de execução do pipeline de CI? Como é otimizado?

13. A empresa pratica trunk-based development ou gitflow? Descreva a estratégia de branching.

14. Como são gerenciados os artefatos gerados pelo pipeline de CI? (Ex: Nexus, Artifactory, GitHub Packages)

15. A empresa pratica Continuous Delivery ou Continuous Deployment? Qual a diferença na abordagem?

16. Descreva o pipeline de CD padrão, desde o build até a entrega em produção.

17. Como são gerenciados os deployments em múltiplos ambientes (dev, QA, staging, produção)?

18. A empresa implementa aprovações manuais (gates) em determinadas etapas do pipeline?

19. Qual a frequência típica de deploys em produção nos projetos da empresa?

20. Como é garantida a rastreabilidade entre commits, builds e deployments?

21. Quais estratégias de deploy a empresa utiliza? (Ex: Blue-Green, Canary, Rolling, Recreate, A/B Testing)

22. Como é implementado o deploy Blue-Green para minimizar downtime?

23. A empresa tem experiência com Canary Releases? Como é feito o monitoramento e rollback?

24. Como são tratados os deploys de banco de dados junto com deploys de aplicação?

25. A empresa implementa Feature Flags/Feature Toggles? Quais ferramentas são utilizadas? (Ex: LaunchDarkly, Unleash, Flagsmith)

26. Como é garantido o zero-downtime durante deployments?

27. Descreva o processo de rollback em caso de falha no deploy.

28. A empresa utiliza containers Docker em seus projetos? Descreva a experiência.

29. Como são criadas e otimizadas as imagens Docker para aplicações Java/Spring Boot e Angular?

30. A empresa segue boas práticas de construção de imagens (multi-stage builds, imagens mínimas, non-root users)?

31. Como são gerenciados os registries de imagens Docker? (Ex: Docker Hub, ECR, ACR, GCR, Harbor)

32. A empresa utiliza Docker Compose para ambientes de desenvolvimento local?

33. Como são tratadas as vulnerabilidades em imagens Docker? Quais ferramentas de scan são utilizadas? (Ex: Trivy, Clair, Snyk)

34. A empresa tem experiência com builds de imagens nativas (GraalVM) para aplicações Java?

35. A empresa possui experiência com Kubernetes? Descreva o nível de maturidade.

36. Quais distribuições ou serviços gerenciados de Kubernetes a empresa utiliza? (Ex: EKS, AKS, GKE, OpenShift, Rancher)

37. Como são estruturados os manifestos Kubernetes? (Ex: YAML, Helm Charts, Kustomize)

38. A empresa utiliza Helm para gerenciamento de pacotes Kubernetes? Descreva a abordagem.

39. Como são implementados os health checks (readiness e liveness probes) nas aplicações?

40. Como é feito o gerenciamento de configurações e secrets no Kubernetes? (Ex: ConfigMaps, Secrets, External Secrets, Sealed Secrets)

41. A empresa tem experiência com auto-scaling (HPA, VPA, Cluster Autoscaler)?

42. Como são gerenciados os recursos (requests e limits) dos pods?

43. A empresa tem experiência com service mesh? (Ex: Istio, Linkerd, Consul Connect)

44. Como é implementado o ingress e balanceamento de carga no Kubernetes?

45. A empresa pratica Infrastructure as Code? Quais ferramentas são utilizadas? (Ex: Terraform, Pulumi, CloudFormation, ARM Templates, CDK)

46. Como é estruturado e organizado o código de infraestrutura?

47. A empresa utiliza módulos reutilizáveis de infraestrutura?

48. Como é feito o versionamento e revisão de código de infraestrutura?

49. A empresa implementa testes para código de infraestrutura? (Ex: Terratest, Checkov, tfsec)

50. Como é gerenciado o state da infraestrutura? (Ex: remote state, state locking)

51. A empresa pratica GitOps para gerenciamento de infraestrutura? Quais ferramentas? (Ex: ArgoCD, Flux, Rancher Fleet)

52. Com quais provedores de cloud a empresa possui experiência? (Ex: AWS, Azure, GCP, Oracle Cloud, IBM Cloud)

53. Quais serviços cloud são mais utilizados para aplicações Java/Angular? Descreva casos de uso.

54. A empresa tem experiência com arquiteturas multi-cloud ou hybrid-cloud?

55. Como é feita a gestão de custos e otimização de recursos cloud (FinOps)?

56. A empresa possui experiência com serviços serverless? (Ex: AWS Lambda, Azure Functions, Cloud Functions)

57. Quais serviços gerenciados de banco de dados a empresa utiliza? (Ex: RDS, Aurora, Azure SQL, Cloud SQL)

58. A empresa tem experiência com serviços de mensageria gerenciados? (Ex: Amazon SQS/SNS, Azure Service Bus, Cloud Pub/Sub)

59. Como é implementada a alta disponibilidade e disaster recovery em ambientes cloud?

60. Como são gerenciadas as configurações específicas de cada ambiente?

61. A empresa utiliza ferramentas de gerenciamento de configuração? (Ex: Ansible, Chef, Puppet, Salt)

62. Como são gerenciados os secrets e credenciais de forma segura? (Ex: HashiCorp Vault, AWS Secrets Manager, Azure Key Vault)

63. A empresa implementa rotação automática de secrets e credenciais?

64. Como é garantida a paridade entre ambientes (dev, staging, produção)?

65. A empresa tem experiência com ambientes efêmeros para desenvolvimento e testes?

66. Quais são os três pilares de observabilidade adotados pela empresa? (Logs, Métricas, Traces)

67. Quais ferramentas de monitoramento de infraestrutura são utilizadas? (Ex: Prometheus, Grafana, Datadog, New Relic, Dynatrace)

68. Como é implementado o monitoramento de aplicações (APM – Application Performance Monitoring)?

69. Quais ferramentas de centralização e análise de logs são utilizadas? (Ex: ELK Stack, Loki, Splunk, CloudWatch Logs)

70. A empresa implementa distributed tracing? Quais ferramentas? (Ex: Jaeger, Zipkin, OpenTelemetry, X-Ray)

71. Como são definidos e monitorados SLIs, SLOs e error budgets?

72. A empresa cria dashboards customizados para acompanhamento de métricas de negócio e técnicas?

73. Como é feita a correlação entre métricas de infraestrutura, aplicação e negócio?

74. Como são configurados os alertas de infraestrutura e aplicação?

75. Quais ferramentas de gestão de alertas são utilizadas? (Ex: PagerDuty, Opsgenie, VictorOps, Alertmanager)

76. A empresa define runbooks automatizados para resposta a incidentes?

77. Como é estruturado o processo de on-call e escalação?

78. A empresa pratica post-mortems blameless após incidentes?

79. Como são classificados e priorizados os incidentes? (Ex: severidade, impacto)

80. Qual o MTTR (Mean Time to Recovery) médio alcançado nos projetos?

81. Como a segurança é integrada no pipeline de CI/CD (DevSecOps)?

82. A empresa realiza scan de vulnerabilidades em imagens de containers?

83. Como são aplicadas políticas de segurança no Kubernetes? (Ex: Pod Security Standards, OPA/Gatekeeper, Kyverno)

84. A empresa implementa Network Policies para segmentação de rede no Kubernetes?

85. Como são gerenciados os acessos e permissões à infraestrutura? (Ex: RBAC, IAM)

86. A empresa realiza auditorias de segurança de infraestrutura periodicamente?

87. Como são tratados os patches de segurança de sistemas operacionais e dependências de infraestrutura?

88. A empresa tem experiência com ferramentas de CSPM (Cloud Security Posture Management)?

89. Quais estratégias de backup são implementadas para dados e aplicações?

90. Como é definida e testada a política de retenção de backups?

91. A empresa implementa e testa planos de Disaster Recovery (DR)?

92. Quais são os RPO (Recovery Point Objective) e RTO (Recovery Time Objective) típicos alcançados?

93. A empresa tem experiência com replicação multi-região para alta disponibilidade?

94. Como são realizados os testes de restauração de backups?

95. Como é dimensionada a infraestrutura para atender requisitos de performance e escalabilidade?

96. A empresa implementa auto-scaling de infraestrutura? Quais métricas são utilizadas como gatilho?

97. Como são realizados testes de capacidade e planejamento de crescimento?

98. A empresa tem experiência com CDN (Content Delivery Network) para otimização de entrega de conteúdo?

99. Como é implementado o caching em nível de infraestrutura? (Ex: Redis, Memcached, Varnish, CloudFront)

100. A empresa tem experiência com banco de dados distribuídos e sharding?

Total de questões neste tópico: 100

Há mais tópicos a serem avaliados?

Se sim, por favor informe o próximo tópico.

1. Há quantos anos a empresa trabalha com PostgreSQL em projetos de desenvolvimento?

2. Quantos projetos utilizando PostgreSQL foram entregues nos últimos 3 anos?

3. Quais versões do PostgreSQL a equipe possui experiência? A empresa está atualizada com as versões mais recentes (PostgreSQL 15, 16)?

4. A equipe possui profissionais certificados em PostgreSQL? (Ex: EDB PostgreSQL certifications)

5. A empresa tem experiência com PostgreSQL em ambientes on-premises e cloud-managed? (Ex: Amazon RDS, Aurora PostgreSQL, Azure Database for PostgreSQL, Cloud SQL)

6. Descreva o maior e mais complexo projeto em que PostgreSQL foi utilizado pela empresa.

7. Qual a metodologia de modelagem de dados utilizada pela empresa? (Ex: modelagem conceitual, lógica, física)

8. Como é conduzido o processo de design de banco de dados em novos projetos?

9. A empresa utiliza ferramentas de modelagem de dados? Quais? (Ex: ERwin, PowerDesigner, dbdiagram.io, pgModeler, DBeaver)

10. Como são aplicados os princípios de normalização e quando é aceitável desnormalizar?

11. A empresa documenta o modelo de dados com dicionário de dados completo?

12. Como são definidas e documentadas as convenções de nomenclatura (tabelas, colunas, constraints, índices)?

13. A empresa tem experiência com modelagem de dados para aplicações multi-tenant?

14. A equipe tem experiência com os tipos de dados avançados do PostgreSQL? (Ex: JSONB, Arrays, Hstore, Range Types, UUID)

15. Como a empresa utiliza JSONB para cenários semi-estruturados? Descreva casos de uso.

16. A equipe tem experiência com Full-Text Search nativo do PostgreSQL?

17. A empresa utiliza recursos de particionamento de tabelas? Quais estratégias? (Ex: Range, List, Hash)

18. A equipe tem experiência com herança de tabelas (Table Inheritance) no PostgreSQL?

19. A empresa tem experiência com extensões do PostgreSQL? Quais são mais utilizadas? (Ex: PostGIS, pg_trgm, uuid-ossp, pgcrypto, TimescaleDB)

20. A equipe utiliza Common Table Expressions (CTEs) e Window Functions? Descreva cenários de aplicação.

21. A empresa tem experiência com Materialized Views? Como é gerenciado o refresh?

22. Quais práticas são adotadas para otimização de performance de queries no PostgreSQL?

23. Como é feita a análise de planos de execução (EXPLAIN ANALYZE)?

24. A empresa utiliza ferramentas de monitoramento de performance do PostgreSQL? Quais? (Ex: pgAdmin, pg_stat_statements, pgBadger, Percona Monitoring)

25. Quais estratégias de indexação são utilizadas? (Ex: B-tree, Hash, GIN, GiST, BRIN)

26. Como a empresa identifica e resolve problemas de queries lentas?

27. A equipe tem experiência com tuning de parâmetros de configuração do PostgreSQL? (Ex: shared_buffers, work_mem, effective_cache_size)

28. Como é feito o gerenciamento de conexões e connection pooling? (Ex: PgBouncer, Pgpool-II)

29. A empresa realiza análise de bloat e manutenção de VACUUM/ANALYZE?

30. Como são tratados problemas de locks e deadlocks?

31. A equipe tem experiência com parallel query execution no PostgreSQL?

32. A empresa tem experiência com configuração de alta disponibilidade para PostgreSQL?

33. Quais soluções de replicação são utilizadas? (Ex: Streaming Replication, Logical Replication)

34. A empresa tem experiência com ferramentas de failover automático? (Ex: Patroni, repmgr, pg_auto_failover)

35. Como é implementado o load balancing entre réplicas de leitura?

36. A empresa tem experiência com PostgreSQL em configuração multi-região?

37. Como são tratados cenários de split-brain em clusters PostgreSQL?

38. A equipe tem experiência com replicação lógica para migrações ou CDC (Change Data Capture)?

39. Quais estratégias de backup são implementadas para PostgreSQL? (Ex: pg_dump, pg_basebackup, PITR)

40. A empresa implementa Point-in-Time Recovery (PITR)? Descreva o processo.

41. Como é definida e gerenciada a política de retenção de backups?

42. Quais ferramentas de backup são utilizadas? (Ex: pgBackRest, Barman, WAL-G)

43. Com que frequência são realizados testes de restauração de backup?

44. Qual o RTO e RPO típicos alcançados para bancos PostgreSQL?

45. Como são tratados backups de bancos de dados muito grandes (VLDBs)?

46. Quais práticas de segurança são implementadas em bancos PostgreSQL?

47. Como é gerenciado o controle de acesso e permissões (RBAC) no PostgreSQL?

48. A empresa implementa Row-Level Security (RLS)? Descreva casos de uso.

49. Como são protegidos dados sensíveis no banco? (Ex: criptografia de colunas, pgcrypto)

50. A empresa implementa criptografia de dados em repouso (TDE – Transparent Data Encryption)?

51. Como é configurada a criptografia de dados em trânsito (SSL/TLS)?

52. A empresa realiza auditoria de acessos e operações no banco? Quais ferramentas? (Ex: pgAudit)

53. Como são gerenciadas e rotacionadas as credenciais de acesso ao banco de dados?

54. A empresa implementa mascaramento de dados para ambientes não-produtivos?

55. Quais ferramentas são utilizadas para gerenciamento de migrations? (Ex: Flyway, Liquibase)

56. Como é garantida a execução ordenada e idempotente de migrations?

57. A empresa implementa migrations reversíveis (rollback)?

58. Como são tratadas migrations em ambientes com múltiplas instâncias da aplicação?

59. Qual o processo de revisão e aprovação de scripts de migration?

60. Como são tratadas migrations de longa duração que podem impactar a disponibilidade?

61. A empresa tem experiência com migrations zero-downtime?

62. Quais práticas são adotadas para uso eficiente do JPA/Hibernate com PostgreSQL?

63. Como a empresa evita problemas comuns como N+1 queries e cartesian products?

64. A equipe utiliza recursos nativos do PostgreSQL através de native queries quando necessário?

65. Como são mapeados os tipos especiais do PostgreSQL (JSONB, Arrays) em entidades JPA?

66. A empresa utiliza batch processing para operações em massa? Descreva a abordagem.

67. Como é feito o tratamento de transações longas e otimização de locks?

68. A equipe utiliza projections e DTOs para otimização de consultas?

69. A empresa possui práticas de governança de dados estabelecidas? Descreva a abordagem.

70. Como são definidos e documentados os data owners e data stewards?

71. A empresa utiliza catálogo de dados (data catalog)? Quais ferramentas? (Ex: Apache Atlas, Collibra, Alation, DataHub)

72. Como é garantida a qualidade dos dados (Data Quality)? Quais métricas são monitoradas?

73. A empresa implementa processos de data profiling e data cleansing?

74. Como são definidas e aplicadas as políticas de retenção de dados?

75. A empresa tem experiência com classificação de dados (data classification)?

76. A empresa tem experiência com adequação de bancos de dados à LGPD?

77. Como são tratados os direitos dos titulares de dados (acesso, retificação, exclusão)?

78. A empresa implementa anonimização e pseudonimização de dados pessoais?

79. Como é feita a gestão de consentimento e base legal no banco de dados?

80. A empresa tem experiência com outras regulamentações de privacidade? (Ex: GDPR, CCPA, HIPAA)

81. Como são documentadas as atividades de tratamento de dados (ROPA)?

82. A empresa realiza Data Protection Impact Assessment (DPIA)?

83. A empresa implementa linhagem de dados (data lineage)? Quais ferramentas são utilizadas?

84. Como é feita a rastreabilidade de dados desde a origem até o consumo?

85. A empresa utiliza metadados para documentar a origem e transformações dos dados?

86. Como são rastreadas as mudanças em dados críticos de negócio?

87. A empresa tem experiência com práticas de Master Data Management?

88. Como são identificados e gerenciados os dados mestres (master data)?

89. A empresa implementa processos de deduplicação e golden record?

90. Quais estratégias são utilizadas para sincronização de dados mestres entre sistemas?

91. A empresa tem experiência com implementação de data warehouses ou data lakes?

92. Como são estruturados os processos de ETL/ELT? Quais ferramentas são utilizadas?

93. A empresa tem experiência com Change Data Capture (CDC) para integração de dados? (Ex: Debezium, AWS DMS)

94. Como são tratadas as integrações de dados entre sistemas transacionais e analíticos?

95. A empresa tem experiência com PostgreSQL como fonte para ferramentas de BI?

96. Quais métricas de banco de dados são monitoradas? (Ex: conexões, transactions, locks, replication lag)

97. A empresa implementa alertas proativos para problemas de banco de dados?

98. Como é feito o capacity planning para crescimento do banco de dados?

99. A empresa utiliza dashboards para acompanhamento de saúde do banco de dados?

100. Como são detectadas e tratadas anomalias nos dados?

Total de questões neste tópico: 100

Há mais tópicos a serem avaliados?

Se sim, por favor informe o próximo tópico.

1. Qual o nível de maturidade da empresa em práticas de segurança da informação?

2. A empresa possui uma área ou equipe dedicada à segurança da informação? Como está estruturada?

3. A empresa adota frameworks de segurança reconhecidos? Quais? (Ex: NIST, ISO 27001, CIS Controls, OWASP)

4. A empresa possui certificações de segurança? Quais? (Ex: ISO 27001, SOC 2, PCI DSS)

5. Como a segurança é incorporada na cultura organizacional e no ciclo de desenvolvimento?

6. A empresa realiza treinamentos de segurança para desenvolvedores? Com que frequência?

7. A equipe possui profissionais com certificações de segurança? Quais? (Ex: CISSP, CEH, OSCP, Security+, CSSLP)

8. A empresa adota um Secure Software Development Lifecycle (SSDLC)? Descreva as fases e atividades.

9. Como os requisitos de segurança são identificados e documentados no início do projeto?

10. A empresa realiza modelagem de ameaças (Threat Modeling)? Quais metodologias são utilizadas? (Ex: STRIDE, PASTA, DREAD)

11. Em quais fases do desenvolvimento são realizadas revisões de segurança?

12. Como são priorizados e tratados os riscos de segurança identificados?

13. A empresa mantém um Security Champions Program? Descreva o funcionamento.

14. Como são documentadas as decisões de arquitetura relacionadas à segurança?

15. A empresa pratica DevSecOps? Como a segurança é integrada ao pipeline de CI/CD?

16. Quais ferramentas de SAST (Static Application Security Testing) são utilizadas? (Ex: SonarQube, Checkmarx, Fortify, Semgrep, CodeQL)

17. Quais ferramentas de DAST (Dynamic Application Security Testing) são utilizadas? (Ex: OWASP ZAP, Burp Suite, Acunetix)

18. A empresa realiza análise de composição de software (SCA)? Quais ferramentas? (Ex: Snyk, OWASP Dependency-Check, WhiteSource, Black Duck)

19. Quais ferramentas de scan de containers e IaC são utilizadas? (Ex: Trivy, Clair, Checkov, tfsec)

20. Como são gerenciados os findings de segurança identificados no pipeline?

21. A empresa implementa quality gates de segurança que bloqueiam o deploy?

22. Como é medida a efetividade das ferramentas de segurança automatizadas?

23. A equipe tem conhecimento e aplica as recomendações do OWASP Top 10?

24. Como são prevenidos ataques de Injection (SQL, NoSQL, Command, LDAP)?

25. Como é implementada a proteção contra Cross-Site Scripting (XSS)?

26. Quais práticas são adotadas para prevenção de Cross-Site Request Forgery (CSRF)?

27. Como são protegidas as aplicações contra ataques de Broken Authentication?

28. Quais práticas são adotadas para prevenção de Insecure Direct Object References (IDOR)?

29. Como são tratadas as vulnerabilidades de Security Misconfiguration?

30. Como é implementada a proteção contra ataques de XML External Entities (XXE)?

31. Quais práticas são adotadas para prevenção de Server-Side Request Forgery (SSRF)?

32. Como são identificadas e mitigadas vulnerabilidades em componentes de terceiros?

33. Quais padrões de autenticação são implementados? (Ex: OAuth 2.0, OpenID Connect, SAML)

34. A empresa tem experiência com integração a Identity Providers? Quais? (Ex: Keycloak, Auth0, Okta, Azure AD, AWS Cognito)

35. Como é implementada a autenticação multifator (MFA)?

36. Quais práticas são adotadas para gestão segura de sessões?

37. Como é implementado o controle de acesso baseado em papéis (RBAC)?

38. A empresa tem experiência com controle de acesso baseado em atributos (ABAC)?

39. Como são tratados os fluxos de recuperação de senha de forma segura?

40. Como é implementada a política de senhas fortes e sua validação?

41. A empresa implementa detecção de comportamentos anômalos de autenticação?

42. Como são protegidos os tokens de acesso (JWT, access tokens, refresh tokens)?

43. Quais práticas de segurança são implementadas para proteção de APIs REST?

44. Como é implementada a autenticação e autorização em APIs? (Ex: API Keys, OAuth 2.0, JWT)

45. A empresa implementa rate limiting e throttling para proteção contra abuse?

46. Como são validados e sanitizados os dados de entrada nas APIs?

47. A empresa implementa Content Security Policy (CSP) e outros headers de segurança?

48. Como são tratados os logs de segurança e auditoria de acessos às APIs?

49. A empresa tem experiência com API Gateway para centralização de segurança? (Ex: Kong, AWS API Gateway, Apigee)

50. Como são protegidas as APIs contra ataques de replay e man-in-the-middle?

51. Quais práticas de criptografia são adotadas para proteção de dados?

52. Como é implementada a criptografia de dados em repouso (at rest)?

53. Como é garantida a criptografia de dados em trânsito (in transit)?

54. A empresa utiliza Hardware Security Modules (HSM) para gerenciamento de chaves?

55. Como é feita a gestão do ciclo de vida de chaves criptográficas?

56. Quais algoritmos criptográficos são utilizados e como são mantidos atualizados?

57. A empresa implementa hashing seguro para senhas? Quais algoritmos? (Ex: bcrypt, Argon2, PBKDF2)

58. Como são protegidos dados sensíveis em logs e mensagens de erro?

59. A empresa tem experiência com tokenização de dados sensíveis?

60. Como são tratados os certificados digitais e sua renovação?

61. Quais ferramentas são utilizadas para gerenciamento de secrets? (Ex: HashiCorp Vault, AWS Secrets Manager, Azure Key Vault, CyberArk)

62. Como é garantido que secrets não são expostos em código-fonte ou logs?

63. A empresa implementa rotação automática de secrets e credenciais?

64. Como é feito o controle de acesso e auditoria de uso de secrets?

65. Quais práticas são adotadas para secrets em ambientes de desenvolvimento?

66. Quais práticas de segurança são implementadas na infraestrutura cloud?

67. Como é feito o hardening de servidores e containers?

68. A empresa implementa segmentação de rede e políticas de firewall?

69. Como são gerenciados os acessos privilegiados à infraestrutura? (Ex: PAM, just-in-time access)

70. A empresa implementa Zero Trust Architecture? Descreva a abordagem.

71. Como são tratadas as atualizações e patches de segurança de infraestrutura?

72. A empresa realiza scans de vulnerabilidades de infraestrutura periodicamente?

73. Como é feita a proteção contra ataques DDoS?

74. A empresa implementa Web Application Firewall (WAF)?

75. Como são coletados e armazenados os logs de segurança?

76. A empresa utiliza SIEM (Security Information and Event Management)? Quais ferramentas? (Ex: Splunk, ELK, Azure Sentinel, Datadog Security)

77. Quais eventos de segurança são monitorados e alertados?

78. Como são detectadas atividades maliciosas ou suspeitas?

79. A empresa possui um processo de resposta a incidentes de segurança documentado?

80. Qual o tempo médio de detecção (MTTD) e resposta (MTTR) a incidentes de segurança?

81. A empresa realiza exercícios de simulação de incidentes (tabletop exercises)?

82. Como são conduzidos os post-mortems de incidentes de segurança?

83. A empresa possui equipe de resposta a incidentes (CSIRT) ou contrato com terceiros?

84. A empresa realiza testes de penetração (pentest)? Com que frequência?

85. Os pentests são realizados internamente ou por terceiros especializados?

86. Como são priorizadas e tratadas as vulnerabilidades identificadas em pentests?

87. A empresa participa de programas de Bug Bounty?

88. São realizados testes de segurança específicos para APIs?

89. A empresa realiza Red Team exercises?

90. Como são testados os mecanismos de autenticação e autorização?

91. A empresa tem experiência com adequação à LGPD (Lei Geral de Proteção de Dados)?

92. Como são implementados os direitos dos titulares de dados (acesso, retificação, exclusão, portabilidade)?

93. A empresa tem experiência com outras regulamentações de privacidade? (Ex: GDPR, CCPA, HIPAA)

94. Como é documentado o mapeamento de dados pessoais e atividades de tratamento?

95. A empresa tem experiência com compliance PCI DSS para dados de cartão de crédito?

96. A empresa tem experiência com regulamentações do setor financeiro? (Ex: Bacen, SOX)

97. Como são tratados os requisitos de residência de dados (data residency)?

98. A empresa realiza auditorias de compliance periodicamente?

99. Como são gerenciadas as evidências de compliance para auditorias externas?

100. A empresa adota os princípios de Privacy by Design? Descreva a abordagem.

101. Como são realizadas as Avaliações de Impacto à Proteção de Dados (DPIA)?

102. A empresa implementa minimização de dados nas aplicações desenvolvidas?

103. Como é garantida a finalidade específica no tratamento de dados pessoais?

104. A empresa implementa mecanismos de consentimento granular?

105. Como são tratados os períodos de retenção e exclusão de dados pessoais?

106. Quais práticas de segurança são implementadas em aplicações Angular?

107. Como são prevenidos ataques XSS em aplicações single-page (SPA)?

108. A empresa implementa Content Security Policy (CSP) adequada para SPAs?

109. Como são protegidos os tokens de autenticação no navegador?

110. Quais práticas são adotadas para validação de entrada no front-end?

111. Como é garantida a segurança na comunicação com APIs (CORS, HTTPS)?

112. A empresa implementa proteção contra clickjacking (X-Frame-Options)?

113. Quais práticas de segurança são implementadas em aplicações Spring Boot?

114. Como é configurado o Spring Security para proteção das aplicações?

115. A empresa utiliza bibliotecas de segurança atualizadas e mantidas?

116. Como são tratadas as dependências vulneráveis identificadas?

117. Quais práticas de coding seguro são seguidas pela equipe Java?

118. Como são prevenidos ataques de desserialização insegura?

119. A empresa implementa limitação de recursos para prevenção de DoS? (Ex: timeouts, limites de payload)

120. A empresa possui um processo de gestão de vulnerabilidades estabelecido?

121. Como são classificadas e priorizadas as vulnerabilidades identificadas? (Ex: CVSS)

122. Quais são os SLAs para correção de vulnerabilidades por severidade?

123. Como é feito o acompanhamento e reporting do status de vulnerabilidades?

124. A empresa mantém inventário de ativos e componentes de software (SBOM)?

125. Como são tratadas as vulnerabilidades zero-day?

126. A empresa possui plano de continuidade de negócios (BCP) documentado?

127. Como são definidos e testados os procedimentos de disaster recovery?

128. A empresa realiza testes de resiliência e chaos engineering?

129. Como é garantida a disponibilidade dos sistemas em cenários de falha?

130. Quais são os RTOs e RPOs definidos para sistemas críticos?

Total de questões neste tópico: 130

Há mais tópicos a serem avaliados?

Se sim, por favor informe o próximo tópico.

1. Quais princípios de engenharia de software a empresa adota como fundamento para o desenvolvimento? (Ex: SOLID, DRY, KISS, YAGNI)

2. Como os princípios SOLID são aplicados no dia a dia de desenvolvimento? Dê exemplos práticos.

3. A empresa adota o princípio DRY (Don’t Repeat Yourself)? Como é evitada a duplicação de código?

4. Como é aplicado o princípio KISS (Keep It Simple, Stupid) para manter a simplicidade nas soluções?

5. A equipe pratica o princípio YAGNI (You Ain’t Gonna Need It)? Como é evitado o over-engineering?

6. Como a empresa equilibra pragmatismo e purismo técnico nas decisões de desenvolvimento?

7. A equipe aplica o princípio de Separation of Concerns? Descreva como é implementado.

8. A empresa adota as práticas de Clean Code? Quais são as mais enfatizadas?

9. Como são definidos e aplicados os padrões de nomenclatura (variáveis, métodos, classes)?

10. Quais práticas são adotadas para manter métodos e funções pequenos e focados?

11. Como é tratada a legibilidade do código? O código é escrito pensando em quem vai mantê-lo?

12. A empresa evita code smells ativamente? Quais são os mais combatidos? (Ex: Long Method, God Class, Feature Envy)

13. Como são tratados os comentários no código? A empresa prefere código autoexplicativo?

14. Quais práticas são adotadas para tratamento consistente de erros e exceções?

15. A empresa utiliza ferramentas de análise de code smells? Quais? (Ex: SonarQube, NDepend, CodeClimate)

16. Quais Design Patterns são mais utilizados pela equipe? (Ex: Factory, Strategy, Observer, Decorator)

17. Como a equipe decide quando aplicar um Design Pattern versus uma solução mais simples?

18. A equipe tem experiência com padrões de arquitetura empresarial? (Ex: Repository, Unit of Work, Domain Events)

19. Quais padrões são mais utilizados em aplicações Spring Boot? (Ex: Dependency Injection, Template Method, Proxy)

20. Quais padrões são mais utilizados em aplicações Angular? (Ex: Observer, Facade, Singleton via Services)

21. A equipe aplica padrões de integração empresarial (EIP)? Quais? (Ex: Message Queue, Pub/Sub, Saga)

22. Como são documentados e compartilhados os padrões de projeto adotados no projeto?

23. A empresa tem experiência com Clean Architecture? Descreva como é estruturada.

24. A equipe aplica os princípios de Arquitetura Hexagonal (Ports and Adapters)?

25. Como é garantida a separação entre regras de negócio e detalhes de infraestrutura?

26. A empresa utiliza Domain-Driven Design (DDD)? Quais conceitos são aplicados? (Ex: Entities, Value Objects, Aggregates, Bounded Contexts)

27. Como são definidos e protegidos os limites entre camadas da aplicação?

28. A equipe utiliza inversão de dependência para desacoplar módulos?

29. Como é estruturada a camada de domínio nas aplicações desenvolvidas?

30. A empresa pratica refactoring de forma contínua? Como é incorporado ao fluxo de trabalho?

31. Quais técnicas de refactoring são mais utilizadas? (Ex: Extract Method, Rename, Move, Inline)

32. Como é garantido que refactorings não introduzem regressões?

33. A equipe utiliza ferramentas de refactoring automatizado das IDEs?

34. Como são identificadas e priorizadas as oportunidades de refactoring?

35. A empresa adota a regra do Boy Scout (“deixe o código mais limpo do que encontrou”)?

36. Como é balanceado o tempo entre desenvolvimento de novas features e refactoring?

37. A empresa possui um processo para identificação e gestão de débito técnico?

38. Como o débito técnico é documentado e rastreado? (Ex: tags no backlog, registro em ferramenta específica)

39. Qual a estratégia para pagamento do débito técnico ao longo do projeto?

40. Como é comunicado o impacto do débito técnico para stakeholders não-técnicos?

41. A empresa utiliza métricas para quantificar o débito técnico? Quais?

42. Como é evitada a acumulação excessiva de débito técnico em projetos de longo prazo?

43. A empresa reserva tempo específico para endereçar débito técnico em cada sprint?

44. A empresa pratica code review obrigatório? Descreva o processo.

45. Quais são os critérios avaliados durante o code review?

46. A empresa utiliza checklists de code review? O que é verificado?

47. Quantos aprovadores são necessários para merge de código?

48. Como são tratadas as discordâncias durante o code review?

49. A empresa diferencia o rigor do review por tipo de mudança? (Ex: bugfix vs. nova feature)

50. Como é garantido que o code review seja construtivo e não gere conflitos na equipe?

51. Quais ferramentas são utilizadas para facilitar o code review? (Ex: GitHub PR, GitLab MR, Bitbucket, Crucible)

52. A empresa realiza pair programming ou mob programming como alternativa/complemento ao code review?

53. A empresa pratica Pair Programming? Em quais situações é utilizado?

54. A equipe utiliza Mob Programming para problemas complexos ou disseminação de conhecimento?

55. Como é feita a rotação de pares para garantir disseminação de conhecimento?

56. A empresa pratica code review síncrono (live review)?

57. Quais ferramentas são utilizadas para programação colaborativa remota? (Ex: VS Code Live Share, CodeTogether)

58. Qual sistema de controle de versão é utilizado? (Ex: Git, SVN)

59. Qual estratégia de branching é adotada? (Ex: GitFlow, GitHub Flow, Trunk-Based Development)

60. Como são nomeados branches, commits e tags?

61. A empresa adota Conventional Commits? Descreva o padrão de mensagens de commit.

62. Como é tratado o histórico do Git? A empresa pratica squash, rebase ou merge?

63. A empresa utiliza hooks de pré-commit para validações automáticas? Quais?

64. Como são protegidos os branches principais (main, develop)?

65. A empresa utiliza signed commits para garantir autenticidade?

66. Como é estruturado o pipeline de CI para garantir qualidade a cada commit?

67. Quais validações são executadas automaticamente no pipeline? (Ex: build, testes, lint, security scan)

68. A empresa pratica Continuous Delivery ou Continuous Deployment?

69. Como é garantido que o código na branch principal está sempre pronto para deploy?

70. A empresa utiliza feature flags para desacoplar deploy de release?

71. Como são tratados os hotfixes em produção?

72. Qual o lead time médio desde o commit até a entrega em produção?

73. Como são gerenciadas as dependências de projetos Java? (Ex: Maven, Gradle)

74. Como são gerenciadas as dependências de projetos Angular? (Ex: npm, yarn)

75. A empresa mantém as dependências atualizadas? Com que frequência são revisadas?

76. Como são avaliadas novas dependências antes de serem adicionadas ao projeto?

77. A empresa utiliza ferramentas de atualização automática de dependências? (Ex: Dependabot, Renovate)

78. Como são tratadas as vulnerabilidades identificadas em dependências?

79. A empresa mantém um registro de licenças das dependências utilizadas?

80. Como é evitada a dependency hell e conflitos de versões?

81. A empresa utiliza linters e formatadores de código? Quais? (Ex: ESLint, Prettier, Checkstyle, Spotless)

82. Como é garantida a consistência de formatação em todo o codebase?

83. A empresa utiliza EditorConfig ou similar para padronização entre IDEs?

84. Existem templates de projeto padronizados para novos desenvolvimentos?

85. A empresa mantém arquétipos ou boilerplates para iniciar novos projetos?

86. Como são padronizadas as estruturas de projeto entre diferentes equipes?

87. Quais práticas de logging são adotadas no desenvolvimento?

88. A empresa define níveis de log adequados? (Ex: DEBUG, INFO, WARN, ERROR)

89. Como são estruturados os logs para facilitar análise e troubleshooting? (Ex: structured logging, correlation IDs)

90. A empresa evita logging de dados sensíveis? Como é garantido?

91. Como são tratados os logs em ambientes de desenvolvimento versus produção?

92. A empresa instrumenta o código para métricas e tracing?

93. Quais práticas de desenvolvimento são adotadas para garantir performance?

94. Como são evitados problemas comuns de performance durante o desenvolvimento?

95. A equipe considera Big O e complexidade algorítmica nas implementações?

96. Como são tratadas operações custosas (I/O, rede, banco de dados)?

97. A empresa pratica profiling durante o desenvolvimento?

98. Como são identificados e otimizados hotspots de performance?

99. A acessibilidade é considerada desde o início do desenvolvimento?

100. Como são implementados os requisitos de acessibilidade no código Angular?

101. A empresa segue as diretrizes WCAG durante o desenvolvimento?

102. Como é estruturado o código para suportar internacionalização (i18n)?

103. A empresa considera diferentes locales (datas, números, moedas) no desenvolvimento?

104. A empresa pratica TDD (Test-Driven Development)? Descreva o processo.

105. A equipe escreve testes antes ou depois da implementação?

106. Como é garantido que os testes são significativos e não apenas para cobertura?

107. A empresa pratica BDD (Behavior-Driven Development)?

108. Como são escritos testes que documentam o comportamento esperado do sistema?

109. A equipe utiliza test doubles de forma adequada? (Ex: mocks, stubs, fakes, spies)

110. A empresa adota documentação como código (docs as code)?

111. Como são documentadas as APIs e contratos no código?

112. A equipe mantém README files atualizados em cada repositório?

113. São geradas documentações automáticas a partir do código? (Ex: Javadoc, Compodoc, Swagger)

114. Como são documentadas as decisões técnicas importantes no código?

115. A empresa utiliza ADRs (Architecture Decision Records)?

116. Como a equipe garante que o código é fácil de manter e evoluir?

117. Quais práticas são adotadas para garantir extensibilidade sem modificar código existente (Open/Closed)?

118. Como são projetadas interfaces e abstrações para facilitar mudanças futuras?

119. A empresa considera o princípio de Least Astonishment no design de APIs e interfaces?

120. Como é garantido que novos desenvolvedores conseguem entender e contribuir rapidamente com o código?

121. A equipe segue práticas de Secure Coding? Quais guidelines são utilizados? (Ex: OWASP Secure Coding Practices)

122. Como são tratadas validações de entrada e sanitização de dados no código?

123. A equipe evita vulnerabilidades comuns durante o desenvolvimento?

124. Como são gerenciados secrets e configurações sensíveis no código?

125. A empresa realiza security code review além do code review funcional?

126. Quais ferramentas e práticas são utilizadas para aumentar a produtividade dos desenvolvedores?

127. A empresa utiliza geradores de código ou scaffolding? Quais? (Ex: Angular CLI, JHipster, Spring Initializr)

128. Como são automatizadas tarefas repetitivas do desenvolvimento?

129. A empresa utiliza IDEs e plugins padronizados? Quais são recomendados?

130. A equipe utiliza snippets e templates de código compartilhados?

131. Como a empresa promove o aprendizado contínuo da equipe de desenvolvimento?

132. São realizadas sessões de tech talks, lightning talks ou brown bags?

133. A empresa incentiva participação em conferências e comunidades técnicas?

134. Como são compartilhadas as lições aprendidas entre projetos?

135. A empresa realiza retrospectivas técnicas além das retrospectivas de processo?

136. Como são avaliadas e adotadas novas tecnologias e práticas?

137. A empresa mantém uma base de conhecimento técnico interno?

Total de questões neste tópico: 137

Há mais tópicos a serem avaliados?

Se sim, por favor informe o próximo tópico.

1. Há quantos anos a empresa trabalha com soluções de Identity and Access Management (IAM)?

2. Quantos projetos envolvendo SSO, SAML ou OAuth 2.0 foram entregues nos últimos 3 anos?

3. A equipe possui profissionais certificados em soluções de identidade? Quais certificações? (Ex: Okta, Auth0, Microsoft Identity)

4. Descreva o projeto mais complexo envolvendo gestão de identidade e acesso implementado pela empresa.

5. A empresa tem experiência com implementações de IAM em diferentes setores? (Ex: financeiro, saúde, governo, varejo)

6. A equipe tem experiência com padrões e especificações de identidade federada?

7. Com quais Identity Providers a empresa possui experiência de integração? (Ex: Keycloak, Auth0, Okta, Azure AD, AWS Cognito, Ping Identity, ForgeRock)

8. A empresa tem experiência com implementação e configuração do Keycloak? Descreva casos de uso.

9. A equipe tem experiência com Azure Active Directory (Azure AD / Entra ID)? Quais funcionalidades foram implementadas?

10. A empresa tem experiência com AWS Cognito? Descreva cenários de utilização.

11. A equipe possui experiência com Auth0? Quais recursos foram implementados?

12. A empresa tem experiência com Okta? Descreva integrações realizadas.

13. Como a empresa avalia e recomenda a escolha de um Identity Provider para cada projeto?

14. A equipe tem experiência com migração entre diferentes Identity Providers?

15. A empresa tem experiência com implementação de Single Sign-On (SSO)? Descreva a abordagem.

16. Quais protocolos de SSO a equipe domina? (Ex: SAML 2.0, OpenID Connect, WS-Federation)

17. Como é implementado o SSO entre múltiplas aplicações web?

18. A empresa tem experiência com SSO para aplicações mobile?

19. Como é tratado o Single Logout (SLO) para garantir encerramento de sessão em todas as aplicações?

20. A equipe tem experiência com SSO cross-domain? Como são tratados os desafios de cookies entre domínios?

21. Como é implementado o SSO em arquiteturas de microsserviços?

22. A empresa tem experiência com SSO para aplicações desktop?

23. Como são tratados os cenários de fallback quando o IdP está indisponível?

24. A empresa tem experiência com SSO iniciado pelo Service Provider (SP-initiated) e pelo Identity Provider (IdP-initiated)?

25. Qual o nível de experiência da equipe com o protocolo SAML 2.0?

26. A empresa tem experiência como Service Provider (SP) SAML? Descreva implementações.

27. A empresa tem experiência como Identity Provider (IdP) SAML? Descreva implementações.

28. Como são gerenciados os metadados SAML (SP metadata, IdP metadata)?

29. Quais bibliotecas são utilizadas para implementação SAML em Java/Spring? (Ex: Spring Security SAML, OpenSAML, OneLogin SAML)

30. Como são tratadas as asserções SAML (Assertions) e seus atributos?

31. A empresa implementa assinatura e criptografia de mensagens SAML?

32. Como são gerenciados os certificados X.509 utilizados no SAML?

33. A equipe tem experiência com SAML Bindings? (Ex: HTTP-POST, HTTP-Redirect, Artifact)

34. Como são tratados os cenários de clock skew e validação de tempo em asserções SAML?

35. A empresa tem experiência com SAML Attribute Mapping e transformação de claims?

36. Como são implementados os perfis SAML (Web Browser SSO Profile, Single Logout Profile)?

37. A equipe tem experiência com troubleshooting de fluxos SAML? Quais ferramentas são utilizadas?

38. Qual o nível de experiência da equipe com o framework OAuth 2.0?

39. Quais grant types do OAuth 2.0 a equipe domina? (Ex: Authorization Code, Client Credentials, Implicit, Resource Owner Password, Device Code)

40. A empresa implementa o Authorization Code Flow com PKCE? Em quais cenários?

41. Como é implementado o Client Credentials Flow para comunicação entre serviços?

42. A equipe tem experiência com o Device Authorization Grant para dispositivos com entrada limitada?

43. Como são gerenciados os access tokens e refresh tokens?

44. Quais práticas são adotadas para definição de escopos (scopes) OAuth?

45. Como é implementada a revogação de tokens (Token Revocation)?

46. A empresa implementa Token Introspection para validação de tokens?

47. Quais bibliotecas são utilizadas para implementação OAuth 2.0 em Java/Spring? (Ex: Spring Security OAuth, Spring Authorization Server)

48. Como são protegidas as aplicações contra ataques comuns ao OAuth 2.0? (Ex: CSRF, token leakage, redirect URI manipulation)

49. A equipe tem experiência com OAuth 2.0 para APIs? Como é feita a proteção de recursos?

50. A empresa tem experiência com dynamic client registration?

51. Qual o nível de experiência da equipe com OpenID Connect?

52. Como a empresa diferencia e utiliza OAuth 2.0 e OpenID Connect de forma complementar?

53. A equipe tem experiência com os diferentes flows do OIDC? (Ex: Authorization Code, Implicit, Hybrid)

54. Como são tratados e validados os ID Tokens (JWT)?

55. A empresa implementa claims customizadas no ID Token?

56. Como é utilizado o endpoint UserInfo para obtenção de informações do usuário?

57. A equipe tem experiência com OIDC Discovery (/.well-known/openid-configuration)?

58. Como são implementados os prompts de autenticação e consentimento? (Ex: prompt=login, prompt=consent)

59. A empresa tem experiência com OIDC Session Management?

60. Como são tratados os cenários de logout com OIDC (RP-Initiated Logout, Back-Channel Logout, Front-Channel Logout)?

61. A equipe tem experiência com OIDC para aplicações SPA (Single Page Applications)?

62. A empresa implementa OIDC em aplicações mobile nativas?

63. Qual o nível de experiência da equipe com JSON Web Tokens (JWT)?

64. Quais algoritmos de assinatura são utilizados para JWTs? (Ex: RS256, HS256, ES256)

65. Como é feita a validação completa de JWTs? (assinatura, expiração, issuer, audience)

66. A empresa implementa JWTs criptografados (JWE) além de assinados (JWS)?

67. Como são gerenciadas as chaves de assinatura (JWKS – JSON Web Key Set)?

68. Quais práticas são adotadas para definição de claims em JWTs?

69. Como é tratada a rotação de chaves de assinatura de JWTs?

70. A equipe tem experiência com refresh token rotation para segurança adicional?

71. Como são tratados JWTs de longa duração versus curta duração?

72. Quais bibliotecas são utilizadas para manipulação de JWTs em Java? (Ex: Nimbus JOSE+JWT, jjwt, Auth0 Java JWT)

73. Como são tratados JWTs em aplicações Angular? Quais bibliotecas são utilizadas?

74. A empresa implementa práticas para minimizar o tamanho dos JWTs?

75. Como é configurado o Spring Security para integração com OAuth 2.0/OIDC?

76. A empresa utiliza Spring Security OAuth2 Client? Descreva a configuração.

77. A empresa utiliza Spring Security OAuth2 Resource Server? Como é implementada a validação de tokens?

78. A equipe tem experiência com Spring Authorization Server para criação de Authorization Servers customizados?

79. Como são implementados filtros de segurança customizados para cenários específicos de autenticação?

80. A empresa implementa Method Security com base em claims e roles do token?

81. Como é feita a propagação de tokens em chamadas entre microsserviços?

82. A equipe tem experiência com reactive security (WebFlux) para OAuth 2.0/OIDC?

83. Como é implementada a autenticação OAuth 2.0/OIDC em aplicações Angular?

84. Quais bibliotecas são utilizadas para OIDC em Angular? (Ex: angular-oauth2-oidc, @auth0/auth0-angular, MSAL Angular)

85. Como são gerenciados os tokens no navegador de forma segura?

86. A empresa implementa silent refresh para renovação automática de tokens?

87. Como são tratados os interceptors HTTP para inclusão de tokens nas requisições?

88. Como é implementado o logout completo em aplicações Angular?

89. A empresa implementa guards de rota baseados em autenticação e autorização?

90. Como são tratados os cenários de token expirado durante a navegação do usuário?

91. Como é implementado o controle de acesso baseado em papéis (RBAC)?

92. A empresa tem experiência com controle de acesso baseado em atributos (ABAC)?

93. Como são definidos e gerenciados os papéis (roles) e permissões?

94. A empresa implementa autorização fine-grained em nível de recursos?

95. Como são tratadas as políticas de autorização complexas? (Ex: policy engines como OPA, Casbin)

96. A equipe tem experiência com claims-based authorization?

97. Como é feita a sincronização de roles e permissões entre o IdP e as aplicações?

98. A empresa implementa delegation e impersonation de usuários?

99. Como são auditadas as decisões de autorização?

100. A empresa tem experiência com IAM em arquiteturas multi-tenant?

101. Como é implementado o isolamento de identidades entre tenants?

102. A empresa tem experiência com tenant-specific Identity Providers?

103. Como são tratados os cenários de usuários pertencentes a múltiplos tenants?

104. A empresa implementa branding customizado por tenant nas telas de login?

105. Como são gerenciadas as políticas de autenticação por tenant?

106. A empresa tem experiência com federação de identidades entre organizações?

107. Como são estabelecidas relações de confiança entre Identity Providers?

108. A equipe tem experiência com identity brokering?

109. Como são tratados os cenários de multiple IdPs para uma mesma aplicação?

110. A empresa tem experiência com social login? (Ex: Google, Facebook, Apple, Microsoft)

111. Como é feito o linking de contas entre diferentes provedores de identidade?

112. A equipe tem experiência com just-in-time (JIT) provisioning de usuários?

113. A empresa tem experiência com implementação de autenticação multifator (MFA)?

114. Quais fatores de autenticação são suportados? (Ex: TOTP, SMS, Email, Push, FIDO2/WebAuthn)

115. A equipe tem experiência com WebAuthn e autenticação passwordless?

116. Como são implementadas políticas de MFA condicionais? (Ex: baseadas em risco, localização, dispositivo)

117. A empresa tem experiência com adaptive authentication?

118. Como é tratado o enrollment e recovery de fatores MFA?

119. A empresa implementa step-up authentication para operações sensíveis?

120. A empresa tem experiência com provisionamento e desprovisionamento automático de usuários?

121. A equipe tem experiência com protocolos SCIM para gestão de identidades?

122. Como é feita a sincronização de usuários entre sistemas?

123. A empresa tem experiência com self-service de gestão de conta pelo usuário?

124. Como são tratados os fluxos de convite e onboarding de usuários?

125. A empresa implementa políticas de ciclo de vida de contas? (Ex: desativação por inatividade)

126. Quais práticas de segurança são adotadas na implementação de soluções IAM?

127. Como são protegidas as credenciais e secrets relacionados ao IAM?

128. A empresa implementa detecção de ataques de credential stuffing e brute force?

129. Como são tratadas as sessões de usuário de forma segura?

130. A empresa implementa logging e auditoria completa de eventos de autenticação?

131. Como são detectados e tratados comportamentos anômalos de autenticação?

132. A empresa realiza testes de segurança específicos para fluxos de autenticação?

133. Como são tratadas as vulnerabilidades conhecidas em protocolos de identidade?

134. Quais ferramentas são utilizadas para troubleshooting de fluxos SSO/OAuth/SAML?

135. Como são analisados e debugados os tokens e asserções?

136. A empresa implementa monitoramento de saúde dos serviços de identidade?

137. Quais métricas de IAM são monitoradas? (Ex: taxa de autenticação, falhas, latência)

138. Como são tratados os cenários de degradação ou indisponibilidade do IdP?

139. A empresa implementa circuit breakers para integração com IdPs?

140. Como são diagnosticados problemas de sincronização de sessão entre aplicações?

141. A empresa tem experiência com requisitos de compliance para IAM? (Ex: SOC 2, ISO 27001, GDPR, LGPD)

142. Como são tratados os requisitos de privacidade na gestão de identidades?

143. A empresa implementa consentimento e gestão de preferências de usuário?

144. Como são atendidos os direitos dos titulares de dados no contexto de IAM?

145. A empresa tem experiência com requisitos setoriais específicos? (Ex: PCI DSS, HIPAA, regulamentações bancárias)

Total de questões neste tópico: 145

Há mais tópicos a serem avaliados?

Se sim, por favor informe o próximo tópico.

1. Há quantos anos a empresa desenvolve sistemas distribuídos de alta disponibilidade?

2. Quantos projetos envolvendo arquiteturas resilientes e escaláveis foram entregues nos últimos 3 anos?

3. Descreva o projeto mais complexo envolvendo sistemas distribuídos e event-driven implementado pela empresa.

4. A equipe possui experiência com o teorema CAP e suas implicações práticas?

5. A empresa tem experiência com sistemas que exigem alta disponibilidade (99.9%+)?

6. A equipe possui certificações relevantes em arquiteturas cloud e distribuídas?

7. Quais padrões de resiliência a empresa adota em seus projetos? (Ex: Circuit Breaker, Retry, Timeout, Bulkhead, Fallback)

8. Como é implementado o padrão Circuit Breaker? Quais bibliotecas são utilizadas? (Ex: Resilience4j, Hystrix, Sentinel)

9. Como são configuradas as políticas de retry com backoff exponencial?

10. A empresa implementa o padrão Bulkhead para isolamento de falhas? Descreva a abordagem.

11. Como são definidos e configurados os timeouts em chamadas entre serviços?

12. A empresa implementa fallbacks graceful para cenários de falha?

13. Como é implementado o padrão Rate Limiter para proteção de serviços?

14. A empresa utiliza o padrão Throttling? Em quais cenários?

15. Como são tratados os cenários de cascading failures?

16. A empresa implementa o padrão Shed Load para proteção contra sobrecarga?

17. Qual o nível de experiência da equipe com Resilience4j?

18. Como é feita a configuração do Resilience4j em aplicações Spring Boot?

19. A empresa utiliza as anotações declarativas do Resilience4j? (Ex: @CircuitBreaker, @Retry, @RateLimiter)

20. Como são configurados os thresholds e janelas de tempo do Circuit Breaker?

21. A empresa implementa combinação de padrões de resiliência? (Ex: Retry + Circuit Breaker + Timeout)

22. Como são expostas e monitoradas as métricas do Resilience4j?

23. A empresa tem experiência com Resilience4j em contextos reativos (WebFlux)?

24. Como são testados os mecanismos de resiliência implementados?

25. Como são implementados os health checks nas aplicações?

26. A empresa diferencia entre liveness e readiness probes? Descreva a abordagem.

27. Como são implementados health checks para dependências externas (banco de dados, cache, mensageria)?

28. A empresa implementa mecanismos de self-healing? Descreva cenários.

29. Como são tratados os cenários de degradação graceful?

30. A empresa utiliza health checks compostos (composite health indicators)?

31. Como são configurados os thresholds de health para orquestradores (Kubernetes)?

32. Quais práticas são adotadas para garantir escalabilidade horizontal das aplicações?

33. Como é garantido que as aplicações são stateless para permitir escalabilidade?

34. A empresa implementa externalização de estado (sessão, cache) para escalabilidade?

35. Quais estratégias de session management são utilizadas em ambientes distribuídos? (Ex: Redis, sticky sessions)

36. Como são tratados os uploads e armazenamento de arquivos em ambientes escaláveis?

37. A empresa tem experiência com auto-scaling baseado em métricas customizadas?

38. Quais métricas são utilizadas como gatilho para auto-scaling? (Ex: CPU, memória, requisições, filas)

39. Como é feito o dimensionamento de réplicas para diferentes componentes?

40. A empresa tem experiência com scaling preditivo além de reativo?

41. Como a empresa avalia a necessidade de escalabilidade vertical versus horizontal?

42. Quais práticas são adotadas para otimização de uso de memória em aplicações Java?

43. Como são configurados os parâmetros de JVM para performance e escalabilidade?

44. A empresa tem experiência com GraalVM Native Image para otimização de recursos?

45. Como são identificados e otimizados os gargalos de CPU e memória?

46. Quais estratégias de load balancing são utilizadas? (Ex: Round Robin, Least Connections, Weighted)

47. A empresa tem experiência com load balancing em diferentes camadas? (Ex: L4, L7)

48. Como é implementado o client-side load balancing em microsserviços?

49. A empresa utiliza service mesh para load balancing? (Ex: Istio, Linkerd)

50. Como são tratados os cenários de sticky sessions quando necessário?

51. A empresa implementa health-aware load balancing?

52. Quais estratégias de caching são utilizadas para escalabilidade? (Ex: local cache, distributed cache)

53. A empresa tem experiência com Redis como solução de cache distribuído?

54. Como são definidas as políticas de cache (TTL, eviction)?

55. A empresa implementa cache-aside, read-through ou write-through patterns?

56. Como é tratada a invalidação de cache de forma consistente?

57. A empresa tem experiência com cache em múltiplas camadas (multi-tier caching)?

58. Como são tratados os cenários de cache stampede?

59. A empresa implementa caching de resultados de APIs (HTTP caching)?

60. Qual o nível de experiência da empresa com arquiteturas event-driven?

61. Quais benefícios e trade-offs da arquitetura event-driven a empresa considera em seus projetos?

62. Como a empresa diferencia entre eventos, comandos e queries no design de sistemas?

63. A empresa adota o padrão Event Sourcing? Descreva casos de uso e implementação.

64. A empresa implementa CQRS (Command Query Responsibility Segregation)? Descreva a abordagem.

65. Como é feito o design de eventos (event schema design)?

66. A empresa utiliza event storming para descoberta de domínio e eventos?

67. Como são tratados os eventos de domínio (domain events) nas aplicações?

68. Qual o nível de experiência da empresa com Apache Kafka?

69. Como é feita a modelagem de tópicos e partições no Kafka?

70. Quais estratégias de particionamento são utilizadas para garantir ordenação e distribuição?

71. A empresa tem experiência com Kafka Consumer Groups? Como é gerenciado o balanceamento?

72. Como são tratados os cenários de reprocessamento e offset management?

73. A empresa implementa idempotência na produção e consumo de mensagens?

74. Quais práticas são adotadas para garantir exactly-once semantics?

75. A empresa tem experiência com Kafka Streams para processamento de streams?

76. A equipe tem experiência com ksqlDB para processamento em tempo real?

77. Como são tratados os cenários de dead letter queues no Kafka?

78. A empresa tem experiência com Schema Registry? Quais formatos são utilizados? (Ex: Avro, Protobuf, JSON Schema)

79. Como é feita a evolução de schemas de eventos (schema evolution)?

80. Quais ferramentas são utilizadas para monitoramento do Kafka? (Ex: Kafka Manager, AKHQ, Confluent Control Center)

81. A empresa tem experiência com Kafka Connect para integrações?

82. Como são tratados os cenários de cluster Kafka multi-region?

83. Qual o nível de experiência da empresa com RabbitMQ?

84. Como são utilizados os diferentes tipos de exchanges? (Ex: Direct, Topic, Fanout, Headers)

85. A empresa implementa padrões de dead letter e retry com RabbitMQ?

86. Como é feita a configuração de durabilidade e persistência de mensagens?

87. A empresa tem experiência com RabbitMQ clustering e alta disponibilidade?

88. A equipe tem experiência com Amazon SQS/SNS? Descreva casos de uso.

89. A empresa tem experiência com Azure Service Bus?

90. A empresa tem experiência com Google Cloud Pub/Sub?

91. Como a empresa avalia e recomenda a escolha de uma solução de mensageria?

92. Como é feita a integração com Kafka em aplicações Spring Boot? (Ex: Spring Kafka, Spring Cloud Stream)

93. A empresa utiliza Spring Cloud Stream? Quais binders são utilizados?

94. Como são configurados os consumers e producers em Spring Kafka?

95. A empresa implementa error handling e retry com Spring Kafka?

96. Como é feita a serialização/desserialização de mensagens? (Ex: JSON, Avro, Protobuf)

97. A empresa utiliza Spring Integration para fluxos de integração complexos?

98. Como são tratadas as transações envolvendo banco de dados e mensageria?

99. A empresa implementa o padrão Saga para transações distribuídas? Descreva a abordagem.

100. Quais estratégias de Saga são utilizadas? (Ex: choreography, orchestration)

101. Como é tratada a compensação em caso de falhas em sagas?

102. A empresa implementa o padrão Outbox para garantia de entrega de eventos?

103. Como é tratado o padrão Transactional Outbox com Change Data Capture (CDC)?

104. A empresa utiliza Debezium para CDC? Descreva casos de uso.

105. Como são tratados os padrões de retry e idempotência em consumidores?

106. A empresa implementa correlation IDs para rastreabilidade de fluxos assíncronos?

107. Como é implementado o padrão Competing Consumers?

108. A empresa tem experiência com message deduplication?

109. A empresa tem experiência com Event Sourcing? Descreva projetos e casos de uso.

110. Como são armazenados os eventos (event store)?

111. A empresa utiliza frameworks específicos para Event Sourcing? (Ex: Axon Framework, Eventuate)

112. Como são implementados os aggregates e command handlers?

113. Como é feita a reconstrução de estado a partir de eventos (event replay)?

114. A empresa implementa snapshots para otimização de reconstrução de estado?

115. Como são tratadas as projeções (projections/read models)?

116. Quais são os desafios e trade-offs do Event Sourcing que a empresa considera?

117. A empresa tem experiência com CQRS? Descreva a abordagem e casos de uso.

118. Como são separados os modelos de comando e consulta?

119. Como é tratada a consistência eventual entre command e query sides?

120. Quais bancos de dados são utilizados para os diferentes modelos (command store, query store)?

121. A empresa implementa CQRS com ou sem Event Sourcing?

122. Como são tratadas as atualizações de projeções de leitura?

123. A empresa tem experiência com processamento de streams em tempo real?

124. Quais frameworks de stream processing são utilizados? (Ex: Kafka Streams, Apache Flink, Apache Spark Streaming)

125. Como são tratados os cenários de windowing e aggregations em streams?

126. A empresa implementa complex event processing (CEP)?

127. Como são tratados os cenários de late events e out-of-order events?

128. A empresa tem experiência com real-time analytics e dashboards?

129. Como a empresa aborda a consistência em sistemas distribuídos?

130. Quais estratégias são utilizadas para eventual consistency?

131. A empresa implementa distributed locks quando necessário? Quais ferramentas? (Ex: Redis, Zookeeper)

132. Como são tratados os cenários de conflitos em sistemas eventualmente consistentes?

133. A empresa tem experiência com conflict-free replicated data types (CRDTs)?

134. Como são implementadas as compensações para manter a consistência?

135. Como é implementada a observabilidade em arquiteturas event-driven?

136. A empresa implementa distributed tracing em fluxos assíncronos? Como?

137. Quais métricas são monitoradas em sistemas de mensageria? (Ex: lag, throughput, latência)

138. Como são correlacionados logs e traces entre produtores e consumidores?

139. A empresa implementa alertas proativos para consumer lag e problemas de mensageria?

140. Como são diagnosticados problemas em fluxos event-driven complexos?

141. Como é garantida a alta disponibilidade em sistemas event-driven?

142. A empresa tem experiência com Kafka MirrorMaker ou similar para replicação cross-region?

143. Como são tratados os cenários de failover em sistemas de mensageria?

144. A empresa implementa backup e recovery de event stores?

145. Como são definidos e testados os planos de disaster recovery para sistemas event-driven?

146. Quais são os RTOs e RPOs típicos alcançados para sistemas event-driven?

147. Como são testados os mecanismos de resiliência (Circuit Breaker, Retry, etc.)?

148. A empresa pratica Chaos Engineering? Quais ferramentas são utilizadas? (Ex: Chaos Monkey, Litmus, Gremlin)

149. Como são realizados os testes de carga e stress em sistemas event-driven?

150. A empresa implementa testes de integração para fluxos assíncronos?

151. Como são testados os cenários de falha e recuperação?

152. A empresa utiliza Testcontainers para testes com Kafka/RabbitMQ?

153. Como são testadas as Sagas e fluxos de compensação?

154. Quais boas práticas de design de eventos a empresa adota?

155. A empresa define padrões e convenções para nomenclatura de eventos e tópicos?

156. Como é feita a governança de schemas de eventos?

157. A empresa documenta os fluxos de eventos (event catalog)?

158. Como são tratados os eventos de diferentes versões (versioning)?

159. A empresa implementa contratos de eventos entre produtores e consumidores?

160. Quais práticas são adotadas para evolução de sistemas event-driven sem breaking changes?

Total de questões neste tópico: 160

Há mais tópicos a serem avaliados?

Se sim, por favor informe o próximo tópico.

Excelente! O questionário de RFP foi concluído com sucesso. Abaixo está o resumo consolidado de todos os tópicos e questões geradas:

#TópicoQuestões1Linguagem, Experiência e Portfólio182Arquitetura Técnica e Melhores Práticas333Desenvolvimento Back-end (Java)454Desenvolvimento Front-end (Angular)685Qualidade, Performance e Testes Automatizados856Documentação e Entregas857Infraestrutura e DevOps1008Banco de Dados (PostgreSQL) e Governança de Dados1009Segurança e Compliance13010Melhores Práticas de Desenvolvimento de Software13711SSO, IAM, SAML e OAuth 2.014512Resiliência, Escalabilidade e Event Driven160TOTAL GERAL1.106

O questionário abrange de forma abrangente os seguintes aspectos para avaliação de consultorias de desenvolvimento de software:

• ✅ Stack tecnológico completo (Java, Spring Boot, Angular)

• ✅ Abordagem API First e design de APIs

• ✅ Banco de dados PostgreSQL

• ✅ Arquiteturas modernas (microsserviços, event-driven, CQRS)

• ✅ Padrões de resiliência e escalabilidade

• ✅ Testes automatizados em todos os níveis

• ✅ Práticas de Clean Code e SOLID

• ✅ Code review e práticas colaborativas

• ✅ Gestão de débito técnico

• ✅ CI/CD e DevOps

• ✅ Segurança de aplicações (OWASP)

• ✅ SSO, OAuth 2.0, SAML, OpenID Connect

• ✅ IAM e gestão de identidades

• ✅ Compliance (LGPD, GDPR, PCI DSS)

• ✅ Containerização e Kubernetes

• ✅ Cloud computing (AWS, Azure, GCP)

• ✅ Observabilidade e monitoramento

• ✅ Alta disponibilidade e disaster recovery

• ✅ Documentação técnica e funcional

• ✅ Transferência de conhecimento

• ✅ Artefatos de entrega

Dado o volume de 1.106 questões, recomenda-se:

• Selecionar as questões mais relevantes para o contexto específico do projeto

• Priorizar tópicos críticos para o sucesso do projeto

• Considerar o uso de questões eliminatórias (must-have) e classificatórias (nice-to-have)

Considere solicitar às consultorias:

• Respostas objetivas com evidências (cases, exemplos, métricas)

• Demonstrações práticas quando aplicável

• Documentação comprobatória (certificações, políticas)

Sugere-se definir:

• Pesos para cada tópico conforme prioridades do projeto

• Notas mínimas de corte por tópico

• Matriz de pontuação padronizada

Recomenda-se:

• Avaliação documental das respostas escritas

• Sessões de apresentação/defesa técnica

• Prova de conceito (PoC) para finalistas

• Verificação de referências

1. Revisar e customizar as questões conforme necessidades específicas do projeto

2. Definir pesos para cada tópico baseado nas prioridades

3. Criar matriz de avaliação com critérios de pontuação

4. Formatar o documento final da RFP com instruções para as consultorias

5. Definir cronograma do processo de seleção

6. Identificar avaliadores técnicos para cada tópico

Caso precise de ajuda adicional para:

• Selecionar um subconjunto de questões prioritárias

• Criar critérios de pontuação

• Formatar o documento final da RFP

• Definir questões eliminatórias

Estou à disposição para auxiliar! 🚀