Todos os episódios
Código, carreira e a dose certa de dopamina — um episódio de cada vez.
Como viver de freelancing e conquistar o mercado internacional
Exploro a transição para o trabalho remoto internacional, destacando desafios e estratégias para sucesso na carreira.
Como a Observabilidade Pode Redefinir Sua Plataforma
Exploramos como a observabilidade pode ser um divisor de águas na sua plataforma, transformando dados em insights e impacto real. Veja como aplicar práticas de observabilidade para alavancar o desempenho do seu time.
AI Agents: Seu Novo Par de Mãos no Código
Exploramos como agentes de IA podem ser verdadeiros parceiros na codificação, transformando sua carreira e rotina diária. Descubra como aumentar sua produtividade e eficiência ao integrar essas ferramentas no seu fluxo de trabalho.
Como Fazer seu Gateway de API Trabalhar para Você
Exploramos como um gateway de API bem configurado pode acelerar entregas e reduzir problemas em times de desenvolvimento de software. Descubra como aproveitar ao máximo essa ferramenta essencial.
Como a Curiosidade Me Fez um Líder Melhor
Exploro como a curiosidade moldou minha trajetória de liderança. Não é só sobre saber mais, mas sobre perguntar mais e ouvir melhor.
Como a IA Está Redefinindo o Trabalho e a Carreira em Tech
A inteligência artificial não está apenas transformando o modo como construímos sistemas, mas também redefinindo como pensamos sobre carreiras em tecnologia. Vamos explorar como essas mudanças sociais e tecnológicas impactam o seu futuro profissional.
Por que o Futuro do Platform Engineering é Sólido como Rocha
Exploro como as práticas de Platform Engineering estão se consolidando como essenciais para o sucesso em times de tecnologia, mesmo em tempos de transformação rápida e agentes de IA.
Rotinas que Transformam: O Poder do Pequeno Progresso
Como pequenas mudanças nas suas rotinas diárias podem criar um grande impacto na sua carreira ao longo do tempo. Descubra como implementar essas modificações pode ser mais fácil do que você imagina.
O que eu diria para o dev de 2013 — e o que ele me diria de volta
Treze anos de carreira em tech — do suporte de Oi em Camaquã ao Staff Engineer em empresa global. Uma carta honesta para o início do caminho, e o que o dev de 2013 provavelmente questionaria sobre onde chegamos.
Dois anos de empresa global: o que mudou, o que não mudou, o que eu não esperava
Dois anos trabalhando em empresa global de tecnologia — não como dev de produto, mas como Staff Platform Engineer. O que a escala muda, o que a distância cria, e o que só se aprende de dentro.
De ideia a 200 episódios: como o café com dopamina foi construído em paralelo com a carreira
Um site de conteúdo com 200+ episódios, 9 temporadas e 12 séries, construído nas margens do tempo de quem trabalha full-time. O que é a estrutura por baixo, as decisões que guiaram o projeto e o que ficou de aprendizado.
Construir em público sendo CLT em 2026: o que funcionou, o que não funcionou
Building in public é um conceito de quem tem tempo e liberdade de founder. Como engenheiro CLT com emprego full-time e família, a equação é diferente — e a versão que funciona tem nuances que ninguém conta.
Claude Code no trabalho de plataforma: o que mudou depois de 6 meses de uso real
Seis meses usando Claude Code como ferramenta diária de trabalho em platform engineering — não como curiosidade, mas como colaborador. O que mudou, o que permaneceu e onde ainda prefiro trabalhar sem ele.
As habilidades que realmente importam em 2026 — e as que ficaram para trás
O mercado de tech muda os critérios de valor mais rápido do que a maioria das pessoas percebe. Depois de anos acompanhando o que diferencia engenheiros que crescem dos que ficam parados, tenho uma visão clara do que importa agora.
O que 14 anos de experiência me ensinaram sobre IA no dia a dia
Exploro como a IA realmente impacta o trabalho do desenvolvedor e compartilho insights práticos de como integrar essas ferramentas no seu fluxo de trabalho diário para amplificar sua produtividade.
Criando Golden Paths para Integrações com APIs Externas
Como equipes de plataforma podem simplificar e padronizar integrações com APIs externas, reduzindo a complexidade e melhorando a experiência dos desenvolvedores.
Como Simplificar Autenticação em Arquiteturas Distribuídas
Exploramos estratégias para simplificar a autenticação em arquiteturas modernas e como uma abordagem de plataforma pode transformar a experiência do desenvolvedor.
Por que seu API Gateway pode estar te segurando
Quando a plataforma vira gargalo? Exploramos os desafios de escalar um API Gateway em arquiteturas cloud-native e como evitá-los.
Observabilidade: O Alicerce para Escalar com Confiança
Como times de plataforma podem usar observabilidade para habilitar escala e reduzir riscos em ecossistemas complexos de microsserviços.
Saúde mental: como sobreviver à avalanche de ferramentas de IA
Com a explosão de ferramentas de IA e agentes inteligentes, como os times de plataforma podem gerenciar a pressão sem comprometer a saúde mental?
Agentes de IA em 2026: o que funciona, o que não funciona, o que todo mundo finge que sabe
O hype de agentes de IA chegou antes da maturidade. Depois de usar agentes em produção por um ano, tenho uma visão mais honesta do que realmente funciona — e do que ainda é promessa com data incerta.
Saúde Mental em Tempos de Inovação Acelerada
Como equilibrar inovação e estabilidade sem comprometer a saúde mental dos times de plataforma.
Automação Inteligente: Construindo Pipelines que Fazem Sentido
Como criar pipelines de automação que realmente agreguem valor em um cenário onde o tempo é um recurso escasso e a complexidade aumenta continuamente.
Como a IA pode impulsionar (ou atrapalhar) sua produtividade
Ferramentas de IA estão em alta, mas será que elas realmente ajudam a produtividade de times de engenharia? Vamos explorar como separar o hype da realidade e construir um caminho dourado para IA na sua plataforma.
Carreira global em tech: o que ninguém te conta
Exploro os desafios e oportunidades de uma carreira internacional em tech, com insights para times de plataforma que precisam lidar com diversidade cultural e fusos horários.
Saúde Mental e a Pressão por Inovação nos Times de Plataforma
Como os times de plataforma podem equilibrar inovação e saúde mental em um cenário de rápida evolução tecnológica e alta demanda por resultados.
DevSecOps: Evoluindo para um mundo de agentes e automação
Como as práticas de DevSecOps estão se adaptando à era dos agentes de IA e automação em larga escala. Exploramos os desafios de segurança, governança e o papel das equipes de plataforma nesse novo cenário.
Golden Paths para IA: Reduzindo a Fragmentação nos Times
Como os golden paths podem ajudar a padronizar o uso de agentes de IA, reduzindo a complexidade e aumentando a produtividade dos times.
O novo burnout da era da IA: quando tudo é possível e nada fica pronto
Com IA, construir nunca foi tão rápido. Mas a velocidade de construção não resolve a velocidade de decisão — e a fadiga de escolha em um ambiente de possibilidade infinita tem um custo real na saúde mental.
Ferramentas LLM e Saúde Mental: Quando Menos é Mais
Como a sobrecarga de ferramentas LLM pode impactar a saúde mental dos times e o que times de plataforma podem fazer para evitar o burnout.
Golden Paths: Como Criar Abstrações que os Devs Amam
Criar um golden path que os desenvolvedores realmente queiram usar é um desafio de design, governança e empatia. Vamos explorar o que separa os caminhos de ouro que funcionam daqueles que ninguém segue.
Guardrails para LLM: Equilibrando Liberdade e Governança
Como líderes de plataforma podem criar guardrails eficazes para que times aproveitem o poder das ferramentas LLM sem gerar fragmentação ou riscos desnecessários.
Como a IA está moldando carreiras globais na engenharia de software
A IA não é só sobre tecnologia; é sobre como ela redefine a carreira de engenheiros em escala global. Vamos explorar as oportunidades e desafios dessa nova era.
Machine Learning Seguro em Arquiteturas de Microsserviços
Exploramos como integrar machine learning em microsserviços sem comprometer segurança e governança, garantindo escalabilidade e uma experiência consistente para desenvolvedores.
Obscura e o Futuro do Web Scraping com Agentes de IA
Nesta semana, exploramos como o Obscura está revolucionando o web scraping com agentes de IA e como isso pode redefinir o cenário cloud-native. Além disso, confira repositórios promissores e insights da comunidade.
AI Agents: A Nova Fronteira do Cloud-Native
Exploramos como os agentes de IA estão transformando o cenário cloud-native e destacamos ferramentas promissoras para desenvolvedores brasileiros.
Sandboxing na Era dos Agentes de IA
Exploramos sandboxes leves, seguras e instantâneas para agentes de IA, além de como isso transforma o cenário cloud-native.
RustDesk e o Avanço das Ferramentas Open Source
Exploramos o crescimento das ferramentas open source como RustDesk e seu impacto no cenário cloud-native. Descubra como essas soluções estão transformando a experiência do desenvolvedor.
OpenMythos e o Crescimento dos Frameworks Open Source
Exploramos o OpenMythos, um framework revolucionário inspirado no Claude, e discutimos como ele reflete o avanço dos agentes de IA open source no universo cloud-native.
Browser Harness e o Futuro dos Agentes de IA na Web
Exploramos como ferramentas como o Browser Harness estão transformando a web em um playground para agentes de IA, automatizando tarefas e redefinindo a interação online.
LLMfit e Cognee: Explorando o Futuro dos Agentes de IA
Descubra como ferramentas como LLMfit e Cognee estão moldando o futuro dos agentes de IA no ecossistema cloud-native e o impacto dessas inovações no mercado brasileiro.
Open Source e Agentes de IA: Um Futuro Promissor para o Cloud-Native
Exploramos o impacto dos agentes de IA open source no ecossistema cloud-native, com destaque para novos repositórios que estão transformando a forma como desenvolvemos aplicações.
LLM Tools e o Impacto na Cultura Cloud-Native
Exploramos como ferramentas de LLM estão moldando práticas cloud-native e transformando a experiência dos desenvolvedores.
Claude Code, RTK e o Novo Cenário dos Agentes de IA
Exploramos como ferramentas como RTK e Claude Code estão transformando o desenvolvimento com IA e o que isso significa para os devs brasileiros.
Superpowers e o Novo Paradigma dos Agentes de IA
Exploramos o impacto do framework Superpowers para agentes de IA e como ele pode transformar o desenvolvimento cloud-native. Além disso, confira repositórios promissores e insights da comunidade.
Claude Code e os Agentes do Futuro: O que está por vir?
Exploramos o boom dos agentes de IA, o impacto do Claude Code e os repositórios que estão bombando no GitHub.
Ruflo e o Futuro da Orquestração de Agentes
Exploramos o impacto dos agentes de IA na era do cloud-native, com foco no Ruflo e outras ferramentas emergentes que estão revolucionando o desenvolvimento de software.
Por que Platform Engineering é o futuro (e não DevOps)
No primeiro episódio, exploramos o que é Platform Engineering, por que está substituindo o DevOps tradicional, e como isso muda a carreira de quem trabalha com infraestrutura e desenvolvimento.
Claude Code e o Boom dos Agentes de IA Open Source
Exploramos o crescimento explosivo dos agentes de IA open source, com destaque para o Claude Code e suas aplicações. Além disso, os repositórios GitHub mais quentes da semana!
Platform engineering para workloads de IA: rate limits, custo de inferência e guardrails
Quando IA vira infraestrutura, os problemas de plataforma ficam diferentes. O que aprendi gerenciando workloads de IA em escala: throttling, custo por token, fallbacks e como construir guardrails que funcionam.
Como construí este site com IA como par de programação — do zero ao deploy
Este site foi construído com IA como colaborador ativo — não para gerar o texto dos episódios, mas para implementar a plataforma inteira. O que funcionou, o que não funcionou, e o que aprendi sobre trabalhar com agentes de código.
O que "sênior" significa quando a IA escreve o boilerplate
A definição de sênior sempre foi nebulosa. Com IA escrevendo o código que antes diferenciava júnior de pleno, o critério precisa ser revisto — e essa revisão tem consequências para quem está crescendo agora.
O que mudou de verdade em 12 meses de agentes de IA no meu trabalho
Não é hype — é a rotina. O que ficou, o que falhou, e o que ninguém estava esperando que acontecesse quando agentes de IA viraram parte do trabalho diário de plataforma.
O que eu faria diferente se começasse hoje — carta para o dev de 2019
Se eu pudesse mandar uma carta para mim mesmo em 2019 — saindo do burnout, entrando numa software house, sem saber onde ia chegar — o que eu diria?
O que uma empresa global aprende sobre IA em 2025 — sem o hype do LinkedIn
Do lado de dentro de uma empresa grande adotando IA, o que está sendo difícil, o que está funcionando, e o que o LinkedIn não conta sobre essa transição.
De ideia a produto: a stack que uso para construir rápido como engenheiro solo
Construir rápido sozinho não é sobre usar menos ferramentas — é sobre escolher as certas e não mudar de ideia no meio do caminho.
Claude Code no trabalho real — um mês usando IA como pair programmer de verdade
Depois de um mês usando Claude Code como meu par de programação principal, aqui está o que mudou, o que não mudou, e o que eu não esperava.
Staff Engineer em 2025: o que mudou na função quando IA faz 80% do código boilerplate
Se IA escreve o código que antes diferenciava seniors de juniors, o que Staff Engineer faz? A resposta é mais clara do que parece — e mais urgente.
Construir em público sendo CLT — o que funciona, o que não funciona, o que tenho medo
Trabalhar em tempo integral numa empresa e construir produtos paralelos em público é possível. Mas tem fricções reais que ninguém comenta no LinkedIn.
MCP: o que é o Model Context Protocol e por que vai mudar como construímos ferramentas
MCP não é mais uma sigla de IA. É um protocolo que muda como ferramentas se conectam com modelos de linguagem — e o que isso significa para engenheiros.
Platform engineering para serviços de IA — golden paths para times que usam LLMs
Quando times de produto começam a usar LLMs, a plataforma precisa evoluir. O que aprendi construindo infraestrutura para IA dentro de uma empresa.
Como construí um produto do zero usando IA como par de programação
Construir um produto solo em 2025 é diferente de 2020. Não porque ficou mais fácil — porque ficou possível atacar escopo que antes exigia um time.
Agentes de IA em produção — o que aprendi deployando LLMs num ambiente enterprise
Colocar um agente de IA em produção numa empresa com compliance, SLA e time de segurança é diferente de fazer um demo no notebook. Aqui está o que ninguém conta.
O que compila em 2025: as habilidades que ainda importam quando a IA escreve código
Quando a IA consegue escrever a maioria do código boilerplate, o que ainda diferencia um engenheiro bom de um mediano?
O que mudou no meu trabalho com IA em 2025 — não é o que você pensa
Todo mundo fala sobre produtividade com IA. O que mudou de verdade no meu trabalho não foi velocidade — foi o tipo de problema que eu consigo atacar.
A pressão de manter 99.999% — o que alta disponibilidade faz com a sua cabeça
Cinco noves de disponibilidade. Isso é 5 minutos de downtime por ano. Aqui está o que ninguém conta sobre o que é operar sistemas com esse SLA — e o custo humano disso.
Dois anos numa empresa global — o que mudou em mim como engenheiro
Não é sobre o que aprendi tecnicamente. É sobre como muda a forma de pensar sobre problemas, sobre impacto, e sobre o que significa fazer bom trabalho.
Documentação como produto — o que aprendi numa empresa onde escrever é trabalhar
Em times distribuídos de alta performance, documentação não é overhead — é o principal mecanismo de escala. Aqui está como pensar sobre isso de forma diferente.
IA no workflow de engenharia — o que mudou de verdade no meu dia a dia depois de 1 ano usando
Depois de um ano usando ferramentas de IA no trabalho de engenharia, aqui está uma avaliação honesta: o que mudou, o que não mudou, e onde eu ainda erro.
Golden paths: o que são e por que o melhor código de plataforma é o que os devs não precisam escrever
A ideia mais contra-intuitiva de platform engineering: quanto menos código os times de produto precisam escrever para infraestrutura, melhor você fez seu trabalho.
PCI-DSS: o que é compliance de verdade quando o dinheiro de todo mundo depende do seu sistema
Compliance parece burocracia até você entender o que está protegendo. Aqui está o que aprendi trabalhando em ambiente financeiro regulado.
O que é um Staff Engineer — e como parei de fazer para começar a multiplicar
O título mudou, mas a mudança maior foi no modelo mental. Staff engineering não é ser um senior melhor — é uma forma diferente de criar impacto.
Trabalhar em time distribuído globalmente: o que funciona, o que não funciona
Depois de quase um ano em time distribuído em múltiplos fusos, aprendi que a maior parte dos problemas não é de fuso — é de cultura de comunicação.
Escrever Go para infraestrutura — o que o Python não me preparou para isso
Fiz a transição de Python para Go para trabalho de plataforma. Aqui está o que realmente muda — além da sintaxe.
API Gateway a sério: o que muda quando você opera para milhões de requests por dia
Existe uma diferença qualitativa entre montar um API gateway para um side project e operar um para uma fintech global. Aqui está o que aprendi operando no segundo cenário.
Minha primeira semana trabalhando 100% em inglês
Eu sabia inglês. Mas trabalhar em inglês é diferente de saber inglês. Aqui está o que ninguém te conta sobre essa transição.
Como me preparei para vaga de Staff Engineer internacional — o que funcionou e o que não funcionou
Em 2022 e 2023 me preparei para vagas internacionais de Staff. O processo revelou lacunas que eu não sabia que tinha e forçou articulação de experiência que eu achava óbvia.
Como foi o processo seletivo para trabalhar numa empresa americana — e o que me surpreendeu
Depois de anos construindo fundação técnica, eu finalmente tentei uma vaga internacional. Aqui está o que ninguém conta sobre como esse processo realmente funciona.
Como aprendi Supabase construindo produto próprio
Em 2023 precisava de banco, autenticação e storage sem operar infraestrutura. Supabase resolveu em um dia o que teria levado uma semana com stack própria.
Por que eu comecei a olhar para vagas internacionais — e o que me assustava
Não foi ambição. Foi uma percepção gradual de que o tipo de problema que queria resolver estava em empresas que eu não conseguia acessar pelo mercado local.
Estudar inglês para carreira internacional — o que funcionou, o que não funcionou
Inglês técnico de documentação é diferente de inglês de reunião. Aprendi isso da forma mais desconfortável possível, e o que fiz para mudar.
Como o Café com Dopamina virou público — e o que aprendi sobre criar publicamente
Em 2022 transformei notas privadas de 2019 em podcast público. Não foi estratégia. Foi perceber que o que eu estava processando era o mesmo que outras pessoas precisavam ouvir.
Cloud cost: o que acontece quando você ignora a fatura da AWS por 3 meses
A AWS não cobra por usar — cobra por esquecer. Instâncias paradas, snapshots acumulados, transferência de dados que ninguém percebeu. Uma história de aprendizado caro.
Síndrome do impostor no próximo nível — quando você sabe mais e se sente menos seguro
Esperava que aprender mais me deixaria mais confiante. O oposto aconteceu por um tempo. Quanto mais eu entendia sobre sistemas, mais eu percebia o quanto não sabia.
Como lancei meu primeiro produto próprio — e o que aprendi no processo
Em 2022 comecei o MEXP como produto paralelo. Não era só código — era entender o que é vender software, não só construir. Os dois são completamente diferentes.
Grafana + Prometheus: de 'não sei o que está acontecendo' para 'eu sei exatamente'
A diferença entre operar no escuro e ter visibilidade real do sistema. Como configurei meu primeiro stack de monitoramento de verdade — e o que aprendi no processo.
O que é service mesh — e quando você realmente precisa de um
Em 2022 aprendi Istio. Demorei semanas para entender por que ele existe. Quando entendi, virei crítico dele — não porque é ruim, mas porque a maioria não precisa.
Como eu comecei a pensar em platform engineering antes de saber que tinha esse nome
Antes de conhecer o termo, já estava fazendo o trabalho: reduzindo o atrito para outros devs, construindo ferramentas internas, abstraindo complexidade. Só faltava o nome.
O incidente que me ensinou sobre resiliência de sistemas — e de mim mesmo
Derrubei um serviço em produção numa sexta às 17h. O que aconteceu nas próximas três horas me ensinou mais sobre engenharia do que qualquer livro.
O que é platform engineering — e por que o conceito mudou minha visão de infra
Em 2022 aprendi sobre Internal Developer Platforms. Não como tecnologia — como forma de pensar sobre o que infra realmente serve. Mudou como eu projeto sistemas.
Observabilidade: a diferença entre log, métrica e trace que ninguém explica direito
Todo sistema produz dados. Poucos sistemas são observáveis. A diferença está em entender o que perguntar — e ter as ferramentas certas para responder.
Infrastructure as Code: quando parei de clicar no console e comecei a escrever Terraform
O console da AWS parece intuitivo até você precisar replicar o que fez. Terraform foi a resposta — mas a transição mental foi mais difícil do que a técnica.
Por que aprendi Go depois de anos em Python
Em 2022 comecei a aprender Go. Não porque Python estava ruim — porque queria entender por que sistemas de alta escala são escritos em Go, e a única forma era escrever.
Meu primeiro deploy no Kubernetes — e os 3 dias que passei debugando
Documentação lida, tutoriais assistidos, teoria clara. E ainda assim, quando tentei subir minha aplicação no Kubernetes, nada funcionou. Aqui está o que aprendi debugando ao vivo.
Kubernetes: o que é, o que não é, e por que todo mundo finge que entende
K8s virou palavra de ordem em qualquer conversa sobre infra. Mas o que ele realmente faz — e quando você não precisa dele — fica perdido no hype.
CI/CD do zero: o que aprendi montando meu primeiro pipeline de verdade
Por anos eu fazia deploy na mão. Quando finalmente montei um pipeline real, entendi que a parte técnica era a menor. O desafio era confiar na máquina.
O que dois anos de software house me ensinaram sobre como engenheiros crescem
Software house tem uma reputação mista entre devs. Depois de dois anos lá, entendo por que — e entendo também o que ela entrega que outros ambientes não entregam do mesmo jeito.
Ler livros técnicos — como eu parei de fingir que lia e comecei a aprender
Por anos eu comprei livros técnicos, comecei vários, terminei poucos, retive menos ainda. O problema não era falta de disciplina — era que eu estava lendo do jeito errado.
O que é observabilidade — e como aprendi a diferença de monitoramento
Em 2021 a diferença entre monitoramento e observabilidade ficou clara num incidente de produção. Monitoramento te diz que algo está errado. Observabilidade te diz por quê.
Git além do commit e push — o que aprendi trabalhando em time
Eu sabia usar Git solo. Aprendi a usar Git em time quando comecei a entender que o histórico de commits é comunicação, não só rastreamento.
Por que tirei a LPIC-1 depois de 10 anos usando Linux
Em 2021 estudei para LPIC-1 com 10 anos de Linux. Aprendi mais do que esperava — não técnica nova, mas nome para coisas que eu fazia sem saber nomear.
Quando eu percebi que queria ser um engenheiro, não só um programador
Programar é escrever código. Engenharia de software é tomar decisões sobre sistemas com trade-offs reais, em equipe, com restrições reais. A diferença parece semântica até você sentir na prática.
Container na prática — do docker run ao docker-compose
Aprendi Docker em três fases distintas, cada uma revelando um nível diferente de controle sobre o ambiente. O salto mais importante foi do docker run para o Dockerfile. O mais útil no dia a dia foi o docker-compose.
Clean Code — o livro que todo dev precisa ler com ceticismo
Clean Code foi o primeiro livro técnico que li com seriedade. Aprendi muito. E aprendi ainda mais quando comecei a questionar o que ele pregava como lei absoluta.
Code review que machuca e code review que ensina — a diferença
Recebi code reviews que me fizeram questionar se eu era bom o suficiente. E recebi code reviews que me tornaram um engenheiro melhor. A diferença estava em como o feedback era dado, não no feedback em si.
Como aprendi Kubernetes — e o que eu entendi errado no começo
Em 2021 comecei a usar EKS. Meu primeiro entendimento de Kubernetes era errado: não é 'Docker com mais peças'. É um sistema de reconciliação de estado desejado.
SQL de verdade — o que mudou quando parei de fugir do banco de dados
Durante anos eu tratei o banco de dados como uma caixa preta que guardava dados. Aprender SQL de verdade mudou completamente como eu penso sobre performance e modelagem.
Construir side projects quando você já trabalha 8h por dia de código
Todo mundo fala que você deveria ter projetos paralelos. Ninguém fala sobre o cansaço cognitivo de programar o dia todo e tentar programar de noite também.
O que aprendi mentorando dev júnior pela primeira vez
Em 2021 fui seniorizado e me pediram para mentorear dois devs júnior. Achei que ia ensinar. O que aconteceu foi que aprendi mais do que eles naqueles seis meses.
Por que SOLID importa — e quando não importa
SOLID é ensinado como lei. Na prática é ferramenta — e como toda ferramenta, tem contexto certo para usar e contexto certo para ignorar.
O que aprendi com o AWS Cost Explorer depois de uma conta surpresa
Em 2021 minha conta AWS foi R$800 num mês que deveria ser R$80. Aprendi mais sobre cloud cost management naquele mês do que nos doze anteriores somados.
Como o Docker mudou minha relação com 'funciona na minha máquina'
Por anos eu aceitei como normal que o ambiente do desenvolvedor fosse diferente do ambiente de produção. O Docker mudou isso — mas o mais importante foi entender o que o problema representava.
O dia que eu aprendi o que é arquitetura de software de verdade
Durante dois anos escrevi código funcional sem entender por que certas decisões tornavam o sistema mais difícil de mudar. Então li uma frase que reorganizou tudo.
O que um ano de pandemia me ensinou sobre autonomia
2020 foi o primeiro ano em que trabalhei sem estrutura externa de escritório por um período longo. Aprendi mais sobre como eu funciono sozinho do que em todos os anos anteriores juntos.
Por que comecei a usar Terraform — para não perder mais infraestrutura
Em 2020 recriei um ambiente de produção do zero depois de deletar sem querer. Levou três horas tentando lembrar o que tinha configurado. Aprendi que infraestrutura também precisa de versão.
Como aprendi AWS VPC — porque meu servidor não conseguia falar com o banco
Coloquei API no EC2 e banco no RDS. Não se falavam. Passei um dia inteiro debugando o que estava entre eles. Era a rede — e eu não sabia nada sobre rede em cloud.
Minha primeira conta AWS — e o susto na fatura
Em 2020, abri minha primeira conta AWS para um projeto. Não entendia o modelo de pricing. A fatura do mês foi um choque — e uma das melhores aulas que tive sobre como cloud funciona de verdade.
Como aprendi a dar e receber feedback técnico
Em 2020 fiquei na defensiva no meu primeiro code review sério. Levei um tempo para entender que o código não é você — e que feedback bom tem uma estrutura específica.
Por que estudei machine learning sem plano de usar
Em 2020 fiz o curso de ML do Andrew Ng. Não tinha projeto. Não tinha aplicação imediata. Aprendi que às vezes estudar sem usar é a preparação para reconhecer quando usar.
Como configurei meu primeiro pipeline de CI/CD — e o que aprendi no processo
Em 2020 tinha uma aplicação que eu deployava manualmente. Aprendi CI/CD não por filosofia DevOps, mas porque errei um deploy às 23h e decidi que nunca mais queria passar por isso.
Aprender a trabalhar remoto quando nunca foi pensado pra isso
Trabalho remoto como adaptação emergencial não é o mesmo que trabalho remoto como design intencional. Levei meses para entender a diferença — e o que tinha que mudar.
COVID, trabalho remoto, e o que aprendi nos primeiros três meses
Em março de 2020 todo o time foi para casa. Alguns meses depois eu percebi que nunca ia querer voltar. Aqui está o que mudou — e o que quase quebrou no começo.
A semana que a COVID chegou e tudo virou remoto da noite pro dia
Março de 2020. Em uma semana, todo o time foi para casa. Sem planejamento, sem processo, sem preparação. E nós tínhamos que continuar entregando.
A primeira vez que usei Docker — e o que ele resolveu de vez
Em 2020 parei de ouvir falar e comecei a usar. O problema que me fez aprender Docker não foi filosofia de DevOps — foi 'funciona na minha máquina' uma vez de mais.
Meu primeiro contato com AWS: o que entendi e o que não entendi
Em 2019 abri o console da AWS pela primeira vez. Tinha 200 serviços. Não sabia por onde começar. Aqui está o que realmente importava entender primeiro.
O que mudou em mim como dev depois do burnout
Burnout muda você. Não só como pessoa — como profissional. Algumas mudanças foram perdas. A maioria foi ganho.
Como encerrei 2019 diferente de como comecei
Em janeiro de 2019 eu sabia fazer scripts. Em dezembro eu tinha construído sistemas integrados, entregado para clientes reais, e aprendido o que nenhum tutorial ensina.
Como eu saí do burnout — o que realmente funcionou
Não foi uma única coisa. Foi uma combinação de mudanças pequenas ao longo de meses. E algumas das coisas que eu achava que iam ajudar não ajudaram.
S3: pesquisa, dados e o que 2018–2019 construíram sem que eu percebesse
Fechando a terceira temporada: o que o período de pesquisa e dados construiu que eu só entendi olhando para trás. Fundação para S4, onde trabalho e universidade acontecem ao mesmo tempo.
O que é idempotência — e por que ela salvou meu sistema
Meu webhook de integração processava o mesmo evento duas vezes quando a rede ficava instável. Aprendi que o problema não era de rede — era que meu código não era idempotente.
Por que derrubei uma API de terceiro — e o que aprendi sobre rate limit
Rodei um script de sincronização sem throttle. Em três minutos fiz 4.200 requests. A API bloqueou minha chave. O cliente ficou sem sistema por duas horas.
O que aprendi lendo código de outras pessoas
Em 2019 eu evitava ler código que não tinha escrito. Parecia mais lento que escrever do zero. Estava completamente errado — e aprendi isso da forma mais dolorosa possível.
Como o Scrum funcionava na prática — bem diferente do livro
Li o Scrum Guide antes de entrar no time. A realidade era mais bagunçada, mais humana, e na minha opinião mais útil do que qualquer guia descreveu.
O que aprendi tentando automatizar uma tarefa que eu odiava
Tinha uma tarefa manual que tomava 40 minutos por dia. Passei uma semana automatizando. O script levava 2 minutos mas levou 3 meses para ficou estável o suficiente para confiar.
O sinal que não reconheci na época: quando trabalho, faculdade e pesquisa começaram a pesar ao mesmo tempo
Final de 2019. Estava fazendo faculdade, pesquisa e começando a trabalhar ao mesmo tempo. Sentia o peso mas não sabia nomear. Só fui entender o que estava acontecendo muito depois.
Por que li meu primeiro livro de arquitetura de software em 2019
Não foi por curiosidade. Foi porque tinha um problema que não conseguia resolver e alguém mencionou Clean Architecture. Lembro onde estava quando aquela leitura clicou.
Meu primeiro código profissional real — e o que ele me ensinou sobre o que eu não sabia
Quando entrei na software house, achei que sabia programar. Sabia. Mas sabia de um jeito que não escalava, não era legível, e não sobrevivia a outro desenvolvedor mexendo nele. Aprendi isso da forma difícil.
Como tokens e sessões funcionam — aprendi implementando autenticação do zero
Em 2019 implementei autenticação pela primeira vez. Guardei token em localStorage, não validava expiração, e não sabia a diferença entre sessão e JWT. Aprendi caro.
"Funciona na minha máquina" — a mentira que eu acreditei por meses
Em 2019 eu disse essa frase pelo menos três vezes. Cada vez era verdade. E cada vez o ambiente de produção ou do cliente contava outra história.
O que é deploy manual — e por que aprendi a ter medo dele
Em 2019 eu deployava via SSH + git pull + restart manual. Funcionava. Até o dia que não funcionou. E o cliente ficou sabendo antes de mim.
Como aprendi sobre logging depois de não conseguir debugar em produção
O bug estava em produção. Não tinha como reproduzir localmente. Não tinha log nenhum. Aprendi da pior forma possível que observabilidade não é opcional.
Como falar de tecnologia com cliente que não é técnico
A primeira reunião que tive com cliente, falei sobre endpoints, payloads e schemas por 20 minutos. Saí achando que tinha ido bem. O cliente saiu sem entender nada.
Debug sistemático: como parei de adivinhar e comecei a investigar
Durante meses eu debugava no estilo tentativa e erro. Trocava uma linha, rodava, olhava. Não funcionava, trocava outra. Aprendi que isso não é debug — é loteria.
O que aprendi sobre refactoring antes de saber o que era
Tinha um módulo que eu evitava tocar. Em 2019 precisei mexer nele e entendi porque código deteriora — e por que ninguém fala sobre isso no começo da carreira.
Aprender a trabalhar sozinho em problema que não tem resposta no Stack Overflow
Em pesquisa, os problemas que você encontra raramente têm solução documentada. Aprendi a trabalhar sem rede de segurança — e esse músculo nunca mais sumiu.
Como eu estimava tarefas no começo — e porque errava sempre
Em 2019 eu estimava em horas e entregava em dias. Levou algumas conversas difíceis para entender que estimativa não é previsão — é comunicação.
Meu primeiro dia numa software house — o choque
Saí de uma telco com processo lento e entrei numa software house com múltiplos clientes, prazos curtos e tecnologia diferente toda semana. O choque foi real — e necessário.
O cliente pediu relatório. O que ele queria era decisão.
Em 2019 entreguei exatamente o que foi pedido e estava completamente errado. Aprendi que pedido técnico é a solução imaginada para um problema que ainda não foi explicado.
Por que comecei a escrever sobre o que aprendia — e por que não parei mais
Em 2019, escrever não era estratégia de conteúdo. Era o que eu fazia para não afundar. Aqui está como virou prática e por que acredito que todo dev deveria escrever.
Quando percebi que estava em burnout — e o que fiz
Em 2019 eu estava aprendendo uma nova carreira, entregando para clientes, estudando à noite, e achando que aguentar mais era a resposta. Não era.
Por que fui aprender banco de dados do zero em plena carreira
Sabia SQL desde a faculdade. Mas índice, vacuum, explain analyze, transaction isolation — aprendi porque precisei, não porque estudei. Aqui está o que a produção me ensinou.
app.py com 800 linhas: como a estrutura do projeto me ensinou a dividir responsabilidade
Meu primeiro projeto profissional em Python era um arquivo. Oitocentas linhas, tudo misturado. Aqui está o que foi forçando a separação — e por que estrutura importa antes de framework.
O mês depois que eu pedi demissão
Pedi demissão em 2019. O mês seguinte foi diferente do que eu esperava — não foi alívio imediato. Foi uma fase estranha de vácuo, incerteza e descoberta sobre quem eu era fora daquele emprego.
Subi credencial no Git. Aqui está o que eu fiz depois.
Aconteceu em 2019, meu primeiro projeto real com cliente pagando. API key de pagamento no histórico do Git. Aprendi sobre variável de ambiente da pior forma.
Autenticação vs. autorização: a diferença que eu confundia no começo
Todo sistema tem as duas. A maioria dos bugs de segurança que vi em código júnior era confundir uma com a outra — ou implementar autorização onde precisava de autenticação.
O checklist que eu usava antes de ir pra produção em 2019
Sem CI/CD automatizado, o que impedia o deploy de quebrar tudo era disciplina manual. Esse era o checklist que eu executava antes de cada deploy.
Terminar a faculdade quando você já está com burnout
Concluir o TCC e as últimas matérias enquanto pedia demissão e ainda não tinha me recuperado do burnout. O que aprendi sobre fazer o suficiente quando você não tem mais do que o suficiente.
Como aprendi HTTP de verdade sem estudar HTTP
Formação em redes me deu TCP/IP na veia. Mas HTTP como protocolo de aplicação — verbos, status codes, headers, idempotência — aprendi construindo API, não lendo RFC.
O que dados sujos ensinam sobre sistemas reais: garbage in, garbage out não é metáfora
A limpeza dos dados de pesquisa levou mais tempo que a análise. Duplicatas, valores ausentes, encoding quebrado, datas em três formatos diferentes. O que isso ensina sobre sistemas de produção.
Como aprendi a dar code review antes de saber receber review
Meu primeiro code review que dei foi antes de entender o que era review bom. O que aprendi sobre review dando, não recebendo — e por que a perspectiva muda tudo.
O que é webhook e por que é muito melhor do que polling
Polling parece óbvio quando você começa. Funciona. Até você entender webhook e perceber que estava resolvendo o problema do jeito mais caro possível.
Como comecei a escrever testes depois de um bug feio em produção
Trabalhei sem testes por meses. Um bug que voltou três vezes na mesma semana me convenceu de vez. Aqui está o que aprendi sobre testes que nenhum tutorial ensina direito.
Por que standup não é sobre o que você fez ontem
Levei meses para entender o que standup realmente serve. Não é relatório de status. É ferramenta de coordenação. A diferença muda como você usa o tempo do time.
Como entregamos um projeto completo para cliente pela primeira vez
Primeiro projeto do zero ao deploy com cliente real na POA Software. O que funcionou, o que não funcionou, e o que aprendi que nenhum tutorial de programação ensina.
Linux de sysadmin para dev: o que muda quando você passa de roteador para aplicação
Linux profissional desde 2013 — roteadores são Linux puro. O que mudou em 2019 foi operar aplicação de software com cliente real, não infraestrutura de rede.
Proxmox em casa: como um servidor velho virou meu melhor professor de infra
Em 2019 transformei um PC antigo num servidor com Proxmox. O que aprendi em 6 meses de homelab foi mais do que qualquer curso de cloud poderia ter me dado.
Como organizar um backlog pessoal de aprendizado sem enlouquecer
Lista de 'quero aprender' que só cresce é ansiedade disfarçada de produtividade. Aqui está como transformei isso em sistema que realmente funciona.
Como estudar sozinho sem perder o foco: meu método de 2019
Em 2019 estava aprendendo desenvolvimento enquanto trabalhava em tempo integral. Não tinha bootcamp, não tinha mentor. Desenvolvi um método que funcionou — e ainda uso hoje, mais refinado.
Por que eu saí de uma empresa de telco depois de 6 anos
Seis anos no mesmo lugar. Cresci lá, aprendi lá, e ainda assim pedi demissão. Não foi uma decisão fácil — e foi a decisão certa.
Por que aprendi sobre dados abertos trabalhando na RNP em 2019
Em 2019 trabalhei em projeto da RNP com dados abertos do governo. Não sabia que dados públicos podiam ser tão úteis — e tão bagunçados. O que aprendi sobre qualidade de dados ficou comigo.
Automação que nasceu de preguiça: quando escrever código economizou horas repetitivas
Tinha uma tarefa de pesquisa que eu fazia manualmente toda semana. Levava 2 horas. Escrevi um script que faz em 3 minutos. Aquele dia entendi o que código pode ser.
Dataverse e Power Platform: o que aprendi trabalhando com dados estruturados da Microsoft
Em 2019 precisei integrar um sistema com Dataverse da Microsoft. Era a primeira vez que encontrei uma plataforma de dados low-code enterprise. O que aprendi sobre dados estruturados ficou comigo.
O Active Directory que eu gerenciava na Oi e o que isso tem a ver com SSO
Passei anos criando usuários e aplicando GPO no Active Directory de clientes. Só entendi o que estava fazendo quando precisei integrar SAML com Azure AD — e percebi que era a mesma coisa, com nome diferente.
Como construí minha primeira integração SAML — e o que é SSO de verdade
Em 2019 precisei integrar um sistema com o provedor de identidade de um cliente. Não sabia o que era SAML. Aprendi na raça. Aqui está o que você precisa saber antes de começar.
Trabalhar e estudar ao mesmo tempo: o que aprendi tentando fazer os dois
Em algum ponto de 2019, voltei a trabalhar enquanto ainda estava na faculdade. Os dois juntos funcionam — mas não da forma que você imagina. O que consegui e o que tive que abrir mão.
Como aprendi a ler documentação técnica de verdade
No começo eu lia docs da mesma forma que lia tutorial. Errado. Aqui está o método que desenvolvi para extrair o que precisa de qualquer documentação, mesmo quando é ruim.
O que é CRM e o que eu aprendi construindo integrações para um
Meu primeiro projeto na POA Software foi integrar formulários de leads com um CRM. Não sabia o que era CRM. Aprendi construindo — e o processo me ensinou mais sobre dados de negócio do que qualquer livro.
VPN corporativa: o que eu configurava na Oi e o que significa hoje em cloud
Configurei VPN para dezenas de empresas clientes na Oi. Só entendi por que isso importava para cloud quando precisei resolver um problema de conectividade em AWS anos depois.
Iniciação científica: o que é trabalhar com pesquisa sem ser pesquisador por vocação
Trabalhei em projeto de pesquisa por dois anos. Aprendi rigor, metodologia, como trabalhar com incerteza. Mas sempre soube que não era aquilo que eu queria fazer para sempre.
Por que SQL ainda importa quando você trabalha com APIs
Em 2019 achei que podia ignorar SQL e só usar ORM. Errei. Aqui está o momento em que entendi que SQL não é detalhe de implementação — é a língua dos dados.
O que é burnout antes de você saber que está com burnout
Eu não sabia que estava com burnout. Achei que era fraqueza, falta de vontade, preguiça. Levou meses para eu entender o que estava acontecendo — e esse atraso no diagnóstico custou caro.
Meu primeiro sistema em produção: o que funcionou e o que não funcionou
Em 2019 subi meu primeiro sistema real para produção. Sem pipeline. Sem rollback. Sem monitoramento. Aqui está o que aprendi antes de aprender do jeito certo.
O que 4 anos configurando redes na Oi me ensinou sobre debug
Debug de software e debug de rede são a mesma coisa. Aprendi isso antes de saber programar, e isso me deu uma vantagem que levei anos para nomear.
O que SQL me ensinou sobre como pensar em transformação de dados
Aprendi SQL para análise, não só para CRUD. Quando descobri CTEs, GROUP BY aninhado e como compor queries, entendi que SQL é linguagem de transformação — não só de consulta.
Como eu organizava meu ambiente de dev em 2019
Setup de dev não é só estética. É quanto tempo você perde procurando coisa, chaveando contexto, esperando build. Em 2019 aprendi isso da forma difícil.
Git em software house vs. universidade — e o que pair programming muda nisso tudo
Usava git em time desde a universidade. Achei que estava pronto para uma software house. Não estava. Pair programming, code review comercial e cliente real revelaram camadas que a faculdade não ensina.
Construí API REST por 3 meses sem entender o que estava fazendo
Aprendi REST na raça, construindo integração de CRM sem saber o nome do que estava fazendo. Aqui está o que eu queria ter lido antes de começar.
Por que saí da Oi para virar software engineer — e o que a rede me ensinou
Passei 4 anos configurando redes na Oi Telecomunicações antes de escrever minha primeira linha de código profissional. Não foi desperdício. Foi o melhor curso de debugging que eu poderia ter feito.
O primeiro modelo de ML que treinei — e o que ele não previa que eu esperava que previsse
Meu primeiro modelo de machine learning tinha 94% de acurácia no teste. No dado real, errava exatamente os casos que mais importavam. Aprendi o que acurácia não mede.
Pandas e a ilusão de que manipular dado em memória é simples
Pandas funcionava perfeitamente com os dados de teste. Quando rodei com o dataset real, recebi MemoryError. A lição: nunca assuma que o dado cabe.
Como estruturei meu primeiro projeto Python que precisava sobreviver mais de uma semana
Scripts são fáceis. Projeto que outros vão ler, que vai ser mantido, que tem módulos e testes — é outra coisa. O que aprendi quando precisei estruturar código para durar além do imediato.
Como aprendi a ler paper técnico sem desistir na segunda página
No começo, todo paper parecia inacessível. Notação matemática, referências que pressupõem que você leu outras 30 referências, abstract que não resume nada. O método que aprendi para extrair valor de literatura técnica.
O que estatística ensina sobre código: por que viés importa em sistema, não só em análise
Aprendi estatística para pesquisa — média, variância, p-valor, viés amostral. Depois percebi que esses conceitos descrevem exatamente os problemas que sistemas de software têm em produção.
Dados abertos e o que infraestrutura de pesquisa do Brasil ensina sobre abertura
Trabalhar com dados públicos num contexto de pesquisa ensina coisas que dado corporativo fechado não ensina: sobre licença, sobre reprodutibilidade, sobre o que significa dado que qualquer pessoa pode verificar.
SQL de verdade: quando banco de dados deixou de ser só 'onde ficam os dados'
Na Oi eu sabia que banco de dados existia. Na pesquisa, aprendi a usar SQL de verdade — JOINs, GROUP BY, subqueries. E entendi que dado é mais do que armazenamento.
O que projetos de inovação universitária ensinam que o mercado não ensina
Participei de projetos de inovação na universidade — pitch de ideia, prova de conceito, apresentação para banca. É diferente de entregar para cliente. Os dois ensinam coisas que o outro não ensina.
Como comecei a estudar ML em 2018 sem saber para que — e o que isso produziu
Em 2018 comecei a estudar machine learning sem projeto concreto, sem vaga esperando, sem aplicação óbvia. O que esse aprendizado sem destino construiu ao longo dos anos.
Jupyter Notebook: o ambiente que ensina a programar sem CLI, e o problema que cria depois
Jupyter foi meu primeiro ambiente de Python sério. Perfeito para explorar dados. Péssimo para me ensinar como código de produção funciona.
O projeto de pesquisa que eu achei que ia ser trabalho de verdade — e o que faltou
Na faculdade, trabalhei meses num sistema que resolvia um problema real. Mas quando tentei mostrar para alguém fora da academia, percebi que tinha construído algo que só fazia sentido dentro dela.
Quando percebi que Python era a linguagem certa para o que eu queria fazer
Em algum momento de 2018, Python deixou de ser 'a linguagem que eu uso para scripts' e virou minha linguagem base. O processo de escolher linguagem principal sem FOMO.
Primeiro contato com dados de verdade: a diferença entre dado de exercício e dado sujo
No tutorial, os dados são limpos. No mundo real, as colunas têm espaço no final, os tipos são inconsistentes, e metade dos registros está faltando. Esse foi meu primeiro projeto com dados reais.
Python depois de anos em shell script e GPO: o que muda quando você aprende a programar de verdade
Passei anos automatizando coisas com bash e PowerShell. Quando encontrei Python na pesquisa, percebi que havia uma diferença entre escrever script e escrever código.
S2: o que um ano de faculdade ensinou que 3 anos de trabalho não tinham ensinado
Fechando a segunda temporada: o que 2017 significou, o que mudou, e por que a decisão de largar o emprego e estudar foi a aposta certa — não pelo diploma, mas pelo que a teoria fez com a prática.
Banco de dados: o que eu nunca tinha entendido usando só como usuário
Eu tinha operado sistemas que usavam banco de dados sem entender banco de dados. Quando aprendi SQL de verdade e modelo relacional, muita coisa sobre sistemas que eu operava ficou clara.
Algoritmos e por que complexidade não era abstrata para mim
A matéria de Algoritmos ensina O(n), O(n²), O(log n). Para a maioria dos alunos é teoria. Para mim, que tinha visto script lento travar servidor, era vocabulário para algo que eu já tinha sentido.
Redes na faculdade: teoria vs. o que eu já tinha configurado na vida real
Quando a matéria de redes chegou, eu já tinha configurado VLANs, VPN e roteamento em produção. A teoria formalizou o que eu fazia — e revelou onde eu estava errado.
Git em time real na faculdade — e por que foi diferente de tudo que aprendi vendo tutorial
Aprendi git em tutorial. Sabia add, commit, push. Quando entrei em um projeto com outras pessoas na faculdade, descobri que não sabia nada.
Ser o mais velho da turma: o que experiência cria e o que ela limita
Entrei na faculdade com 3 anos de trabalho a mais que a maioria dos colegas. Tinha vantagens reais. Mas experiência também cria pontos cegos que levei tempo para perceber.
Primeiro projeto em grupo na faculdade: o que não aprendi em nenhum tutorial
Trabalhar em grupo num projeto de faculdade parece simples. Na prática é onde você aprende divisão de trabalho, conflito de código, e por que comunicação é parte do trabalho técnico.
Linux na universidade: da curiosidade para ferramenta de trabalho real
Eu já usava Linux no trabalho antes de entrar na faculdade. Na universidade, aprendi o que eu não sabia que não sabia — e por que o terminal é onde a produtividade de verdade acontece.
Programação vs. TI: quando percebi que eram mundos completamente diferentes
Entrei na faculdade achando que TI e desenvolvimento eram a mesma coisa. Não eram. A descoberta mudou o que eu queria aprender e como eu me via na área.
O gap entre o currículo de Ciência da Computação e o que eu já sabia fazer
Entrei na faculdade sabendo operar servidores Linux, configurar VPN, manter rede corporativa. O currículo de CC ensinava outra coisa. Os dois mundos levaram tempo para se encontrar.
A aposta de 2017: largar tudo e ir estudar numa cidade diferente
Em 2017 tomei uma decisão que parecia arriscada: largar emprego, mudar de cidade sozinho e ir para a faculdade. O que me convenceu foi inverter a pergunta.
Primeira semana na faculdade depois de 3 anos trabalhando
Voltei para sala de aula depois de 3 anos em produção. A sensação foi estranha — não porque foi difícil, mas porque foi diferente do que eu esperava.
Largar emprego estável, mudar de cidade e ir estudar
Depois de 3 anos na Oi, tomei uma decisão que não fazia sentido para muita gente: largar o emprego, mudar de cidade e ir fazer faculdade. O que me levou até ali.
Firewall na prática: o que passa, o que não passa, e o que todo mundo esquece de documentar
Assumi manutenção de um firewall com 200 regras. Metade delas, ninguém sabia mais por que existiam. O que isso me ensinou sobre princípio de menor privilégio antes de eu saber o nome.
S1: o que anos de infra ensinam sobre sistemas antes de você escrever uma linha de código
Saindo da Oi para a universidade, o que carreguei não era certificação nem título — era modelo mental de como sistemas falham, dependem uns dos outros, e precisam de governança para funcionar. Uma síntese da S1.
O que SLA significa quando você tem que cumprir
Tinha SLA de atendimento: 2 horas para responder, 8 horas para resolver. No começo era número no contrato. Com o tempo entendi que era compromisso com uma pessoa real esperando.
Ticket de suporte: como aprender a priorizar por impacto real, não por urgência percebida
Fila de chamados com 30 tickets. Todo mundo diz que o dele é urgente. Como separar urgência real de percebida — e o que isso ensina sobre triagem em qualquer contexto técnico.
Crescer na mesma função quando promoção não existe: o que expanda seu escopo significa na prática
Fui analista de TI por anos sem promoção formal. Mas o escopo do que eu fazia mudou drasticamente. O que isso ensina sobre crescimento de carreira quando a estrutura não acompanha.
Rede sem documentação: como operar o que você não construiu
Herdei uma rede corporativa sem diagrama, sem inventário, com configurações que ninguém sabia de onde vinham. O que aprendi sobre operar sistemas legados sem história documentada.
TCP/IP na prática: o que os pacotes fazem enquanto a página carrega
Aprendi TCP/IP não em livro mas no Wireshark, olhando para o tráfego real de uma rede com problema. O que isso muda em como você escreve código.
Incidente humano: como uma decisão bem-intencionada causou downtime
Tomei uma decisão que parecia certa, foi bem-intencionada, e causou downtime de 40 minutos. O que isso ensina sobre a diferença entre intenção e impacto em operações.
O backup que não existia: o que aprendi sobre disaster recovery antes de saber o nome
O backup estava configurado. Rodava toda noite. O problema: nunca tinha sido testado. Quando precisamos restaurar, descobrimos que o backup estava corrompido há semanas.
MikroTik RouterOS: quando roteador se torna ferramenta de aprendizado de redes
MikroTik foi o equipamento que me fez entender roteamento de verdade — não na teoria, mas configurando rotas, NAT e firewall rules em equipamento real. O que você aprende quando o hardware expõe o protocolo.
VLAN de visitante: por que segmentar rede WiFi é design, não paranoia
Implementei rede WiFi separada para visitantes sem acesso à rede interna. Parecia exagero na época. Não era — e o princípio voltou em zero-trust architecture anos depois.
Active Directory: como autenticação centralizada funciona e o que quebra quando para
Quando o Active Directory tem problema, nada funciona — login, email, VPN, acesso a arquivos. Isso me ensinou o que single point of failure significa antes de eu conhecer o termo.
Meu primeiro mentor técnico: o que aprendi observando alguém mais experiente trabalhar
Ele diagnosticava em minutos o que me levava horas. Não era que sabia mais — era que pensava diferente. O que aprendi observando, não só executando.
Atendimento ADSL na casa do cliente: o que field service ensina sobre sistemas reais
Parte do meu trabalho na Oi era ir até a casa do cliente resolver problema de internet. ADSL, wireless, WPS, roteador mal configurado. O que você aprende sobre sistemas reais quando o ambiente é a sala de visitas de alguém.
Trabalhar em empresa grande sendo júnior: como navegar burocracia sem autoridade
A Oi era grande. Processo, chamado, aprovação, escalada. Como júnior navega isso sem autoridade formal — e o que esse aprendizado vale anos depois em empresa global.
O dia que derrubei a rede de um escritório inteiro
Uma mudança que parecia pequena. Um efeito cascata que eu não antecipei. E o que isso me ensinou sobre fazer mudanças em produção — antes de 'produção' ser uma palavra que eu usava.
DHCP na prática: o conflito de IP que travou um andar inteiro
Um dispositivo com IP estático dentro do range do DHCP. Parece pequeno. Travou um andar inteiro de máquinas por uma hora. O que isso ensina sobre como endereçamento de rede funciona de verdade.
VLANs, GPO e servidor de email: o que aprendi mantendo infra real
Antes de escrever código profissionalmente, passei anos mantendo servidores, switches, VPNs e Linux rodando email corporativo. O que isso ensina que nenhum tutorial de dev cobre.
Como ler log quando você não sabe o que está procurando
Ninguém me ensinou a ler log. Aprendi na prática, com /var/log/syslog aberto e problema não resolvido. O que aprendi sobre investigação antes de conhecer o nome.
Hardware é software: o que trocar placa de rede em produção ensina sobre sistemas
Substituir hardware em servidor em produção parece diferente de fazer deploy de código. Os princípios são os mesmos — e aprendi isso da forma mais tensa possível.
DNS na prática: quando tudo para de funcionar por causa de um registro
Um registro DNS errado derrubou acesso de email de um escritório inteiro por horas. O problema não estava onde todo mundo estava procurando.
Cliente difícil de suporte: o que atender pessoa frustrada ensina sobre comunicação técnica
Quando a internet cai pela terceira vez no mesmo cliente, a solução técnica certa não é suficiente. O que aprendi sobre comunicar problema, causa e resolução para quem não faz ideia do que é BGP.
Meu primeiro servidor Linux sem interface gráfica
Sem GUI, sem clique, sem menu. Só terminal. Foi a coisa mais desorientante e mais formadora que aconteceu no início da minha carreira técnica.
Linux no roteador: o dia que descobri que infra era Linux antes de saber o nome
Meu primeiro computador foi Linux. Meu primeiro emprego foi em rede com Cisco e MikroTik. Demorei um tempo para perceber que os dois mundos eram o mesmo mundo.
O que IT support parece por dentro
Meu primeiro emprego em tecnologia foi suporte de TI na Oi. Não era o que eu imaginava. Foi melhor — porque me ensinou o que a maioria dos devs nunca aprende.
Da concessionária de carros para TI: como a mudança que parecia lateral virou base
Cresci numa família de empreendedores do ramo de carros. A decisão de entrar em tecnologia não foi óbvia de onde eu estava — mas o que aprendi nessa transição moldou tudo que veio depois.