Guia Prático: Previsão de entregas de software com simulação de Monte Carlo

1. O problema das estimativas fixas

No universo do desenvolvimento de software, a pergunta “Quando vai ficar pronto?” é uma constante. A abordagem tradicional para respondê-la geralmente envolve uma matemática simples e, infelizmente, enganosa: dividir o total de tarefas restantes pela velocidade média da equipe.

Essa estimativa de ponto único (ex: “2.5 semanas”) cria uma falsa sensação de precisão. Ela ignora a realidade fundamental do nosso trabalho: a incerteza. Imprevistos acontecem, a complexidade de uma tarefa pode ser maior que o esperado, um membro do time pode ficar doente… Confiar em uma estimativa fixa é preparar o terreno para prazos estourados, frustração e desconfiança.

Este guia propõe uma mudança de paradigma: sair do campo das promessas e entrar no campo das probabilidades. Utilizaremos a Simulação de Monte Carlo para abraçar a incerteza e transformá-la em uma ferramenta estratégica para gerenciar expectativas e riscos.

2. Preparando a simulação: Os dados essenciais

Antes de rodar a simulação, a qualidade dos dados de entrada é fundamental. Um modelo, por melhor que seja, produzirá resultados ruins se alimentado com informações imprecisas.

Como coletar a vazão (Throughput) do time?

A vazão é o número de tarefas que a equipe entrega por semana. Para obter esse dado:

Ferramenta: Utilize o histórico de um sistema como o Jira, Azure DevOps ou similar.
Período: Análise um período de tempo relevante e estável. Uma boa recomendação é coletar dados das últimas 8 a 12 semanas (2 a 3 meses). Períodos mais curtos podem ser voláteis, e períodos muito longos podem não refletir a realidade atual do time.
Exemplo Prático: Exporte as tarefas concluídas por semana. Você terá uma lista de números, como: [5, 8, 4, 6, 7, 5, 8, 6]. A menor vazão foi 4 e a maior foi 8. Essa é a faixa que alimentará nossa simulação.

Quais tarefas contar? Foco em valor

Este é um ponto crucial. Para prever a entrega de novas features, não devemos olhar para todas as tarefas que o time executa. É preciso filtrar e focar no que agrega valor direto ao produto.

Incluir: Tarefas de implementação de features.
Excluir (Descontar): Correção de bugs, débitos técnicos, refatorações, incidentes etc.

Ao fazer isso, medimos a vazão de entrega de valor, o que torna a previsão sobre novas features muito mais acurada.

3. A Ferramenta: Script em Node.js

Para colocar a simulação em prática, utilizamos o script em Node.js abaixo. Ele foi projetado para ser flexível, aceitando não apenas uma variação na vazão do time, mas também um grau de incerteza no escopo (ex: “restam de 15 a 20 tarefas”), tornando a simulação ainda mais próxima da realidade.

// previsao_cli.js

// --- PARÂMETROS DA SIMULAÇÃO ---
const VALORES_PADRAO = {
  tarefasMin: 15,
  tarefasMax: 15, // Por padrão, o intervalo é um número fixo
  vazaoMin: 3,
  vazaoMax: 8,
  simulacoes: 10000,
};

const args = process.argv.slice(2);

if (args[0] === '--help' || args[0] === '-h') {
  console.log(`
  Uso: node previsao_cli.js [tarefas_min] [tarefas_max] [vazao_min] [vazao_max]

  Argumentos:
    [tarefas_min]  - (Opcional) O número mínimo de tarefas restantes. Padrão: ${VALORES_PADRAO.tarefasMin}
    [tarefas_max]  - (Opcional) O número máximo de tarefas restantes. Se omitido, será igual ao mínimo. Padrão: ${VALORES_PADRAO.tarefasMax}
    [vazao_min]    - (Opcional) A menor vazão semanal. Padrão: ${VALORES_PADRAO.vazaoMin}
    [vazao_max]    - (Opcional) A maior vazão semanal. Padrão: ${VALORES_PADRAO.vazaoMax}

  Exemplos:
  - Cenário fixo (15 tarefas, vazão 3-8):
    node previsao_cli.js 15
  - Cenário com escopo variável (15 a 20 tarefas, vazão 3-8):
    node previsao_cli.js 15 20
  - Cenário completo (15 a 20 tarefas, vazão 4-9):
    node previsao_cli.js 15 20 4 9
  `);
  process.exit(0);
}

