Os custos que ninguém coloca na conta
Toda empresa com software de mais de três anos tem código legado. Isso é normal. O que não é normal é como os verdadeiros custos desse código são sistematicamente subestimados.
Os custos óbvios – tempos de desenvolvimento mais longos, mais bugs, onboarding trabalhoso – são conhecidos. Mas as consequências realmente caras do código legado são aquelas que nunca aparecem em um ticket do Jira.
Os custos visíveis
Vamos começar pelo que é mensurável:
Velocidade de desenvolvimento: Features que levam dois dias em uma codebase moderna levam duas semanas em sistemas legados. Não porque os desenvolvedores são mais lentos, mas porque cada mudança tem efeitos colaterais que precisam ser compreendidos e protegidos.
Taxa de bugs: Código legado tipicamente tem uma taxa de bugs 3–5x maior que código moderno. Não porque foi mal escrito, mas porque cresceu ao longo dos anos sem que a arquitetura acompanhasse.
Testabilidade: Código antigo frequentemente foi escrito sem testes. Adicionar testes retroativamente é possível, mas caro – e sem testes, cada mudança é um voo às cegas.
Documentação: Quanto mais antigo o código, mais provável é que as pessoas que o escreveram não estejam mais na empresa. O conhecimento vive no código – e às vezes em mais ninguém.
Os custos invisíveis
Aqui é onde fica caro:
Fuga de talentos: Bons desenvolvedores querem trabalhar com tecnologias modernas. Um time que gasta 80% do seu tempo mantendo sistemas legados rodando perde suas melhores pessoas. E os substitutos custam mais e precisam de meses para se familiarizar com o código antigo.
Custo de oportunidade: Cada hora que um desenvolvedor gasta com manutenção de legado é uma hora que não é investida em novas features, novos produtos ou novos mercados. Essa é a linha mais cara da conta – e nunca aparece explicitamente.
Riscos de segurança: Frameworks e bibliotecas antigas eventualmente param de receber atualizações de segurança. As vulnerabilidades permanecem abertas porque uma atualização quebraria metade da aplicação. Isso não é um risco hipotético – é o estado padrão de sistemas legados.
Capacidade de integração: APIs modernas, webhooks, serviços de IA – sistemas legados frequentemente não conseguem se conectar a tecnologias atuais, ou só conseguem com esforço massivo. Isso significa que a empresa perde oportunidades que concorrentes com sistemas modernos aproveitam.
A armadilha psicológica
Código legado sobrevive não apesar de seus custos, mas por causa de uma armadilha psicológica: a falácia do custo afundado.
"Investimos dez anos neste sistema" não é argumento para investir mais dez. Mas é exatamente assim que a maioria das organizações pensa. O investimento do passado é usado como justificativa para gastos futuros – mesmo sendo irrelevante.
Some-se a isso o medo do grande rewrite. "Se reescrevermos o sistema, vai levar dois anos e custar um milhão." Pode ser verdade – mas a alternativa é gastar R$ 1,5 milhão adicionais por ano em manutenção e mesmo assim ficar mais lento.
O que a conta realmente mostra
Uma empresa de médio porte com um sistema legado tipicamente se depara com o seguinte:
Custos diretos de manutenção: 2–3 desenvolvedores mantendo principalmente o sistema antigo. R$ 500.000–800.000 por ano.
Perda de produtividade: Features levam 3x mais tempo. Para um time de 8 desenvolvedores, isso equivale à perda de output de 5 desenvolvedores. Difícil de quantificar, mas real.
Custos de talento: Salários mais altos necessários para atrair desenvolvedores para trabalho com legado. Turnover mais alto. Onboarding mais longo. R$ 150.000–300.000 em custos adicionais por ano.
Oportunidades perdidas: Não quantificável, mas frequentemente o maior item. A feature que não foi construída. O mercado que não foi explorado. A integração que não foi possível.
O caminho pragmático para fora
Um rewrite big-bang raramente é a resposta. É arriscado, caro e fracassa mais vezes do que tem sucesso. Uma abordagem incremental funciona melhor:
Strangler fig pattern: Novas features são construídas em uma arquitetura moderna. O código antigo é substituído pedaço por pedaço por novas implementações. O sistema permanece funcional o tempo todo.
Introduzir uma camada de API: Uma API limpa entre o sistema legado e o mundo exterior cria uma abstração que permite modernização gradual sem precisar mexer em tudo de uma vez.
Caminhos críticos primeiro: Nem tudo precisa ser modernizado. O painel administrativo usado por três funcionários pode continuar legado. O checkout voltado ao cliente que processa milhares de transações diariamente, não.
IA como acelerador: Ferramentas como o Claude Code podem analisar, documentar e refatorar incrementalmente código legado. O que antes exigia meses de trabalho manual agora pode ser realizado significativamente mais rápido.
O que isso significa para tomadores de decisão
Código legado não é uma decisão técnica – é uma decisão de negócio. A pergunta não é "devemos manter o código antigo?", mas "quanto nos custa mantê-lo – e o que faríamos com os recursos liberados?"
Na nh labs, ajudamos empresas a fazer exatamente esse cálculo. O resultado frequentemente surpreende: a modernização se paga mais rápido do que o esperado – não porque é barata, mas porque o custo do status quo é maior do que se imagina.
Conclusão
Código legado é como uma hipoteca com taxa de juros crescente. Quanto mais você espera, mais caro fica. As empresas que investem em modernização incremental hoje serão mais rápidas, mais seguras e mais atraentes para talentos em dois anos. As que esperarem vão descobrir que sua dívida técnica cobra não apenas juros, mas juros compostos.