Seu código ruim funciona. Esse é o problema.
A arquitetura de software não prova seu valor na primeira entrega, mas em todas as mudanças que vêm depois.

Existe uma coisa perigosa sobre código ruim:
Ele funciona.
A funcionalidade pode ser entregue, os testes podem passar.
O sistema pode entrar em produção, o cliente pode usar e ficar satisfeito.
Se o código ruim simplesmente quebrasse no primeiro dia, seria fácil identificá-lo e corrigi-lo o problema é que ele consegue sobreviver por bastante tempo.
Às vezes, por anos, a conta aparece quando alguma coisa precisa mudar.
A primeira entrega mente no início de um projeto, quase qualquer arquitetura parece boa.
Existem poucas regras, poucas integrações poucos desenvolvedores.
A equipe ainda lembra por que cada decisão foi tomada, nesse momento, adicionar mais uma funcionalidade é relativamente simples. O sistema é pequeno o suficiente para caber na cabeça de quem o construiu.
A velocidade inicial cria uma sensação de que a arquitetura está funcionando.
Talvez esteja.
Ou talvez ainda não tenha sido testada pelo tempo, a arquitetura começa a revelar sua qualidade quando:
- uma regra muda;
- uma tecnologia precisa ser substituída;
- uma nova integração aparece;
- outra pessoa entra no projeto;
- uma funcionalidade antiga precisa ser testada isoladamente;
- o sistema precisa continuar evoluindo sem quebrar o que já existe.
É aí que percebemos se construímos um sistema ou apenas acumulamos código que funciona.
De MongoDB para PostgreSQL
Vivi uma situação em produção que materializou essa diferença.
O sistema utilizava MongoDB como mecanismo de persistência.
Com a evolução do produto, começaram a aparecer necessidades cada vez mais relacionais. As consultas exigiam relações e comportamentos que faziam mais sentido em um banco relacional.
A decisão foi migrar do MongoDB para o PostgreSQL, não foi uma alteração pequena.
Precisávamos modelar os dados de outra forma, criar a nova estrutura, migrar as informações e adaptar a camada responsável pela persistência.
Havia trabalho real, arquitetura limpa não faz um banco de dados desaparecer para que outro surja magicamente no lugar.
O que ela fez foi impedir que a mudança do banco exigisse também uma reescrita das regras de negócio.
A aplicação precisava continuar respondendo às mesmas perguntas as regras continuavam válidas.
O produto não havia mudado de propósito apenas porque a tecnologia de persistência mudou.
Como as responsabilidades estavam separadas, conseguimos concentrar a troca na parte do sistema que realmente precisava mudar.
MongoDB saiu.
PostgreSQL entrou.
A regra de negócio permaneceu protegida, o banco não deveria mandar no negócio
É comum começarmos um sistema pelo banco de dados.
Criamos as tabelas ou coleções, depois construímos os serviços ao redor da estrutura escolhida, com o tempo, a forma de persistir passa a determinar a forma de pensar o próprio negócio.
A regra já não diz apenas o que precisa acontecer, ela começa a conhecer detalhes de consulta, estrutura de documento, framework e tecnologia.
O banco deixa de ser uma ferramenta usada pelo sistema, passa a ser o lugar onde o sistema inteiro está preso.
Enquanto nada muda, isso pode parecer eficiente, há menos abstrações, menos interfaces, menos arquivos.
A implementação inicial fica rápida, só que velocidade na primeira entrega não é a única medida de uma arquitetura.
Um banco de dados é uma decisão importante, mas continua sendo uma tecnologia.
A regra que calcula um valor, aprova uma operação ou define o comportamento do produto representa o motivo pelo qual o software existe.
Quando misturamos os dois, qualquer mudança de infraestrutura ameaça o centro do negócio.
O que significa estar desacoplado?
Desacoplamento não significa ausência de dependências.
Todo sistema depende de alguma coisa.
Precisávamos do MongoDB antes, passamos a precisar do PostgreSQL depois.
O ponto é definir a direção dessas dependências, a regra de negócio não deveria precisar conhecer detalhes do banco para existir.
Ela deveria trabalhar com contratos que expressem aquilo de que precisa:
- buscar determinada informação;
- salvar uma entidade;
- recuperar um conjunto de dados;
- verificar uma condição.
A implementação concreta desses contratos pode utilizar MongoDB, PostgreSQL ou outra tecnologia, trocar o banco ainda exige trabalho.
Mas o trabalho fica no limite do sistema, não espalhado dentro das regras centrais.
Essa é uma das ideias mais importantes da Clean Architecture.
Não se trata apenas de separar o projeto em pastas com nomes bonitos.
bTrata-se de proteger aquilo que muda por motivos de negócio daquilo que muda por motivos técnicos, código ruim cobra juros
Uma arquitetura deficiente raramente apresenta uma fatura única, ela cobra juros, a primeira funcionalidade leva um dia a segunda leva dois, depois, uma alteração aparentemente pequena exige tocar em cinco partes do sistema.
Os testes precisam subir banco, fila e serviços externos, ninguém sabe ao certo quais comportamentos podem quebrar, a equipe começa a adicionar condições dentro de condições porque alterar a estrutura parece mais perigoso que continuar remendando.
O código ainda funciona, esse é o problema.
Como continua funcionando, sempre existe uma justificativa para adiar a correção, temos uma entrega urgente, o cliente precisa da funcionalidade, na próxima sprint organizamos.
Depois criamos os testes, em algum momento, a equipe já não entrega devagar porque perdeu competência, entrega devagar porque cada mudança precisa atravessar todas as decisões que foram adiadas.
Código ruim não avisa que é ruim na primeira entrega. Ele cobra em cada mudança seguinte.
A arquitetura aparece na décima funcionalidade, uma estrutura improvisada pode ser mais rápida para entregar a primeira versão.
Às vezes, essa é inclusive a decisão correta, nem todo software precisa viver durante dez anos.
Nem todo projeto precisa suportar trocas de tecnologia, dezenas de integrações ou regras complexas de negócio, o problema é tratar a velocidade inicial como prova definitiva da qualidade da arquitetura.
A diferença aparece depois, em uma arquitetura saudável, o esforço necessário para mudar o sistema permanece relativamente controlado.
Em uma arquitetura ruim, cada funcionalidade aumenta o custo da próxima.
A primeira entrega gera confiança., a décima revela a dívida.
Por isso, arquitetura não deve ser avaliada apenas por quanto tempo levamos para colocar a primeira versão em produção.
Também precisamos observar:
- quanto custa alterar uma regra;
- quanto do sistema precisa ser conhecido para fazer uma mudança;
- quais partes conseguem ser testadas isoladamente;
- quanto medo uma pequena alteração gera;
- quanto conhecimento existe apenas na cabeça de uma pessoa.
Manutenibilidade é uma medida de velocidade ao longo do tempo.
Clean Architecture não é uma religião
Existe um erro no outro extremo.
Depois de aprender Clean Architecture, algumas equipes passam a aplicá-la como uma fórmula universal, criam camadas, interfaces, adaptadores e casos de uso para sistemas que talvez nunca precisem daquela estrutura.
Um CRUD simples ganha dezenas de arquivos, uma alteração pequena precisa atravessar abstrações que não protegem nenhuma complexidade real.
O código fica “limpo” no diagrama e cansativo para quem precisa trabalhar nele.
Arquitetura também possui custo.
A pergunta não é:
“Estamos seguindo todos os círculos corretamente?”
A pergunta é:
“Quais partes deste sistema precisam continuar independentes porque provavelmente mudarão em ritmos diferentes?”
Se existe uma regra de negócio importante que deve sobreviver a frameworks, bancos e interfaces, faz sentido protegê-la.
Se estamos construindo algo temporário, pequeno e com poucas chances de evolução, uma estrutura mais simples pode ser suficiente.
Uma arquitetura limpa não é aquela que possui mais camadas, é aquela na qual as fronteiras ajudam o sistema a mudar.
Sustentabilidade não aparece na demo o cliente raramente olha para uma demonstração e pergunta se as dependências apontam na direção correta.
Ele quer saber se o produto resolve o problema.
E está certo, eu defendo muito isso!
Arquitetura não deveria competir com o valor entregue.
Ela existe para permitir que esse valor continue sendo entregue depois, o desafio é que a sustentabilidade de um sistema quase sempre é invisível no começo.
Duas implementações podem produzir a mesma tela, podem responder à mesma requisição, podem executar no mesmo tempo.
Uma delas, porém, permite mudar a persistência sem reescrever as regras.
A outra espalha detalhes técnicos pelo produto inteiro para o usuário, elas parecem iguais hoje para a empresa, terão custos completamente diferentes amanhã.
A arquitetura não precisa prever tudo, quando adotamos uma estrutura mais limpa, não estamos afirmando que sabemos exatamente como o sistema mudará.
No nosso caso, ninguém precisava prever todos os detalhes da migração para PostgreSQL, precisávamos apenas reconhecer que o mecanismo de persistência não deveria possuir o negócio.
Essa fronteira preservou uma opção, quando as consultas relacionais começaram a justificar outra tecnologia, a troca era difícil, mas possível.
Essa é uma forma mais madura de pensar arquitetura, não tentar prever cada requisito futuro, construir limites claros ao redor das partes mais importantes para que o sistema consiga absorver mudanças que ainda não conhecemos.
Toda arquitetura é uma aposta, não sabemos exatamente o que mudará.
Mas podemos evitar que uma decisão técnica temporária se torne uma prisão permanente.
Seu código ruim funciona
Talvez o sistema esteja funcionando hoje, isso não encerra a discussão sobre qualidade.
A pergunta não é apenas se ele entrega.
É quanto custará continuar entregando.
Se cada mudança demora mais que a anterior, se os testes dependem de tudo e se trocar uma tecnologia ameaça as regras de negócio, o sistema está enviando um sinal.
A arquitetura deixou de sustentar o crescimento, foi isso que a migração de MongoDB para PostgreSQL reforçou para mim.
Clean Architecture não eliminou o trabalho.
Não tornou a mudança automática, não adivinhou qual banco usaríamos no futuro.
Ela fez algo mais útil:
Manteve a mudança técnica no lugar em que ela deveria acontecer.
O código ruim também consegue chegar à produção, a diferença é o que acontece quando a produção exige que ele mude.
E essa foi mais uma dobra de: construir software que continue mudando sem precisar esquecer por que existe.
Nos vemos na próxima quinta, às 10:10.
Escrevi anteriormente um artigo mais técnico e acadêmico sobre Clean Architecture, testabilidade e sustentabilidade de sistemas:
https://medium.com/@italocastro2010/arquitetura-limpa-impactos-na-manutenibilidade-testabilidade-e-sustentabilidade-de-sistemas-de-de14fe21521a (3/3)
Quer levar uma dessas conversas para o seu evento ou empresa?
Quer trocar uma ideia sobre engenharia, produto ou IA?