const TAREFAS_MIN = parseInt(args[0], 10) || VALORES_PADRAO.tarefasMin;
const TAREFAS_MAX = parseInt(args[1], 10) || TAREFAS_MIN; // Se o max não for passado, é igual ao min
const VAZAO_MINIMA_SEMANAL = parseInt(args[2], 10) || VALORES_PADRAO.vazaoMin;
const VAZAO_MAXIMA_SEMANAL = parseInt(args[3], 10) || VALORES_PADRAO.vazaoMax;
const NUMERO_DE_SIMULACOES = VALORES_PADRAO.simulacoes;

if (VAZAO_MINIMA_SEMANAL > VAZAO_MAXIMA_SEMANAL || TAREFAS_MIN > TAREFAS_MAX) {
    console.error("\x1b[31mErro: O valor mínimo não pode ser maior que o valor máximo.\x1b[0m");
    process.exit(1);
}

// --- LÓGICA DA SIMULAÇÃO ---
function sortearNumero(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

function executarUmaSimulacao() {
  let semanas = 0;
  // Sorteia o total de tarefas para ESTA simulação específica
  const totalTarefasNestaSimulacao = sortearNumero(TAREFAS_MIN, TAREFAS_MAX);
  let tarefasConcluidas = 0;

  while (tarefasConcluidas < totalTarefasNestaSimulacao) {
    semanas++;
    tarefasConcluidas += sortearNumero(VAZAO_MINIMA_SEMANAL, VAZAO_MAXIMA_SEMANAL);
  }
  return semanas;
}

function analisarResultados(resultados) {
  resultados.sort((a, b) => a - b);
  const calcularPercentil = (percentil) => {
    const index = Math.ceil(percentil / 100 * resultados.length) - 1;
    return resultados[index];
  };

  const p50 = calcularPercentil(50);
  const p70 = calcularPercentil(70);
  const p85 = calcularPercentil(85);
  const p95 = calcularPercentil(95);

  console.log("--- Previsão de Entrega (Simulação de Monte Carlo) ---");
  let escopoTexto = TAREFAS_MIN === TAREFAS_MAX ? `${TAREFAS_MIN}` : `entre ${TAREFAS_MIN} e ${TAREFAS_MAX}`;
  console.log(`\nBaseado em ${NUMERO_DE_SIMULACOES.toLocaleString('pt-BR')} simulações para completar ${escopoTexto} tarefas:`);
  console.log(`Vazão semanal de valor estimada entre ${VAZAO_MINIMA_SEMANAL} e ${VAZAO_MAXIMA_SEMANAL} tarefas.`);
  
  console.log("\nResultados Probabilísticos:");
  console.log(`\x1b[33m%s\x1b[0m`, `  -> 50% de chance de terminar em ${p50} semanas ou menos.`);
  console.log(`\x1b[32m%s\x1b[0m`, `  -> 70% de chance de terminar em ${p70} semanas ou menos.`);
  console.log(`\x1b[32m%s\x1b[0m`, `  -> 85% de chance de terminar em ${p85} semanas ou menos.`);
  console.log(`\x1b[32m%s\x1b[0m`, `  -> 95% de chance de terminar em ${p95} semanas ou menos.`);
}

// --- EXECUÇÃO PRINCIPAL ---
const todosOsResultados = [];
for (let i = 0; i < NUMERO_DE_SIMULACOES; i++) {
  todosOsResultados.push(executarUmaSimulacao());
}
analisarResultados(todosOsResultados);

Como Usar:

Cenário com escopo fixo (15 tarefas, vazão 3-8): node previsao_cli.js 15
Cenário com escopo variável (15 a 20 tarefas, vazão 3-8): node previsao_cli.js 15 20
Cenário completo com escopo e vazão variáveis (15 a 20 tarefas, vazão 4-9): node previsao_cli.js 15 20 4 9
Para visualizar todas as instruções de uso, execute o comando de ajuda: node previsao_cli.js --help

4. Decifrando a saída: O que os números realmente significam

Ao rodar a simulação, você obterá uma saída como esta:

Resultados Probabilísticos:
  -> 50% de chance de terminar em 3 semanas ou menos.
  -> 70% de chance de terminar em 3 semanas ou menos.
  -> 85% de chance de terminar em 4 semanas ou menos.
  -> 95% de chance de terminar em 4 semanas ou menos.

A repetição de valores não é um erro; é a informação mais valiosa.

A Natureza dos Dados

A saída de cada simulação é um número inteiro de semanas. O projeto não pode terminar em 3.5 semanas. A lista de 10.000 resultados é ordenada, e os percentis são extraídos dela.

Interpretando os percentis passo a passo

50% de chance de terminar em 3 semanas ou menos: O resultado na metade da lista(5000) ordenada é 3.
70% de chance de terminar em 3 semanas ou menos: Na posição 7.000, o resultado ainda é 3. Isso mostra que o cenário “3 semanas” é muito comum.
85% de chance de terminar em 4 semanas ou menos: Na posição 8.500, o resultado muda para 4. Esse é o “pulo do gato”, o ponto onde o risco aumenta.
95% de chance de terminar em 4 semanas ou menos: O resultado “4 semanas” também é comum, cobrindo a faixa de 85% a 95% de confiança.

O que isso significa na prática? O mapa de riscos.

Cenário Provável: Existe uma chance muito grande (até 70%) de o projeto terminar em 3 semanas.
O “Degrau” de Risco: A simulação alerta que, se as coisas não saírem como o esperado, o prazo salta para 4 semanas.
Planejamento de Alta Confiança: Para comunicar um prazo com 85% de confiança, você deve usar 4 semanas. A conversa com o PM ou stakeholder se torna mais estratégica: “O mais provável são 3 semanas, mas para termos 85% de certeza, o plano é para 4 semanas”.

5. Quando ter cautela: Limitações do modelo

Nenhuma ferramenta é uma bala de prata. A Simulação de Monte Carlo é poderosa, mas sua eficácia depende do contexto. É importante saber quando seus resultados podem ser menos confiáveis:

Falta de dados Históricos: Se o time é novo ou nunca mediu sua vazão, o modelo não tem como ser alimentado. Qualquer faixa de vazão será um “chute”, o que invalida o propósito da simulação.
Mudanças drásticas na Equipe: Se a composição do time mudou significativamente (ex: saíram 2 seniores e entraram 2 juniores), o histórico de vazão do time antigo não é mais válido para prever o futuro do time novo.
Mudança no tipo de Trabalho: Se a equipe está mudando de um tipo de desenvolvimento (ex: front-end) para outro completamente diferente (ex: ciência de dados), o desempenho passado não é um bom preditor do futuro.
Projetos muito pequenos: A técnica se beneficia da lei dos grandes números. Para um projeto com apenas 1 ou 2 tarefas, a variação é tão alta que a simulação oferece pouco valor em relação a uma conversa direta.

6. Conclusão: Equilibrando qualidade e previsibilidade no Asaas

No Asaas, a qualidade não é uma variável negociável, é o pilar que sustenta a confiança de nossos clientes. Dedicamos tempo e esforço para garantir que cada entrega atenda aos mais altos padrões de excelência técnica e de experiência do usuário.

No entanto, em um ambiente de negócios dinâmico, a previsibilidade é igualmente crucial. Ter uma estimativa confiável de quando uma nova feature estará disponível não é apenas sobre cumprir prazos. É sobre alinhar estratégias, coordenar equipes de marketing e vendas, e, fundamentalmente, planejar nossos OKRs (Objectives and Key Results) com base em metas tangíveis.

A Simulação de Monte Carlo surge como a ponte perfeita entre esses dois mundos. Ela nos permite manter nosso compromisso inabalável com a qualidade, ao mesmo tempo que nos fornece um mapa probabilístico de entrega. Em vez de datas frágeis, trabalhamos com cenários de confiança, permitindo que o Asaas planeje seu futuro de forma mais inteligente e estratégica, garantindo que continuaremos inovando e entregando valor de forma consistente.

Biografia: Líder Técnico | CTO | Engenheiro de Software

+15 anos de experiência em tecnologia, conectando engenharia e estratégia de negócio.

Liderou como CTO a jornada de uma startup, do dia zero à venda.

Experiência em múltiplas funções: de Engenheiro Full-stack a Tech Lead, CTO e COO.

Apaixonado por criar ferramentas para resolver problemas reais e explorar novas tecnologias.

Atualmente Tech Lead de Engenharia na tribo ERP do Asaas.

De 0 a 10, o quanto você recomendaria este artigo para um amigo?

Powered by: