Teoria da Produção SaaS

// Cálculo Real: Custo Marginal por Cliente
function calcularCustoMarginal(clienteInfo) {
  const { plano, receitaMensal, usoServidor, ticketsSuporteMes } = clienteInfo;
  
  // Custos de infraestrutura (baseado no uso real)
  const custoServidor = {
    'starter': 0.50,    // Uso baixo
    'pro': 1.20,        // Uso médio  
    'enterprise': 3.50  // Uso alto + recursos premium
  };
  
  // Custo de suporte (baseado em complexidade do plano)
  const custoSuporteBase = {
    'starter': 2.00,
    'pro': 5.00, 
    'enterprise': 15.00
  };
  
  // Custos variáveis
  const infraestrutura = custoServidor[plano];
  const suporte = custoSuporteBase[plano] + (ticketsSuporteMes * 8); // $8 por ticket
  const processamentoPagamento = receitaMensal * 0.029; // 2.9% Stripe
  const apis3rdParty = Math.min(receitaMensal * 0.01, 5); // Max $5/mês
  
  const custoMarginalTotal = infraestrutura + suporte + processamentoPagamento + apis3rdParty;
  const margemBruta = ((receitaMensal - custoMarginalTotal) / receitaMensal) * 100;
  
  return {
    plano,
    receita: receitaMensal,
    custos: {
      infraestrutura: Math.round(infraestrutura * 100) / 100,
      suporte: Math.round(suporte * 100) / 100,
      pagamento: Math.round(processamentoPagamento * 100) / 100,
      apis: Math.round(apis3rdParty * 100) / 100,
      total: Math.round(custoMarginalTotal * 100) / 100
    },
    margemBruta: Math.round(margemBruta * 10) / 10
  };
}

// Teste diferentes cenários
const cenarios = [
  { plano: 'starter', receitaMensal: 15, usoServidor: 'baixo', ticketsSuporteMes: 0.2 },
  { plano: 'pro', receitaMensal: 50, usoServidor: 'medio', ticketsSuporteMes: 0.5 },
  { plano: 'enterprise', receitaMensal: 200, usoServidor: 'alto', ticketsSuporteMes: 1.2 }
];

cenarios.forEach(cenario => {
  const resultado = calcularCustoMarginal(cenario);
  console.log(`${resultado.plano.toUpperCase()}: Receita $${resultado.receita}, Custo $${resultado.custos.total}, Margem ${resultado.margemBruta}%`);
});

/* Output:
STARTER: Receita $15, Custo $4.54, Margem 69.7%
PRO: Receita $50, Custo $11.15, Margem 77.7%  
ENTERPRISE: Receita $200, Custo $31.1, Margem 84.5%

Insight: Margem aumenta com o ticket médio!
*/

// Função de Produção SaaS: Output vs Inputs
class SaaSProductionFunction {
  // Inputs principais
  constructor() {
    this.labor = {
      developers: 0,
      designers: 0,
      productManagers: 0,
      devops: 0
    };
    
    this.capital = {
      codebase: 0,        // Linhas de código, arquitetura
      infrastructure: 0,   // Servidores, databases
      tools: 0,           // IDEs, monitoring, CI/CD
      data: 0             // User data, analytics, insights
    };
  }
  
  // Função de produção: Q = f(L, K)
  calculateOutput(labor, capital, timeframe = 'monthly') {
    // Fator tecnológico (A) - eficiência da equipe
    const technologyFactor = this.getTechnologyFactor(capital);
    
    // Produtividade marginal do trabalho
    const laborProductivity = this.calculateLaborProductivity(labor, capital);
    
    // Produtividade marginal do capital
    const capitalProductivity = this.calculateCapitalProductivity(capital, labor);
    
    return {
      features: laborProductivity.features * technologyFactor,
      bugFixes: laborProductivity.bugFixes * technologyFactor,
      customersServed: capitalProductivity.scalingCapacity,
      performance: capitalProductivity.performance,
      reliability: capitalProductivity.uptime
    };
  }
  
  // Produtividade marginal do trabalho (∂Q/∂L)
  calculateLaborProductivity(labor, capital) {
    const totalDevs = labor.developers;
    const totalSupport = labor.designers + labor.productManagers;
    
    // Lei dos rendimentos marginais decrescentes
    const diminishingReturns = Math.pow(totalDevs, 0.7); // <1 = diminishing
    
    return {
      features: diminishingReturns * (1 + totalSupport * 0.2),
      bugFixes: totalDevs * 0.8,
      codeQuality: Math.min(totalSupport / totalDevs, 1) // Ratio ideal
    };
  }
  
