🚀 Oferta especial: 60% OFF no CrazyStack - Últimas vagas!Garantir vaga →
Voltar ao Curso
Módulo 4
Aula 14
45 min

Barreiras à Entrada

Por que lucros de longo prazo podem existir: custos irrecuperáveis, network effects e switching costs.

📹 MIT OpenCourseWare - Lecture 8: Competition in the Long Run

O Paradoxo dos Lucros Zero

Na aula anterior, vimos que competição perfeita com entrada e saída livre leva a uma predição surpreendente:

Teoria: Lucros de Longo Prazo = Zero

Por quê? Se π > 0, novas firmas entram → oferta aumenta → preço cai → π → 0.

Resultado: P = MC = AC (no mínimo de AC). Cada firma produz em eficiência máxima.

Entry happens → Profits → 0
Exit happens → Profits → 0
Long-run equilibrium: π = 0

Problema: Na realidade, empresas como Apple, Microsoft, Salesforce fazem bilhões em lucros há décadas. Como isso é possível?

Exemplo MIT: PCs vs Mainframes (1990)

💻 Mercado de PCs

  • • Dell, Gateway, Compaq entrando
  • • Entrada livre → lucros altos atraem competidores
  • • Curva de oferta se flatten → preços caem
  • • π → 0 no longo prazo

🖥️ Mainframes (IBM, DEC)

  • • Demanda caindo → π < 0
  • • DEC fechou (founder falou na graduação do MIT 1987)
  • • IBM sobreviveu pivotando
  • • Saída acontece quando π < 0

Ken Olson (DEC): Deu discurso de formatura no MIT em 1987 falando como a DEC era incrível. 5 anos depois, fora de negócio. Lição: mercados são implacáveis.

3 Razões para Lucros de Longo Prazo

A predição de π = 0 é baseada em assunções heroicas. No mundo real, há barreiras à entrada que permitem lucros sustentáveis.

Razão 1: Custos Irrecuperáveis (Sunk Costs)

Sunk costs são custos que você paga para entrar, mas não recupera se sair. Eles criam uma barreira à entrada.

Exemplo MIT: Médico

  • • Custo de escola de medicina: $300,000
  • • Se lucros como médico são pequenos, você não paga os $300k
  • • Logo, lucros podem ser positivos, mas não enormes
  • • Entrada só acontece se π > sunk cost amortizado

Em SaaS: Custos iniciais de desenvolvimento, marca, GTM são sunk costs. Se não tem certeza de sucesso, você não entra.

// Modelo de entrada com sunk cost
class EntryDecision {
  constructor(marketPrice, averageCost, sunkCost, discountRate) {
    this.P = marketPrice;
    this.AC = averageCost;
    this.K = sunkCost;  // Custo irrecuperável
    this.r = discountRate;  // Taxa de desconto
  }

  // NPV (Net Present Value) de entrar no mercado
  npvOfEntry(years) {
    // Lucro por ano = (P - AC) * Q
    // Assumindo Q = 100 unidades por simplicidade
    const Q = 100;
    const annualProfit = (this.P - this.AC) * Q;

    // NPV = Σ(profit_t / (1+r)^t) - K
    let npv = -this.K;  // Pago logo no início
    for (let t = 1; t <= years; t++) {
      npv += annualProfit / Math.pow(1 + this.r, t);
    }
    return npv;
  }

  // Decisão: entrar se NPV > 0
  shouldEnter(years) {
    const npv = this.npvOfEntry(years);
    return npv > 0;
  }

  // Lucro mínimo necessário para justificar entrada
  minimumProfitToEnter(years) {
    // Resolver: NPV = 0
    // K = Σ(profit_t / (1+r)^t)
    // profit anual mínimo = K * r / (1 - (1+r)^-years)

    const annuity_factor = (1 - Math.pow(1 + this.r, -years)) / this.r;
    return this.K / annuity_factor;
  }
}

