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
Na aula anterior, vimos que competição perfeita com entrada e saída livre leva a uma predição surpreendente:
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?
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.
A predição de π = 0 é baseada em assunções heroicas. No mundo real, há barreiras à entrada que permitem lucros sustentáveis.
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
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.
*/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
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!
*/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:
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.
SaaS tem barreiras técnicas baixas (é "fácil" lançar um app web), mas pode ter barreiras competitivas altíssimas.
Valor do produto cresce com usuários. Cria lock-in natural.
Exemplos:
Defesa: Newcomers precisam convencer toda a rede a migrar simultaneamente.
Custo (tempo, dinheiro, risco) de migrar para alternativa.
Exemplos:
Defesa: Cliente avalia custo de migração vs benefício do concorrente.
Custo médio cai com volume. Incumbente tem vantagem estrutural.
Exemplos:
Defesa: Newcomer não consegue competir em preço até atingir escala equivalente.
Produto melhora com dados. Quanto mais uso, melhor fica.
Exemplos:
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!
*/Framework clássico de Michael Porter para analisar atratividade de um mercado. Quanto mais fortes as forças, menor a lucratividade potencial.
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)
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)
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)
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)
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
Insight: Network effects sozinhos não bastam. Microsoft usou bundling (outra barreira) para contornar.
O modelo assume que firmas maximizam π. Mas e se gestores têm incentivos diferentes dos proprietários?
Separação de controle e propriedade: Corporações são possuídas por acionistas, mas geridas por CEOs.
Exemplo MIT: Private Jet
Conclusão: Maximização de lucros é um modelo útil, mas não perfeito. Agency problems são reais e custosos.
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.
É 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.
Network effects, switching costs, dados proprietários: esses fossos levam anos para construir. Começe cedo. Cada feature deve perguntar: "isso aumenta switching costs?"
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).
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.
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.