Construir vs Comprar

// Calculadora de Opportunity Cost: Build vs Buy
class OpportunityCostAnalyzer {
  constructor(projectName) {
    this.projectName = projectName;
    this.buildCosts = {};
    this.buyCosts = {};
    this.opportunityCosts = {};
  }

  // Definir custos explícitos de construir
  setBuildCosts(params) {
    this.buildCosts = {
      developerTime: params.developers * params.monthsToBuil * params.salaryPerMonth,
      infrastructure: params.infrastructureCost || 5000,
      tools: params.toolsCost || 3000,
      securityAudit: params.securityAudit || 15000,
      maintenance: params.maintenanceYearly || 30000 // Manutenção anual
    };

    this.buildCosts.total = Object.values(this.buildCosts)
      .reduce((sum, cost) => sum + cost, 0);

    return this.buildCosts;
  }

  // Definir custos de comprar solução pronta
  setBuyCosts(params) {
    this.buyCosts = {
      subscriptionYearly: params.subscriptionYearly,
      integration: params.integrationCost || 10000,
      training: params.trainingCost || 5000,
      customization: params.customizationCost || 0
    };

    this.buyCosts.total = Object.values(this.buyCosts)
      .reduce((sum, cost) => sum + cost, 0);

    return this.buyCosts;
  }

  // Calcular opportunity costs de construir
  calculateOpportunityCosts(params) {
    this.opportunityCosts = {
      // Revenue perdida por time-to-market atrasado
      delayedRevenue: params.monthsDelay * params.monthlyRevenueProjection,

      // Features core não construídas
      coreFeaturesMissed: params.coreFeaturesMissed * params.revenuePerFeature,

      // Custo de não focar no diferencial competitivo
      competitiveDisadvantage: params.marketShareLost * params.ltv,

      // Debt técnico futuro
      technicalDebt: params.techDebtEstimate || 0
    };

    this.opportunityCosts.total = Object.values(this.opportunityCosts)
      .reduce((sum, cost) => sum + cost, 0);

    return this.opportunityCosts;
  }

  // Análise completa
  analyze() {
    const buildTotalEconomicCost = this.buildCosts.total + this.opportunityCosts.total;
    const buyTotalEconomicCost = this.buyCosts.total;

    const savings = buildTotalEconomicCost - buyTotalEconomicCost;
    const recommendation = savings > 0 ? 'BUY' : 'BUILD';

    return {
      project: this.projectName,
      buildCosts: this.buildCosts,
      buyCosts: this.buyCosts,
      opportunityCosts: this.opportunityCosts,
      comparison: {
        buildTotal: buildTotalEconomicCost,
        buyTotal: buyTotalEconomicCost,
        savings: Math.abs(savings),
        recommendation: recommendation,
        roiMultiple: (buildTotalEconomicCost / buyTotalEconomicCost).toFixed(2)
      }
    };
  }

  // Relatório formatado
  printReport() {
    const analysis = this.analyze();

    console.log(`=== ANÁLISE BUILD VS BUY: ${this.projectName.toUpperCase()} ===`);
    console.log('');

    console.log('BUILD - Custos Explícitos:');
    console.log(`  Developer Time: $${this.buildCosts.developerTime.toLocaleString()}`);
    console.log(`  Infrastructure: $${this.buildCosts.infrastructure.toLocaleString()}`);
    console.log(`  Security Audit: $${this.buildCosts.securityAudit.toLocaleString()}`);
    console.log(`  Maintenance (1yr): $${this.buildCosts.maintenance.toLocaleString()}`);
    console.log(`  SUBTOTAL: $${this.buildCosts.total.toLocaleString()}`);
    console.log('');

    console.log('BUILD - Opportunity Costs:');
    console.log(`  Delayed Revenue: $${this.opportunityCosts.delayedRevenue.toLocaleString()}`);
    console.log(`  Core Features Missed: $${this.opportunityCosts.coreFeaturesMissed.toLocaleString()}`);
    console.log(`  Competitive Loss: $${this.opportunityCosts.competitiveDisadvantage.toLocaleString()}`);
    console.log(`  SUBTOTAL: $${this.opportunityCosts.total.toLocaleString()}`);
    console.log('');

    console.log(`TOTAL ECONOMIC COST (BUILD): $${analysis.comparison.buildTotal.toLocaleString()}`);
    console.log('');

    console.log('BUY - Custos:');
    console.log(`  Subscription (1yr): $${this.buyCosts.subscriptionYearly.toLocaleString()}`);
    console.log(`  Integration: $${this.buyCosts.integration.toLocaleString()}`);
    console.log(`  Training: $${this.buyCosts.training.toLocaleString()}`);
    console.log(`  TOTAL: $${this.buyCosts.total.toLocaleString()}`);
    console.log('');

    console.log('=== RECOMMENDATION ===');
    console.log(`Decision: ${analysis.comparison.recommendation}`);
    console.log(`Savings: $${analysis.comparison.savings.toLocaleString()}`);
    console.log(`Build is ${analysis.comparison.roiMultiple}x more expensive than Buy`);
    console.log('');
  }
}