  // Produtividade marginal do capital (∂Q/∂K)
  calculateCapitalProductivity(capital, labor) {
    const infrastructureEfficiency = Math.log(capital.infrastructure + 1);
    const toolsMultiplier = 1 + (capital.tools * 0.1);
    
    return {
      scalingCapacity: infrastructureEfficiency * 1000, // Clientes que suporta
      performance: capital.infrastructure * toolsMultiplier,
      uptime: Math.min(capital.infrastructure * 0.999, 0.999) // Max 99.9%
    };
  }
  
  // Fator tecnológico (A) - melhora toda a produção
  getTechnologyFactor(capital) {
    // Mais código base = mais eficiência (até um ponto)
    const codebaseEfficiency = Math.min(capital.codebase * 0.001, 2);
    
    // Ferramentas modernas multiplicam produtividade
    const toolsEfficiency = 1 + (capital.tools * 0.05);
    
    return codebaseEfficiency * toolsEfficiency;
  }
}

// Exemplo: Startup vs Scale-up
const startup = new SaaSProductionFunction();
const scaleup = new SaaSProductionFunction();

// Startup: Poucos recursos
const startupOutput = startup.calculateOutput(
  { developers: 3, designers: 1, productManagers: 1, devops: 0 },
  { codebase: 50, infrastructure: 5, tools: 3, data: 1 }
);

// Scale-up: Mais recursos mas diminishing returns
const scaleupOutput = scaleup.calculateOutput(
  { developers: 25, designers: 8, productManagers: 5, devops: 3 },
  { codebase: 500, infrastructure: 50, tools: 20, data: 100 }
);

console.log('Startup Output:', startupOutput);
console.log('Scale-up Output:', scaleupOutput);
console.log('Efficiency Ratio:', scaleupOutput.features / startupOutput.features);

/* Output esperado:
Startup: Alta eficiência por dev (times pequenos)
Scale-up: Mais output total, mas eficiência por dev menor
Insight: Scaling requer otimização constante da função de produção!
*/

// Simulação: Diminishing Returns em Engineering Team
function calculateTeamProductivity(teamSize, complexity = 'medium') {
  // Fatores que afetam produtividade
  const complexityMultipliers = {
    'simple': 1.0,
    'medium': 0.8,
    'complex': 0.6
  };
  
  // Communication overhead: cresce exponencialmente
  const communicationOverhead = Math.pow(teamSize, 1.5) / 100;
  
  // Base productivity per developer
  const baseProductivity = 10; // features per month
  
  // Diminishing returns formula
  function marginalProductivity(n) {
    if (n <= 3) return baseProductivity; // Sweet spot
    if (n <= 8) return baseProductivity * 0.8; // Still good
    if (n <= 15) return baseProductivity * 0.6; // Coordination issues
    if (n <= 25) return baseProductivity * 0.4; // Process overhead
    return baseProductivity * 0.2; // Bureaucracy
  }
  
  let totalOutput = 0;
  let outputs = [];
  
  for (let dev = 1; dev <= teamSize; dev++) {
    const marginal = marginalProductivity(dev);
    const adjusted = marginal * complexityMultipliers[complexity] * (1 - communicationOverhead);
    totalOutput += Math.max(adjusted, 0);
    
    outputs.push({
      dev: dev,
      marginalOutput: Math.round(adjusted * 100) / 100,
      totalOutput: Math.round(totalOutput * 100) / 100,
      efficiency: Math.round((totalOutput / dev) * 100) / 100
    });
  }
  
  return outputs;
}

// Teste diferentes tamanhos de time
const teamSizes = [3, 5, 8, 12, 20, 30];

teamSizes.forEach(size => {
  const results = calculateTeamProductivity(size);
  const lastResult = results[results.length - 1];
  
  console.log(`Team Size: ${size}`);
  console.log(`  Total Output: ${lastResult.totalOutput} features/month`);
  console.log(`  Efficiency: ${lastResult.efficiency} features/dev/month`);
  console.log(`  Marginal: ${lastResult.marginalOutput} (last dev added)`);
  console.log('---');
});

