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:
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.
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.
*/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
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!
*/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.
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.
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.
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.
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.
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
🎯 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
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
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
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
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?
Separação de controle e propriedade: Corporações são possuídas por acionistas, mas geridas por CEOs.
Exemplo MIT: Private Jet
- CEO quer jato privado (status)
- Não é econômico: primeira classe é mais barato
- CEO cozinha os números para justificar
- Board of directors não revisa a fundo (são amigos)
- 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.