// Exemplo: Entrar no mercado SaaS
const saasEntry = new EntryDecision(
  100,    // Preço de mercado = $100/mês
  30,     // Custo médio = $30/mês (após escala)
  500000, // Sunk cost = $500k (dev + marca + GTM)
  0.10    // Taxa de desconto = 10%
);

console.log('=== ENTRY DECISION ANALYSIS ===');
console.log(`NPV (5 years): $${saasEntry.npvOfEntry(5).toFixed(0)}`);
console.log(`Should enter? ${saasEntry.shouldEnter(5) ? 'YES' : 'NO'}`);

const minProfit = saasEntry.minimumProfitToEnter(5);
console.log(`\nMinimum annual profit to justify entry: $${minProfit.toFixed(0)}`);

// Implicação: lucros podem existir no longo prazo
// até o ponto em que não compensam pagar o sunk cost
const currentAnnualProfit = (100 - 30) * 100;
console.log(`Current annual profit: $${currentAnnualProfit}`);
console.log(`Barrier height: $${(minProfit / currentAnnualProfit * 100).toFixed(1)}% of current profit`);

/*
OUTPUT:
=== ENTRY DECISION ANALYSIS ===
NPV (5 years): $76,410
Should enter? YES

Minimum annual profit to justify entry: $131,899
Current annual profit: $7000
Barrier height: 1884.3% of current profit

CONCLUSÃO: Com sunk costs, há uma "zona de conforto" onde
incumbentes fazem lucro, mas não o suficiente para justificar entrada.
*/
Razão 2: Firmas Não Idênticas (Eficiência Diferencial)

Se firmas têm custos diferentes, as mais eficientes podem lucrar mesmo quando o mercado está em equilíbrio.

Exemplo MIT: Mercado de Algodão

🇵🇰 Paquistão:$0.71/kg
🇦🇷 Argentina:$1.08/kg
🇦🇺 Austrália:$1.15/kg
🇺🇸 Estados Unidos:$1.56/kg

Demanda: 1 bilhão kg/ano

  • • Apenas Paquistão produz
  • • Preço de mercado: $0.71/kg
  • • Lucro do Paquistão: zero

Demanda: 5 bilhões kg/ano

  • • Todos produzem (até EUA)
  • • Preço de mercado: $1.56/kg
  • • Lucro do Paquistão: $0.85/kg!

Insight: Se demanda é alta o suficiente para acionar firmas menos eficientes, as firmas mais eficientes fazem lucro. O preço é determinado pelo custo marginal da firma marginal.

// Modelo de firmas heterogêneas
class HeterogeneousMarket {
  constructor(firms) {
    // firms = [{name: 'Pakistan', mc: 0.71, capacity: 2}, ...]
    this.firms = firms.sort((a, b) => a.mc - b.mc);  // Ordenar por custo
  }

  // Curva de oferta agregada
  aggregateSupply() {
    let cumulative_q = 0;
    const supply = [];

    for (const firm of this.firms) {
      supply.push({
        price: firm.mc,
        quantity_from: cumulative_q,
        quantity_to: cumulative_q + firm.capacity,
        firm: firm.name
      });
      cumulative_q += firm.capacity;
    }

    return supply;
  }

  // Equilíbrio: dado demanda, encontrar P* e lucros
  equilibrium(demandQuantity) {
    let cumulative_q = 0;
    let marginalFirm = null;

    // Encontrar a firma marginal (última a produzir)
    for (const firm of this.firms) {
      if (cumulative_q + firm.capacity >= demandQuantity) {
        marginalFirm = firm;
        break;
      }
      cumulative_q += firm.capacity;
    }

    if (!marginalFirm) {
      return { error: 'Demand exceeds total capacity' };
    }

    // Preço = custo marginal da firma marginal
    const P_star = marginalFirm.mc;

    // Calcular lucros de cada firma
    const profits = this.firms.map(firm => {
      const q_produced = Math.min(firm.capacity, demandQuantity -
        this.firms.filter(f => f.mc < firm.mc)
          .reduce((sum, f) => sum + f.capacity, 0)
      );

      if (q_produced <= 0) return { firm: firm.name, profit: 0, producing: false };

      const profit = (P_star - firm.mc) * q_produced;
      return {
        firm: firm.name,
        mc: firm.mc,
        quantity: q_produced,
        profit: profit,
        producing: true
      };
    }).filter(p => p.producing);

    return { price: P_star, marginalFirm: marginalFirm.name, profits };
  }
}