/* Output típico:
Team Size: 3
  Total Output: 30 features/month
  Efficiency: 10 features/dev/month
  Marginal: 10 (last dev added)

Team Size: 8  
  Total Output: 62.4 features/month
  Efficiency: 7.8 features/dev/month
  Marginal: 7.8 (last dev added)

Team Size: 20
  Total Output: 108 features/month  
  Efficiency: 5.4 features/dev/month
  Marginal: 3.2 (last dev added)

Insight: Efficiency per dev decreases as team grows!
*/

// Otimização de Isoquantas: Work vs Capital no SaaS
class IsoquantOptimizer {
  constructor(targetOutput, wageCost, capitalCost) {
    this.Q = targetOutput; // Features per year
    this.w = wageCost;     // Salary per developer
    this.r = capitalCost;  // Tools/automation cost
  }
  
  // Função de produção Cobb-Douglas: Q = A * L^α * K^β
  // α + β = 1 (constant returns to scale)
  productionFunction(L, K, A = 1, alpha = 0.6, beta = 0.4) {
    return A * Math.pow(L, alpha) * Math.pow(K, beta);
  }
  
  // Encontrar combinações na isoquanta para output target
  findIsoquantCombinations() {
    const combinations = [];
    
    // Para diferentes níveis de capital, calcular trabalho necessário
    for (let K = 1; K <= 20; K++) {
      // Resolver para L: Q = A * L^α * K^β
      // L = (Q / (A * K^β))^(1/α)
      const L = Math.pow(this.Q / Math.pow(K, 0.4), 1/0.6);
      
      const totalCost = this.w * L + this.r * K;
      
      combinations.push({
        labor: Math.round(L * 10) / 10,
        capital: K,
        totalCost: Math.round(totalCost),
        laborCost: Math.round(this.w * L),
        capitalCost: this.r * K,
        efficiency: Math.round((this.Q / totalCost) * 1000) / 1000
      });
    }
    
    return combinations.sort((a, b) => a.totalCost - b.totalCost);
  }
  
  // Encontrar ponto ótimo (custo mínimo)
  findOptimalCombination() {
    const combinations = this.findIsoquantCombinations();
    return combinations[0]; // Primeiro é o de menor custo
  }
  
  // Calcular MRTS em um ponto específico
  calculateMRTS(L, K) {
    // MRTS = (∂Q/∂L) / (∂Q/∂K) = (α/β) * (K/L)
    const alpha = 0.6;
    const beta = 0.4;
    return (alpha / beta) * (K / L);
  }
}

// Exemplo: Startup quer produzir 50 features/ano
const optimizer = new IsoquantOptimizer(
  50,      // Target: 50 features/year
  120000,  // Salary: $120k/dev/year
  25000    // Tools: $25k/tool/year
);

console.log('=== ISOQUANT ANALYSIS: 50 Features/Year ===');
console.log('');

const combinations = optimizer.findIsoquantCombinations().slice(0, 8);
combinations.forEach((combo, i) => {
  const mrts = optimizer.calculateMRTS(combo.labor, combo.capital);
  console.log(`Option ${i+1}: ${combo.labor} devs + ${combo.capital} tools`);
  console.log(`  Cost: $${combo.totalCost.toLocaleString()}`);
  console.log(`  MRTS: ${Math.round(mrts * 100)/100} (tools per dev)`);
  console.log(`  Efficiency: ${combo.efficiency} features/$1k`);
  console.log('');
});

const optimal = optimizer.findOptimalCombination();
console.log('=== OPTIMAL COMBINATION ===');
console.log(`Best: ${optimal.labor} developers + ${optimal.capital} automation tools`);
console.log(`Total Cost: $${optimal.totalCost.toLocaleString()}/year`);
console.log(`Breakdown: $${optimal.laborCost.toLocaleString()} labor + $${optimal.capitalCost.toLocaleString()} tools`);

/* Output típico:
Option 1: 2.3 devs + 1 tools
  Cost: $301,000
  MRTS: 0.65 (tools per dev)
  Efficiency: 0.166 features/$1k

Option 2: 1.8 devs + 2 tools  
  Cost: $266,000
  MRTS: 1.67 (tools per dev)
  Efficiency: 0.188 features/$1k

Insight: Mais automation tools = menor custo total para mesmo output!
*/