// Caso 1: Sistema de Autenticação
const authAnalysis = new OpportunityCostAnalyzer('Authentication System');

authAnalysis.setBuildCosts({
  developers: 2,
  monthsToBuild: 3,
  salaryPerMonth: 10000,
  infrastructureCost: 8000,
  securityAudit: 25000,
  maintenanceYearly: 40000
});

authAnalysis.setBuyCosts({
  subscriptionYearly: 24000, // Auth0 ~$2k/month
  integrationCost: 8000,
  trainingCost: 3000
});

authAnalysis.calculateOpportunityCosts({
  monthsDelay: 3,
  monthlyRevenueProjection: 50000,
  coreFeaturesMissed: 5,
  revenuePerFeature: 20000,
  marketShareLost: 0.05,
  ltv: 800
});

authAnalysis.printReport();

/* Output esperado:
=== ANÁLISE BUILD VS BUY: AUTHENTICATION SYSTEM ===

BUILD - Custos Explícitos:
  Developer Time: $60,000
  Infrastructure: $8,000
  Security Audit: $25,000
  Maintenance (1yr): $40,000
  SUBTOTAL: $136,000

BUILD - Opportunity Costs:
  Delayed Revenue: $150,000
  Core Features Missed: $100,000
  Competitive Loss: $40
  SUBTOTAL: $250,040

TOTAL ECONOMIC COST (BUILD): $386,040

BUY - Custos:
  Subscription (1yr): $24,000
  Integration: $8,000
  Training: $3,000
  TOTAL: $35,000

=== RECOMMENDATION ===
Decision: BUY
Savings: $351,040
Build is 11.03x more expensive than Buy
*/

// Isocost Optimization: Build vs Buy Sweet Spot
class IsocostOptimizer {
  constructor(wage, capitalRate) {
    this.W = wage;           // Custo por hora de dev ($100/hr)
    this.R = capitalRate;    // Custo mensal de ferramentas ($50/mo)
  }

  // Calcular combinações na linha de isocost
  getIsocostCombinations(totalBudget) {
    const combinations = [];

    // Isocost: C = W*L + R*K
    // Resolver para L: L = (C - R*K) / W

    for (let K = 0; K <= totalBudget / this.R; K += 5) {
      const L = (totalBudget - this.R * K) / this.W;

      if (L >= 0) {
        combinations.push({
          laborHours: Math.round(L),
          capitalBudget: K,
          totalCost: totalBudget,
          slope: -this.W / this.R
        });
      }
    }

    return combinations;
  }

  // Função de produção: Q = f(L, K)
  // Assumindo Cobb-Douglas: Q = A * L^α * K^β
  productionFunction(L, K, A = 1, alpha = 0.6, beta = 0.4) {
    return A * Math.pow(L, alpha) * Math.pow(K, beta);
  }

  // Produtividade marginal do labor
  marginalProductLabor(L, K, A = 1, alpha = 0.6, beta = 0.4) {
    // MPL = ∂Q/∂L = α * A * L^(α-1) * K^β
    return alpha * A * Math.pow(L, alpha - 1) * Math.pow(K, beta);
  }

  // Produtividade marginal do capital
  marginalProductCapital(L, K, A = 1, alpha = 0.6, beta = 0.4) {
    // MPK = ∂Q/∂K = β * A * L^α * K^(β-1)
    return beta * A * Math.pow(L, alpha) * Math.pow(K, beta - 1);
  }