// Exemplo: Mercado de algodão
const cottonMarket = new HeterogeneousMarket([
  { name: 'Pakistan', mc: 0.71, capacity: 1.7 },      // bilhões kg
  { name: 'Argentina', mc: 1.08, capacity: 1.2 },
  { name: 'Australia', mc: 1.15, capacity: 1.0 },
  { name: 'USA', mc: 1.56, capacity: 2.0 },
]);

console.log('=== HETEROGENEOUS MARKET ANALYSIS ===\n');

// Cenário 1: Demanda baixa
const eq1 = cottonMarket.equilibrium(1.0);
console.log('SCENARIO 1: Demand = 1.0 billion kg');
console.log(`Market Price: $${eq1.price.toFixed(2)}/kg`);
console.log(`Marginal Firm: ${eq1.marginalFirm}`);
console.log('Profits:');
eq1.profits.forEach(p => {
  console.log(`  ${p.firm}: $${p.profit.toFixed(2)}B (MC: $${p.mc}, Q: ${p.quantity}B)`);
});

// Cenário 2: Demanda alta
console.log('\nSCENARIO 2: Demand = 5.0 billion kg');
const eq2 = cottonMarket.equilibrium(5.0);
console.log(`Market Price: $${eq2.price.toFixed(2)}/kg`);
console.log(`Marginal Firm: ${eq2.marginalFirm}`);
console.log('Profits:');
eq2.profits.forEach(p => {
  console.log(`  ${p.firm}: $${p.profit.toFixed(2)}B (MC: $${p.mc}, Q: ${p.quantity}B)`);
});

/*
OUTPUT:
=== HETEROGENEOUS MARKET ANALYSIS ===

SCENARIO 1: Demand = 1.0 billion kg
Market Price: $0.71/kg
Marginal Firm: Pakistan
Profits:
  Pakistan: $0.00B (MC: 0.71, Q: 1.0B)

SCENARIO 2: Demand = 5.0 billion kg
Market Price: $1.56/kg
Marginal Firm: USA
Profits:
  Pakistan: $1.45B (MC: 0.71, Q: 1.7B)
  Argentina: $0.58B (MC: 1.08, Q: 1.2B)
  Australia: $0.41B (MC: 1.15, Q: 1.0B)
  USA: $0.00B (MC: 1.56, Q: 1.1B)

LESSON: Firmas mais eficientes fazem lucro quando demanda é alta!
*/
Razão 3: Preços de Input Dependem da Quantidade

Mesmo com π = 0, a curva de oferta pode ser upward-sloping se os preços de inputs (ex: salários) aumentam com a quantidade produzida.

Lógica:

  • 1. Demanda por produto aumenta → empresas querem produzir mais
  • 2. Para produzir mais, precisam contratar mais trabalhadores
  • 3. Curva de oferta de trabalho é upward-sloping → salários sobem
  • 4. Salários maiores → custos marginais maiores → P tem que subir
  • 5. Logo, mesmo com π = 0, P aumenta com Q (curva de oferta upward-sloping)

Importante: Isso NÃO explica lucros de longo prazo. Lucros continuam zero. Mas explica por que a curva de oferta não é flat mesmo no longo prazo.

Em SaaS: Quando você cresce, precisa contratar mais engenheiros. Mas o mercado de engenheiros tem oferta limitada. Você acaba pagando mais (stock options, benefits, etc). Isso aumenta seu AC e MC, mesmo mantendo π = 0.