  // Encontrar combinação ótima (tangência)
  findOptimalCombination(targetOutput) {
    // Procurar combinação onde:
    // 1. Produz o output desejado
    // 2. Minimiza custos (tangency: MPL/MPK = W/R)

    let optimalCombo = null;
    let minCost = Infinity;

    // Grid search
    for (let L = 1; L <= 500; L += 5) {
      for (let K = 1; K <= 500; K += 5) {
        const output = this.productionFunction(L, K);

        // Se produz aproximadamente o output target
        if (Math.abs(output - targetOutput) < targetOutput * 0.05) {
          const cost = this.W * L + this.R * K;
          const mpl = this.marginalProductLabor(L, K);
          const mpk = this.marginalProductCapital(L, K);
          const tangencyRatio = (mpl / mpk) / (this.W / this.R);

          // Procurar tangência (ratio próximo de 1)
          if (Math.abs(tangencyRatio - 1) < 0.1 && cost < minCost) {
            minCost = cost;
            optimalCombo = {
              laborHours: L,
              capitalBudget: K,
              totalCost: cost,
              output: output,
              mpl: mpl.toFixed(2),
              mpk: mpk.toFixed(2),
              tangencyRatio: tangencyRatio.toFixed(2)
            };
          }
        }
      }
    }

    return optimalCombo;
  }

  // Análise de sensibilidade
  sensitivityAnalysis(targetOutput) {
    console.log('=== ISOCOST SENSITIVITY ANALYSIS ===');
    console.log(`Target Output: ${targetOutput} features`);
    console.log(`Wage (W): $${this.W}/hr | Capital Rate (R): $${this.R}/mo`);
    console.log('');

    // Cenário 1: All build (K=0)
    const allBuildL = Math.pow(targetOutput, 1/0.6); // L^0.6 = targetOutput
    const allBuildCost = this.W * allBuildL;
    console.log('CENÁRIO 1: All Build (K=0)');
    console.log(`  Labor Hours: ${Math.round(allBuildL)}`);
    console.log(`  Total Cost: $${Math.round(allBuildCost).toLocaleString()}`);
    console.log('');

    // Cenário 2: All buy (L=minimal)
    const allBuyK = Math.pow(targetOutput / Math.pow(1, 0.6), 1/0.4);
    const allBuyCost = this.W * 1 + this.R * allBuyK;
    console.log('CENÁRIO 2: Mostly Buy (L=1)');
    console.log(`  Capital Budget: $${Math.round(allBuyK)}`);
    console.log(`  Total Cost: $${Math.round(allBuyCost).toLocaleString()}`);
    console.log('');

    // Cenário 3: Optimal (tangency)
    const optimal = this.findOptimalCombination(targetOutput);
    if (optimal) {
      console.log('CENÁRIO 3: Optimal Mix (Tangency)');
      console.log(`  Labor Hours: ${optimal.laborHours}`);
      console.log(`  Capital Budget: $${optimal.capitalBudget}`);
      console.log(`  Total Cost: $${Math.round(optimal.totalCost).toLocaleString()}`);
      console.log(`  MPL/MPK ratio: ${optimal.mpl}/${optimal.mpk} = ${(parseFloat(optimal.mpl)/parseFloat(optimal.mpk)).toFixed(2)}`);
      console.log(`  W/R ratio: ${this.W}/${this.R} = ${(this.W/this.R).toFixed(2)}`);
      console.log(`  Tangency achieved: ${optimal.tangencyRatio}x`);
      console.log('');

      console.log('SAVINGS vs All Build: $' +
        (allBuildCost - optimal.totalCost).toLocaleString());
      console.log('SAVINGS vs All Buy: $' +
        (allBuyCost - optimal.totalCost).toLocaleString());
    } else {
      console.log('CENÁRIO 3: Nenhuma combinação ótima encontrada');
    }
  }
}

// Exemplo: Construir plataforma de analytics
const optimizer = new IsocostOptimizer(
  100,  // $100/hr for senior dev
  50    // $50/mo for analytics tools (Mixpanel, Amplitude, etc)
);

// Queremos construir analytics com output target = 50 features
optimizer.sensitivityAnalysis(50);

/* Output típico:
=== ISOCOST SENSITIVITY ANALYSIS ===
Target Output: 50 features
Wage (W): $100/hr | Capital Rate (R): $50/mo

CENÁRIO 1: All Build (K=0)
  Labor Hours: 305
  Total Cost: $30,500

CENÁRIO 2: Mostly Buy (L=1)
  Capital Budget: $1562
  Total Cost: $78,200

CENÁRIO 3: Optimal Mix (Tangency)
  Labor Hours: 120
  Capital Budget: $180
  Total Cost: $21,000
  MPL/MPK ratio: 0.42/0.28 = 1.50
  W/R ratio: 100/50 = 2.00
  Tangency achieved: 0.75x

SAVINGS vs All Build: $9,500
SAVINGS vs All Buy: $57,200

Insight: Mix ótimo economiza 31% vs all-build e 73% vs all-buy!
*/