Fossos Econômicos em SaaS

SaaS tem barreiras técnicas baixas (é "fácil" lançar um app web), mas pode ter barreiras competitivas altíssimas.

Network Effects

Valor do produto cresce com usuários. Cria lock-in natural.

Exemplos:

  • • Slack: quanto mais pessoas no workspace, maior o valor
  • • Zoom: precisa que todo mundo tenha
  • • Notion: templates compartilhados

Defesa: Newcomers precisam convencer toda a rede a migrar simultaneamente.

Switching Costs

Custo (tempo, dinheiro, risco) de migrar para alternativa.

Exemplos:

  • • Salesforce: dados + workflows + integrações
  • • AWS: infraestrutura inteira
  • • Adobe: anos de arquivos .psd

Defesa: Cliente avalia custo de migração vs benefício do concorrente.

Economias de Escala

Custo médio cai com volume. Incumbente tem vantagem estrutural.

Exemplos:

  • • Netflix: conteúdo fixo / milhões de usuários
  • • Stripe: compliance cost / volume processado
  • • GitHub: infra / repos hospedados

Defesa: Newcomer não consegue competir em preço até atingir escala equivalente.

Dados & IA

Produto melhora com dados. Quanto mais uso, melhor fica.

Exemplos:

  • • Google Search: queries melhoram algoritmo
  • • Grammarly: correções treinam modelo
  • • Spotify: playlists personalizadas

Defesa: Newcomer começa com produto inferior por falta de dados históricos.

// Modelo de Network Effects
class NetworkEffectsProduct {
  constructor(base_value, network_coefficient) {
    this.V0 = base_value;  // Valor base do produto
    this.k = network_coefficient;  // Coeficiente de rede
    this.users = 0;
  }

  // Valor para cada usuário: V(n) = V0 + k*n
  valuePerUser(totalUsers) {
    return this.V0 + this.k * totalUsers;
  }

  // Valor total da rede: Σ V(i) para i=1 até n
  totalNetworkValue() {
    // ≈ n*V0 + k*n*(n-1)/2 (soma aritmética)
    return this.users * this.V0 +
           this.k * this.users * (this.users - 1) / 2;
  }

  // Adicionar usuário
  addUser() {
    this.users++;
    return this.valuePerUser(this.users);
  }

  // Perder usuário (churn)
  loseUser() {
    if (this.users > 0) {
      this.users--;
    }
    return this.valuePerUser(this.users);
  }
}

// Exemplo: Slack vs Newcomer
const slack = new NetworkEffectsProduct(10, 0.5);  // V0=10, k=0.5
const newcomer = new NetworkEffectsProduct(12, 0.5);  // Melhor produto base!

// Slack tem 1000 usuários, newcomer tem 0
for (let i = 0; i < 1000; i++) {
  slack.addUser();
}

console.log('=== NETWORK EFFECTS BARRIER ===\n');
console.log('SLACK (incumbent):');
console.log(`  Users: ${slack.users}`);
console.log(`  Value per user: $${slack.valuePerUser(slack.users).toFixed(2)}`);
console.log(`  Total network value: $${slack.totalNetworkValue().toFixed(0)}`);

console.log('\nNEWCOMER (better product, but no network):');
console.log(`  Users: ${newcomer.users}`);
console.log(`  Value per user: $${newcomer.valuePerUser(newcomer.users).toFixed(2)}`);
console.log(`  Total network value: $${newcomer.totalNetworkValue().toFixed(0)}`);

// Switching decision: usuário compara valores
console.log('\n=== SWITCHING ANALYSIS ===');
const slack_value = slack.valuePerUser(slack.users);
const newcomer_value_if_switch = newcomer.valuePerUser(1);  // Primeiro usuário
const switching_cost = 20;  // Custo de migrar dados, treinar time, etc

console.log(`Value if stay on Slack: $${slack_value.toFixed(2)}`);
console.log(`Value if switch to Newcomer: $${newcomer_value_if_switch.toFixed(2)}`);
console.log(`Switching cost: $${switching_cost}`);

const net_benefit_of_switching = newcomer_value_if_switch - slack_value - switching_cost;
console.log(`\nNet benefit of switching: $${net_benefit_of_switching.toFixed(2)}`);
console.log(`Decision: ${net_benefit_of_switching > 0 ? 'SWITCH' : 'STAY ON SLACK'}`);

/*
OUTPUT:
=== NETWORK EFFECTS BARRIER ===

SLACK (incumbent):
  Users: 1000
  Value per user: $510.00
  Total network value: $259,950

NEWCOMER (better product, but no network):
  Users: 0
  Value per user: $12.00
  Total network value: $0

=== SWITCHING ANALYSIS ===
Value if stay on Slack: $510.00
Value if switch to Newcomer: $12.00
Switching cost: $20
Net benefit of switching: $-518.00
Decision: STAY ON SLACK

LESSON: Mesmo com produto 20% melhor (V0=12 vs 10),
o newcomer não consegue competir contra network effects!
*/

5 Forças de Porter em SaaS

Framework clássico de Michael Porter para analisar atratividade de um mercado. Quanto mais fortes as forças, menor a lucratividade potencial.

1️⃣ Ameaça de Novos Entrantes

Em SaaS: Tecnicamente fácil (AWS + GitHub + Vercel). Mas competitivamente difícil (network effects, marca, dados).

Alta ameaça: CRM genérico, todo list apps, formulários

Baixa ameaça: Salesforce (dados + integrações), Figma (network effects), Stripe (compliance + integrations)

2️⃣ Poder de Barganha dos Clientes

Em SaaS: Depende de switching costs e diferenciação. PLG (product-led growth) dá mais poder ao cliente.

Alto poder: Commoditized SaaS (hosting, email), fácil testar alternativas

Baixo poder: Mission-critical + switching costs altos (ERP, core banking)

3️⃣ Poder de Barganha dos Fornecedores

Em SaaS: Cloud providers (AWS, GCP), payment processors, APIs críticas.

Alto poder: Stripe (único provider com compliance), OpenAI API (sem alternativa equivalente)

Baixo poder: Cloud providers (multi-cloud possível), databases (muitas opções)

4️⃣ Ameaça de Substitutos

Em SaaS: Não é só competidores diretos. É qualquer solução alternativa (spreadsheets, in-house, IA).

Alta ameaça: Project management (Excel funciona), simple CRM (Google Sheets), AI replacing tools

Baixa ameaça: Video conferencing (precisa ser software), payments (regulado)

5️⃣ Rivalidade Entre Concorrentes

Em SaaS: Intensidade da competição direta. Guerras de preço, feature parity races.

Alta rivalidade: Chat tools (Slack vs Teams vs Discord), no-code builders (Bubble vs Webflow vs Framer)

Baixa rivalidade: Nichos específicos, vertical SaaS, clear differentiation

🎯 Estratégia: Construir Fossos em Múltiplas Dimensões

  • Network effects: produto que melhora com mais usuários
  • Switching costs: integração profunda + dados críticos
  • Economias de escala: custo marginal decrescente
  • Marca/confiança: anos de track record em categoria crítica
  • Dados proprietários: produto melhora com histórico

Cases: SaaS com Fossos Profundos

☁️ Salesforce: O Rei do CRM
Barreiras:
  • • 20+ anos de dados de clientes
  • • 5,000+ integrações no AppExchange
  • • Workflows customizados complexos
  • • Switching cost estimado: $500k+ (enterprise)
Resultado:
  • • Market cap: $250B+ (2024)
  • • Operating margin: ~20%
  • • Lucros sustentáveis há 15+ anos
  • • Concorrentes não conseguem deslocar
🎨 Adobe: Creative Suite
Barreiras:
  • • Formato .psd é padrão da indústria
  • • Anos de arquivos e projetos
  • • Curva de aprendizado de décadas
  • • Network effects (compartilhar arquivos)
Resultado:
  • • Transição para SaaS: +300% revenue
  • • Churn mensal: <1% (incrivelmente baixo)
  • • Figma/Canva atacam nichos, não core
  • • Pricing power: aumentos anuais
💼 Microsoft 365: Ecosystem Lock-in
Barreiras:
  • • Bundle: Office + Teams + OneDrive + ...
  • • Active Directory integration (enterprise)
  • • Formatos .docx, .xlsx onipresentes
  • • Força de vendas enterprise decades
Resultado:
  • • 345M+ paid Office 365 seats
  • • Google Workspace não consegue deslocar
  • • Switching: requer mudança de toda org
  • • Lucros: Commercial Cloud $100B+ ARR
💬 Slack: Network Effects Case Study
Barreiras:
  • • Network effects: precisa que todos usem
  • • Historical messages = institutional memory
  • • Bots e integrações customizadas
  • • Cultural fit: "we use Slack"
Problema:
  • • Microsoft Teams: bundled "de graça"
  • • Enterprise escolhe Teams (TCO)
  • • Slack vendido para Salesforce $27B
  • • Lição: barreira não era suficiente

Insight: Network effects sozinhos não bastam. Microsoft usou bundling (outra barreira) para contornar.

Extra: Firmas Maximizam Lucros?

O modelo assume que firmas maximizam π. Mas e se gestores têm incentivos diferentes dos proprietários?

Principal-Agent Problem

Separação de controle e propriedade: Corporações são possuídas por acionistas, mas geridas por CEOs.

Exemplo MIT: Private Jet

  1. CEO quer jato privado (status)
  2. Não é econômico: primeira classe é mais barato
  3. CEO cozinha os números para justificar
  4. Board of directors não revisa a fundo (são amigos)
  5. Jato é aprovado → lucros não maximizados
Evidência:
  • • CEO compensation de empresas de petróleo sobe quando preço do petróleo sobe
  • • Mas CEO não controla preço do petróleo!
  • • Logo, não é por performance real
  • • (Bertrand & Mullainathan study)
Solução (tentada):
  • • Stock options: alinhar incentivos
  • • Problema: Enron, contabilidade criativa
  • • CEO infla preço no curto prazo
  • • Cash out antes do colapso

Conclusão: Maximização de lucros é um modelo útil, mas não perfeito. Agency problems são reais e custosos.

📚 Área de Pesquisa: Corporate Finance

Como desenhar contratos e estruturas de governança que alinhem incentivos de gestores e acionistas? Campo fascinante com implicações reais para bilhões de dólares.

Nobel Prize 2016: Bengt Holmström (MIT) por trabalho em contract theory e agency problems.

🎯 Lições Para Founders

✅ Barreiras técnicas baixas ≠ mercado fácil

É fácil lançar um SaaS. Mas construir uma empresa lucrativa de longo prazo requer fossos econômicos reais. Não confunda facilidade de deployment com facilidade de negócio.

✅ Construa defensibilidade desde o Dia 1

Network effects, switching costs, dados proprietários: esses fossos levam anos para construir. Começe cedo. Cada feature deve perguntar: "isso aumenta switching costs?"

✅ Sunk costs protegem, mas não para sempre

Se seus lucros são apenas por sunk costs (marca, dev inicial), você está vulnerável a alguém com bolso mais fundo. Combine com outras barreiras (network effects, dados).

✅ Bundling é uma estratégia poderosa

Microsoft venceu Slack via bundling (Teams "de graça" com Office). Apple vence via ecosystem. Se você não pode vencer em features, ganhe em conveniência.

⚠️ Cuidado com mercados comoditizados

Se não há barreiras, competição perfeita é real: π → 0. Hosting, email básico, simple CRMs são mercados difíceis. Ou você tem escala massiva, ou sofre.

Próxima aula

Discriminação de Preços