<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>Bleu — Blog</title>
    <link>https://bleu.builders/blog/</link>
    <description>Technical articles, field notes and decisions from inside the work.</description>
    <language>en</language>
    <atom:link href="https://bleu.builders/blog/feed.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Portfolio Manager: construindo com a 1inch</title>
      <link>https://bleu.builders/pt/blog/bleu-1inch-gestao-portfolio-aqua/</link>
      <guid isPermaLink="true">https://bleu.builders/pt/blog/bleu-1inch-gestao-portfolio-aqua/</guid>
      <pubDate>Tue, 03 Nov 2026 12:00:00 GMT</pubDate>
      <dc:language>pt-BR</dc:language>
      <description>Estamos desenvolvendo com a 1inch um Portfolio Manager sobre Aqua para ajudar gestores a fornecer liquidez mantendo a carteira próxima da alocação escolhida.</description>
      <category>DeFi</category>
      <content:encoded><![CDATA[<p>Para que alguém troque uma criptomoeda por outra, os ativos precisam estar disponíveis para negociação. Em muitas plataformas, eles vêm de reservas formadas por pessoas e organizações que alocam seus ativos para fornecer liquidez e, em contrapartida, recebem taxas pelas negociações.</p>
<p>Devido às negociações e às variações de preço, a composição da carteira pode se afastar da alocação definida pelo gestor, aumentando involuntariamente a exposição a determinados ativos. O processo, portanto, vem acompanhado do trabalho de monitorar e rebalancear o portfólio.</p>
<p>Estamos desenvolvendo com a 1inch um Portfolio Manager sobre Aqua para ajudar gestores de portfólio a usar seus ativos em pools de liquidez, mantendo a carteira próxima da alocação escolhida e reduzindo a necessidade de ajustes manuais.</p>
<h2>O que é um pool de liquidez?</h2>
<p>Quando alguém troca USDC por ETH em uma plataforma que usa pools de liquidez, o ETH recebido sai de uma reserva de criptoativos. O USDC entregue como pagamento entra nessa mesma reserva.</p>
<p>Essa reserva é chamada de pool de liquidez. Ela reúne ativos depositados por pessoas ou organizações e é administrada por um contrato inteligente: um programa na blockchain que executa as trocas conforme regras predefinidas, incluindo como os preços são calculados.</p>
<p>Os pools são usados por muitas corretoras descentralizadas, também chamadas de DEXs. Essas corretoras fazem parte das finanças descentralizadas, ou DeFi, em que operações financeiras são executadas por programas na blockchain.</p>
<h2>Quem fornece os ativos e o que determina o resultado</h2>
<p>Quem deposita os ativos é chamado de provedor ou fornecedor de liquidez (LP, na sigla em inglês). Ele participa dessa reserva para receber uma parcela das taxas cobradas nas negociações que utilizam os recursos fornecidos.</p>
<p>Para um gestor de portfólio, fornecer liquidez não é apenas uma forma de gerar receita com taxas. Também é uma decisão de alocação: quais ativos manter, em que proporção e com qual exposição a risco e potencial de valorização. O resultado da estratégia depende, portanto, da combinação entre as taxas recebidas, o desempenho dos ativos e as mudanças na composição da carteira.</p>
<p>Em um pool de ETH e USDC, por exemplo, o gestor pode alocar parte de cada ativo. Quando outros usuários compram ETH pagando em USDC, a reserva fica com menos ETH e mais USDC. As trocas no sentido contrário fazem o movimento inverso.</p>
<p>Assim, enquanto a estratégia acumula taxas, as negociações também alteram a proporção dos ativos correspondentes à participação do gestor na reserva.</p>
<h2>Por que controlar a alocação do portfólio</h2>
<p>Um gestor pode definir uma alocação desejada para os recursos sob sua administração. Por exemplo, manter metade do valor em ETH e metade em USDC. As negociações e as variações de preço podem afastar a carteira dessa proporção.</p>
<p>Se a participação de ETH passa de 50% para 60% do valor total, a carteira fica mais exposta às oscilações desse ativo. Uma queda em seu preço, por exemplo, passa a ter impacto maior do que o previsto na alocação original. Da mesma forma, reduzir a exposição a um ativo pode limitar a participação da carteira em uma eventual valorização.</p>
<p>Por isso, avaliar a estratégia exige considerar em conjunto as taxas recebidas, o desempenho dos ativos e a evolução da composição da carteira. Monitorar os saldos e fazer os ajustes necessários demanda atenção.</p>
<h2>O que muda com a liquidez compartilhada no Aqua</h2>
<p>Aqua, da 1inch, oferece outra forma de fornecer liquidez. Em vez de depositar os ativos em um pool separado, o provedor autoriza seu uso diretamente de sua carteira. Eles só são transferidos quando uma troca é executada.</p>
<p>O mesmo saldo pode atender a diferentes estratégias de negociação. Essa é a proposta de liquidez compartilhada: usar os ativos da carteira em mais de uma estratégia sem precisar dividir o capital entre pools separados.</p>
<p>Com isso, as negociações de uma estratégia podem alterar os saldos que também estão disponíveis para outras. O controle da composição precisa considerar o conjunto da carteira usado por essas estratégias.</p>
<h2>Como o Portfolio Manager busca ajudar</h2>
<p>O Portfolio Manager que estamos desenvolvendo com a 1inch considera a alocação desejada pelo gestor e os saldos atuais da carteira para calcular os preços oferecidos nas negociações.</p>
<p>A proposta é favorecer trocas que aproximem o portfólio do seu objetivo de alocação, permitindo o uso dos ativos em estratégias de liquidez com menos necessidade de ajustes manuais.</p>
<p>A execução depende do fluxo de ordens e das condições de mercado. Por isso, o produto não garante uma composição exata em determinado prazo, retorno financeiro ou proteção contra perdas.</p>
<p>O projeto está em desenvolvimento e tem como foco gestores de portfólio que utilizam 1inch Aqua.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Sistema lento: como descobrir o que está travando a operação</title>
      <link>https://bleu.builders/pt/blog/sistema-lento/</link>
      <guid isPermaLink="true">https://bleu.builders/pt/blog/sistema-lento/</guid>
      <pubDate>Fri, 16 Oct 2026 12:00:00 GMT</pubDate>
      <dc:language>pt-BR</dc:language>
      <description>Como investigamos a lentidão de uma aplicação, encontramos a causa e acompanhamos o que aconteceu depois da correção.</description>
      <category>observabilidade</category>
      <category>desempenho</category>
      <category>modernização</category>
      <content:encoded><![CDATA[<p>Baseado na apresentação de Juliano Quatrin Nunes no Bleu Bytes.</p>
<p>Você abre uma tela para trabalhar e espera, atualiza a página, tenta de novo e pergunta se mais alguém está com o mesmo problema. A equipe responsável pelo sistema começa a investigar, mas ainda não consegue explicar por que isso está acontecendo.</p>
<p>Para um founder ou gestor, a dificuldade é decidir o próximo passo enquanto o trabalho continua parado (e, se não trabalha com uma empresa como a Bleu, a dificuldade é também esperar resposta do cara de TI que nunca responde, rs).</p>
<p>Pode ser necessário aumentar a capacidade do servidor, corrigir uma funcionalidade ou rever uma atualização recente, mas cada hipótese leva a um tipo diferente de trabalho e investimento. Precisamos saber o que sustenta essa decisão.</p>
<h1>Uma falha no carregamento das páginas</h1>
<p>Passamos por isso em um projeto para uma consultoria do setor de mineração. Estávamos substituindo um sistema antigo que usava uma tecnologia sem suporte adequado, e o novo sistema trouxe funcionalidades para o que antes era trabalho manual (como buscar informações em órgãos reguladores e lançar prazos internos).</p>
<p>Em um determinado dia, algumas páginas não estavam carregando e o time interno começou a relatar dificuldades para usar a aplicação. Já conhecíamos as páginas mais importantes para a rotina, especialmente as de processos e alertas, e usamos os painéis para investigar o que estava acontecendo naquele momento.</p>
<p>Os dados ajudaram a localizar a falha e resolvemos o problema rapidamente. Depois da correção, continuamos acompanhando a aplicação para conferir se as páginas voltavam a carregar e se ainda havia usuários afetados.</p>
<h1>Como saber por que um sistema está lento</h1>
<p>Uma reclamação de lentidão descreve o que a pessoa está vendo na tela, mas ainda deixa várias causas em aberto. Para investigar, precisamos acompanhar quanto tempo as operações levam, quantas vezes são executadas e o que aconteceu no período em que houve o problema.</p>
<p>Essa capacidade é chamada de observabilidade. Ela permite entender o comportamento de um sistema pelos dados que ele produz, conforme a definição do <a href="https://opentelemetry.io/pt/docs/concepts/observability-primer/">OpenTelemetry</a>.</p>
<p>No projeto, organizamos essas informações em painéis e passamos a comparar os momentos de lentidão com o funcionamento habitual da aplicação. Conseguimos verificar se uma operação estava demorando mais, se estava sendo executada com uma frequência diferente ou se alguma etapa concentrava boa parte do tempo de resposta.</p>
<p>Isso nos deu uma forma de conferir as hipóteses antes de escolher o que mudar.</p>
<h1>O que encontramos durante o incidente</h1>
<p>Ao consultar o painel, encontramos um aumento no tempo de resposta, mas foi o volume de chamadas que direcionou a investigação, que precisava ser rápida e efetiva: os prazos de mais de 40 mil processos dependiam daquele fluxo.</p>
<p>Em períodos normais, as operações mais acessadas recebiam cerca de 40 a 50 chamadas a cada cinco minutos. Durante o incidente, uma única operação chegou a aproximadamente 3 mil chamadas no mesmo intervalo.</p>
<p>Ao analisar os registros e o código, encontramos uma falha na tela: em determinadas condições, ela fazia um pedido ao servidor e repetia esse pedido enquanto esperava terminar de carregar. O ciclo gerava novas chamadas e dificultava o próprio carregamento, mantendo o comportamento que provocava a sobrecarga.</p>
<p>Corrigimos o código e continuamos acompanhando o painel. Depois da publicação, porém, apareceram novos picos porque algumas pessoas ainda estavam com a versão anterior aberta no navegador e continuavam gerando chamadas repetidas.</p>
<p>Foi necessário orientar esses usuários a recarregar a aplicação e adicionar um limite para conter o excesso de solicitações. Essa proteção conteve a sobrecarga provocada pelas versões antigas, enquanto os dados nos permitiram acompanhar o efeito da correção e das chamadas que ainda chegavam.</p>
<h1>O que um founder pode pedir à equipe responsável pelo sistema</h1>
<p>Não é necessário conhecer a arquitetura da aplicação para acompanhar uma investigação, mas sim entender como a equipe chegou à causa apontada e o que vai continuar acompanhando depois da correção. Essas perguntas ajudam a tornar a conversa mais concreta:</p>
<table>
<thead>
<tr>
<th>Pergunta</th>
<th>O que a resposta ajuda a entender</th>
</tr>
</thead>
<tbody><tr>
<td>Quais tarefas estão sendo afetadas?</td>
<td>Onde a lentidão está atrapalhando o trabalho</td>
</tr>
<tr>
<td>O que mudou em relação ao funcionamento habitual?</td>
<td>Quais hipóteses têm apoio nos dados e merecem ser investigadas primeiro</td>
</tr>
<tr>
<td>Que evidência sustenta a causa apontada?</td>
<td>Como a equipe relacionou o problema observado à mudança proposta</td>
</tr>
<tr>
<td>Como vamos verificar se a correção funcionou?</td>
<td>Que dados serão acompanhados e quais tarefas serão conferidas com os usuários</td>
</tr>
<tr>
<td>Quem ainda pode estar enfrentando o problema?</td>
<td>Se há sessões antigas ou outras situações que precisam de atenção</td>
</tr>
</tbody></table>
<p>Começar com hipóteses faz parte da investigação. Neste projeto, tínhamos dúvidas sobre a infraestrutura, a comunicação entre partes da aplicação e o código, mas só conseguimos avançar quando passamos a conferir essas possibilidades com os dados do sistema.</p>
<p>O mesmo vale para a correção. Se tivéssemos encerrado o acompanhamento logo depois da publicação, as sessões com a versão anterior continuariam provocando o problema sem que tivéssemos entendido por quê.</p>
<h1>Um sistema com poucos usuários pode ser essencial para a operação</h1>
<p>O sistema da consultoria era usado por poucas pessoas para acompanhar milhares de processos, e a lentidão atrapalhava quem dependia dele para controlar todos os prazos.</p>
<p>Isso precisa entrar na avaliação de desempenho. Uma ferramenta usada durante boa parte do expediente pode atrasar a rotina inteira, mesmo que tenha um público pequeno, e as tarefas mais importantes para essas pessoas devem orientar o que vamos medir e investigar.</p>
<p>Depois do incidente, usamos os mesmos dados para examinar consultas ao banco e fazer outros ajustes. Conseguimos ver quais etapas demoravam mais e avaliar onde uma mudança no código poderia melhorar o tempo de resposta.</p>
<p>A modernização precisava ser avaliada também por esse uso cotidiano. As novas funcionalidades faziam parte da entrega, assim como entender por que uma página demorava e acompanhar se as mudanças melhoraram o trabalho de quem dependia dela.</p>
<h1>Perguntas frequentes</h1>
<h2>Um sistema lento precisa de um servidor maior?</h2>
<p>Depende da causa. Mais capacidade pode ser necessária quando os recursos disponíveis não atendem à demanda, mas é preciso conferir o que está provocando essa demanda. No caso apresentado, encontramos uma falha que repetia chamadas ao servidor e precisávamos corrigir esse comportamento.</p>
<h2>O que é observabilidade?</h2>
<p>É conseguir entender o que acontece dentro de um sistema: onde ele fica lento, por que uma falha ocorreu e como isso afeta quem usa. Com esses dados, a equipe consegue identificar a causa dos problemas e acompanhar se os ajustes resolveram.</p>
<h2>Como saber se uma correção resolveu o problema?</h2>
<p>Acompanhe os dados depois da mudança, usando os mesmos critérios de medição, e confira as tarefas com os usuários. Neste caso, essa verificação mostrou que algumas pessoas ainda estavam com a versão anterior aberta e continuavam gerando chamadas repetidas.</p>
<h2>Uma aplicação com poucos usuários precisa desse acompanhamento?</h2>
<p>Vale considerar quanto trabalho depende dela. Uma aplicação usada por poucas pessoas pode ser necessária para acompanhar milhares de processos ou cumprir prazos, e as informações coletadas devem ajudar a investigar os problemas que afetam essas tarefas.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Privacidade em blockchain — Zama Developer Program</title>
      <link>https://bleu.builders/pt/blog/privacidade-blockchain-zama/</link>
      <guid isPermaLink="true">https://bleu.builders/pt/blog/privacidade-blockchain-zama/</guid>
      <pubDate>Tue, 06 Oct 2026 12:00:00 GMT</pubDate>
      <dc:language>pt-BR</dc:language>
      <description>Zama | Protegendo Estratégias Financeiras Onchain. Projeto da Bleu que protege o orçamento e as ofertas individuais durante uma recompra de tokens, com divulgação posterior do total comprado.</description>
      <category>blockchain</category>
      <category>privacidade</category>
      <category>Zama</category>
      <category>FHE</category>
      <content:encoded><![CDATA[<p><strong>Zama | Protegendo Estratégias Financeiras Onchain</strong></p>
<p>Projeto da Bleu que protege o orçamento e as ofertas individuais durante uma recompra de tokens, com divulgação posterior do total comprado.</p>
<p>Em blockchains públicas, qualquer pessoa pode acompanhar as transações. Isso facilita observar as operações, mas também pode expor decisões financeiras antes de elas serem concluídas. Camadas de privacidade podem ajudar a proteger essas informações e a estratégia por trás de uma operação.</p>
<p>A Bleu explorou esse desafio em uma recompra de tokens. É comum um protocolo que emite seu próprio token utilizar sua receita para recomprar seu ativo. Isto é feito para o preço do ativo subir e remunerar o investidor.  Contudo, quando a ordem de compra fica visível, outros participantes podem antecipar a demanda, comprar antes do protocolo e vender depois por um preço maior. Com isso, o protocolo pode acabar pagando mais pelos tokens e comprando menos com o mesmo orçamento.</p>
<p>O que construímos: uma recompra com ofertas protegidas</p>
<p>O Confidential Buybacks é uma prova de conceito criada para o Zama Developer Program Builder Track. Na demonstração, uma organização define um orçamento e pessoas que detém o token enviam ofertas de venda com um valor e um preço mínimo. Diferente de uma ordem pública, as quantidades de tokens envolvidos e limites de preços são criptografados.</p>
<p>Esses valores são processados sem serem revelados durante a operação. Para isso, o projeto usa FHE, uma tecnologia que permite fazer cálculos com dados criptografados sem descriptografá-los durante o processamento. A documentação da Zama explica como essa abordagem é aplicada a contratos inteligentes.</p>
<p>Quando uma rodada termina, todas as pessoas envolvidas conseguem avaliar se sua ordem de venda foi bem sucedida e resgatar os tokens.</p>
<p>Demonstração da solução</p>
<p>A Bleu conseguiu montar uma demonstração funcional na rede de testes Sepolia. O fluxo inclui ofertas protegidas, cálculo dentro do orçamento, pagamento ou devolução de tokens e divulgação posterior do total da rodada.</p>
<p>O projeto ainda usa tokens de demonstração e um preço de referência simulado. O estado atual é de prova de conceito, sem auditoria e sem uso em produção.</p>
<p>O impacto para operações financeiras em blockchain</p>
<p>Confidential Buybacks explora uma forma de proteger o orçamento e as ofertas individuais enquanto uma recompra acontece e, depois, publicar o total comprado. A ideia toca um desafio mais amplo das finanças descentralizadas: como manter operações verificáveis sem expor de antemão informações que podem influenciar o mercado. Proteger valores durante a execução pode ajudar a reduzir a exposição de estratégias financeiras; divulgar um resultado agregado depois oferece uma forma de informar o que ocorreu sem publicar cada oferta individual.</p>
<p>O mesmo desafio pode aparecer em pagamentos, distribuição programada de tokens e gestão de tesouraria. A prova de conceito mostra uma abordagem para uma recompra; ainda não valida essas outras aplicações.</p>
<p><a href="https://github.com/bleu/confidential-buybacks">Veja o código e os detalhes do projeto.</a></p>
]]></content:encoded>
    </item>
    <item>
      <title>IA para marketplaces: de dados dos clientes a decisões automatizadas</title>
      <link>https://bleu.builders/pt/blog/ia-para-marketplaces/</link>
      <guid isPermaLink="true">https://bleu.builders/pt/blog/ia-para-marketplaces/</guid>
      <pubDate>Tue, 06 Oct 2026 12:00:00 GMT</pubDate>
      <dc:language>pt-BR</dc:language>
      <description>Como conectar dados de clientes, agentes especializados e decisões automatizadas em um marketplace.</description>
      <category>inteligência artificial</category>
      <category>marketplaces</category>
      <category>agentes</category>
      <content:encoded><![CDATA[<p>Marketplaces acumulam anos de dados sobre o que as pessoas pesquisam, visualizam e compram. Mas, ter esses dados não garante uma boa experiência para o cliente.</p>
<p>Acontece com frequência: compramos um suéter e continuamos vendo anúncios daquele produto por semanas. Inclusive, uma pessoa comentou recentemente que comprou a mesma blusa três vezes porque esqueceu que já tinha uma. Cada vez que via no site ou em um anúncio, pensava: “Nossa, é a minha cara.”</p>
<p>A história é meio tragicômica, mas mostra um desafio real para as empresas por trás dessa experiência de compra: o comportamento atual dos clientes, a eficiência de logística e os dados coletados no marketplace nem sempre se encaixam. Isso significa experiências desagradáveis para um lado (ver o mesmo produto várias vezes, devolver porque comprou repetido) e dinheiro perdido para o outro (esse orçamento em anúncios poderia ter sido melhor aproveitado, os custos de devolução para a empresa, etc.).</p>
<p>A essa altura, já é de conhecimento comum que a IA pode ajudar a conectar esses sinais. Mas, como tirar um projeto assim do papel? A solução precisa considerar o conhecimento existente na empresa (banco de dados, conhecimento interno, etc), como o novo esquema vai lidar com novas informações, quanto tempo uma automação ou um agente pode levar para responder e com que frequência esse conhecimento precisa ser atualizado</p>
<p>Como estruturar uma solução de IA para um marketplace</p>
<p>Em uma palestra, Nancy, arquiteta de soluções da AWS, apresentou três partes do problema: dados de clientes fragmentados, um grande volume de novas interações e situações do dia a dia que mudam o que cada pessoa precisa.</p>
<p>Um modelo treinado com o comportamento passado pode não considerar interações recentes, ou pode considerar com o peso errado novos dados: uma cliente pode normalmente comprar para si mesma e, em outro momento, procurar um presente de Dia das Mães. Se o marketplace interpretar essa compra como um sinal sobre o estilo pessoal dela, pode continuar recomendando aquele estilo de produto mesmo depois da ocasião.</p>
<p>Uma possibilidade é usar agentes de IA especializados. Um agente orquestrador recebe os sinais dos clientes e aciona outros agentes responsáveis por tarefas específicas, como recomendações, textos para anúncios ou ofertas de fidelidade.</p>
<p>O orquestrador é quem considera os objetivos mais amplos da empresa, enquanto os agentes especializados podem ter como meta resultados que ajudam a compor esse objetivo. Exemplo: enquanto um agente foca em aumentar a adesão ao programa de fidelidade, o orquestrador precisa levar esse resultado em conta junto com o objetivo de construir uma relação duradoura com os clientes.</p>
<figure class="ma-diagram" role="img" aria-label="Fluxo geral dos sinais dos clientes até um orquestrador e agentes especializados"><figcaption>Fluxo geral dos sinais dos clientes até um orquestrador e agentes especializados</figcaption><div class="ma-flow"><div>Sinais dos clientes</div><div>Agente orquestrador</div><div>Agentes especializados<br>recomendações · textos para anúncios · fidelidade</div><div>Decisões e ações no marketplace</div></div><p class="ma-loop">Resultados das ações retornam como novos sinais</p></figure><p>O sistema também precisa aprender com o que acontece depois de cada ação. A recomendação ajudou? A cliente respondeu à oferta? Esses resultados viram novos sinais para orientar decisões futuras.</p>
<p class="ma-caption">A arquitetura completa estará disponível no guia para download.</p><p>Como agentes de IA podem responder ao comportamento dos clientes</p>
<p>Considere Sophia, uma possível cliente que visitou o marketplace várias vezes, mas ainda não comprou. O sistema conhece, por exemplo, a região e a idade dela, além de ter sinais de que se interessa por roupas de trabalho e marcas premium.</p>
<p>Ela demonstra interesse. Como o marketplace pode ajudar na decisão de concluir a compra?</p>
<figure class="ma-diagram" role="img" aria-label="Fluxo 1 — Primeiros sinais de Sophia"><figcaption>Fluxo 1 — Primeiros sinais de Sophia</figcaption><div class="ma-flow"><div>Pesquisa blazers</div><div>Clica em três peças</div><div>Aumenta o interesse por roupas de trabalho</div><div>O orquestrador aciona o agente de recomendações</div></div><p class="ma-loop">Sophia recebe sugestões para completar o look</p></figure><p>Se Sophia adicionar uma peça ao carrinho e sair sem comprar, o agente especializado em ofertas também pode testar o frete grátis, caso esse tipo de campanha esteja dando resultado para um grupo de clientes com características parecidas com as dela. A decisão se baseia também no grupo à que ela pertence, não apenas no comportamento de Sophia.</p>
<p>O papel desse agente é descobrir quais ofertas ajudam clientes como Sophia a comprar naquele momento da jornada. Para isso, ele precisa de limites claros: o que pode testar e quais informações deve considerar. O contexto precisa ser específico o bastante para orientar a decisão, sem incluir ruído a ponto de dificultar uma resposta útil.</p>
<figure class="ma-diagram" role="img" aria-label="O orquestrador aciona um agente especializado e fornece contexto"><figcaption>O orquestrador prepara o contexto para a tarefa</figcaption><div class="ma-arch"><div><strong>Orquestrador</strong>Escolhe o agente especializado</div><div><strong>Tarefa</strong>O que o agente precisa decidir</div><div><strong>Sinais e contexto</strong>Informações relevantes sobre a cliente e o momento</div><div><strong>Limites</strong>O que o agente pode testar e considerar</div><div class="wide"><strong>Agente especializado</strong>Recebe o contexto necessário para produzir uma resposta útil</div></div></figure><p>Como usar automação para decisões em tempo real</p>
<p>No exemplo de Nancy, o sistema precisava atender até 300 milhões de usuários. Nessa escala, o marketplace precisa considerar quanto tempo cada decisão leva e o custo dela. Os clientes esperam uma experiência rápida. Sophia não vai perder tempo esperando se o marketplace, onde ela nunca comprou, parecer lento ou não responder.</p>
<p>O agente pode seguir caminhos diferentes conforme as informações disponíveis. Se tiver sinais recentes suficientes sobre a cliente, pode usar os dados já armazenados. Se isso não for suficiente, pode recorrer a padrões de um grupo de clientes relevante. É uma questão de quanto do conhecimento já está “pronto” para ser acionado, ou quanto é necessário colocar capacidade analítica de IA para definir o próximo passo.</p>
<figure class="ma-diagram" role="img" aria-label="Fluxo 2 — Escolher um caminho mais rápido para decidir"><figcaption>Fluxo 2 — Escolher um caminho mais rápido para decidir</figcaption><div class="ma-branches"><div><strong>Sinais recentes desse cliente</strong>Usar as informações disponíveis sobre ele</div><div><strong>Pouco histórico do cliente</strong>Combinar o comportamento observado com padrões de compradores parecidos</div></div><p class="ma-loop">Enviar o contexto relevante ao agente; receber uma recomendação sem executar todo o processo de decisão</p></figure><p>Vimos uma ideia relacionada em um marketplace de alimentos com que a Bleu trabalhou. A plataforma conecta fornecedores a compradores de médio porte, como supermercados. <a href="https://bleu.builders/cases/animal-protein/">Leia o case completo.</a></p>
<p>Um supermercado novo talvez ainda não tenha navegado o suficiente para que o marketplace entenda suas preferências. O sistema pode consultar o que supermercados parecidos na região costumam comprar e combinar esses padrões com os sinais do novo comprador, como cliques em produtos premium.</p>
<p>Como avaliar agentes de IA em um marketplace</p>
<p>Há várias formas de verificar se os agentes estão tomando boas decisões. Em operações de grande escala, um agente pode avaliar o trabalho de outro. Para uma empresa menor, pode ser mais prático incluir uma pessoa no processo: alguém analisa a ação proposta, corrige o que for necessário e envia esse retorno ao modelo.</p>
<p>A Bleu usou essa abordagem ao criar um modelo de segundo cérebro para uma empresa de consultoria. <a href="https://bleu.builders/cases/second-brain/">Leia o case completo.</a> Um marketplace com milhões de clientes toma um volume muito maior de decisões. Por isso, o processo de avaliação precisa acompanhar essa escala e ajudar a equipe a encontrar problemas.</p>
<figure class="ma-diagram" role="img" aria-label="Diagrama de sinais de negócio e avaliação em um marketplace"><figcaption>Sinais de negócio e avaliação dos agentes</figcaption><div class="ma-arch"><div><strong>Sinais do marketplace</strong>Cliques · etapas da jornada · adições ao carrinho</div><div><strong>Ação dos agentes</strong>Recomendação ou oferta apresentada</div><div><strong>Resultado observado</strong>Resposta da cliente · conversão · etapa abandonada</div><div><strong>Avaliação</strong>Outro agente ou uma pessoa revisa a decisão</div><div class="wide"><strong>Retorno para o sistema</strong>Correções e resultados alimentam as decisões futuras</div></div></figure><p>Um marketplace não precisa começar com uma arquitetura completa de agentes. Pode começar identificando uma decisão sobre o cliente que vale a pena melhorar, quais informações ela exige, em quanto tempo precisa acontecer e como a equipe vai avaliar o resultado.</p>
<p>Por onde começar com IA em um marketplace</p>
<p>Distribuir agentes por toda a operação sem priorizar onde eles podem ajudar pode levar a uma solução que não funciona bem na prática. E, quando o marketplace já está em operação, introduzir agentes sem planejamento adequado pode trazer riscos de logística e de experiência do cliente.</p>
<p>Um começo mais seguro é escolher um fluxo que valha a pena melhorar, entender quais dados podem ajudar e definir como avaliar o resultado.</p>
<p>Se sua equipe está tentando decidir onde a IA pode fazer diferença, o <a href="https://bleu.builders/guia-ia/">Guia de IA da Bleu</a> ajuda a comparar oportunidades e escolher um primeiro projeto para testar.</p>
]]></content:encoded>
    </item>
    <item>
      <title>CoW Protocol | Criando a Infra que Desbloqueia Escala de Provedores</title>
      <link>https://bleu.builders/pt/blog/bring-your-own-solver/</link>
      <guid isPermaLink="true">https://bleu.builders/pt/blog/bring-your-own-solver/</guid>
      <pubDate>Tue, 15 Sep 2026 12:00:00 GMT</pubDate>
      <dc:language>pt-BR</dc:language>
      <description>Um projeto de infraestrutura pra CoW DAO: permitir que provedores externos passem a atuar na plataforma sem burocracia no credenciamento junto ao time da CoW.</description>
      <category>CoW Protocol</category>
      <category>infraestrutura</category>
      <category>BYOS</category>
      <content:encoded><![CDATA[<p>Parceria de Infraestrutura — CoW Protocol</p>
<h1>O que a CoW faz, na prática</h1>
<p>A CoW atua como um intermediário para a troca de criptomoedas. Ela não fecha a troca sozinha: publica o pedido e deixa vários provedores de câmbio disputarem por ele, cada um oferecendo sua própria cotação. A CoW compara essas ofertas, fecha com quem dá o melhor preço, e repassa esse preço para quem pediu a troca.</p>
<p>Até agora, só um grupo seleto e bem avaliado de provedores podia entrar nessa disputa. Fazer parte desse grupo exige meses de revisão técnica, um depósito de segurança considerável e validação jurídica (razoável para quem já opera grande volume, pesado demais para quem só tem uma boa cotação para oferecer num tipo específico de troca).</p>
<ol>
<li>Alguém publica uma ordem</li>
<li>Provedores de criptomoedas oferecem suas cotações</li>
<li>Melhor preço vence</li>
<li>A operação é executada</li>
</ol>
<h1>O custo do modelo atual</h1>
<p>A CoW DAO (a organização que governa a CoW) queria mais provedores disputando, não menos, já que mais provedores significa preço melhor para quem troca. Ao mesmo tempo, cada novo provedor aumenta os riscos da operação — e é justamente por isso que o processo de credenciamento exige tantas garantias.</p>
<p>Eles buscavam um jeito de deixar provedores menores e independentes disputarem trocas individuais, sem herdar o risco que o processo de avaliação original existia justamente para evitar. Foi esse o briefing que recebemos.</p>
<h1>O que construímos: BYOS</h1>
<p>BYOS (sigla de Bring Your Own Solver) é o sistema que desenhamos, e que estamos construindo agora, pra CoW DAO. Ele deixa provedores independentes entrarem direto na disputa de cotações, receberem quando vencem uma troca, e responderem quando não entregam, sem nunca tocar no núcleo da CoW ou guardar o dinheiro de quem está trocando.</p>
<p>Três mecanismos tornam isso possível.</p>
<h2>Isolamento</h2>
<p>Cada provedor recebe uma via privada e de uso único para cada troca. O dinheiro entra e sai dentro da mesma transação, sem ficar exposto durante o processo. As vias são isoladas umas das outras, e cada provedor só tem acesso à própria operação.</p>
<h2>Depósito</h2>
<p>Para entrar, o provedor deixa um depósito de segurança — a mesma lógica de uma caução de aluguel. Ele é debitado automaticamente no instante em que uma troca falha on-chain, ou manualmente, após revisão, se o provedor quebra as regras de conduta da disputa.</p>
<h2>Monitoramento</h2>
<p>Uma camada de monitoramento confere cada troca no momento em que ela se conclui, confirma que aconteceu do jeito esperado, e congela a conta de um provedor antes que um padrão de mau comportamento cause mais dano.</p>
<h1>Como isso está sendo construído</h1>
<h2>M1 · Design e Contratos</h2>
<p>6 semanas</p>
<h3>Provar que é seguro antes</h3>
<p>Construir e testar sob estresse as duas peças que garantem segurança — a via isolada e o contrato de depósito — contra uma bateria de cenários adversariais, antes de escrever qualquer coisa que toque uma troca real.</p>
<h2>M2 · Motor e Staging</h2>
<p>5 semanas</p>
<h3>Conectar e observar rodando</h3>
<p>Conectar a BYOS ao motor de comparação de preços já existente da CoW e rodar numa rede de teste pública, com pelo menos um provedor externo de fato disputando cotações.</p>
<h2>M3 · Lançamento</h2>
<p>3 semanas</p>
<h3>Ir ao ar, aos poucos</h3>
<p>Corrigir o que a auditoria de segurança independente encontrar, lançar primeiro numa rede menor, depois na principal — com um provedor externo de verdade fechando trocas reais.</p>
<h1>O potencial de impacto</h1>
<p>Hoje, o número de provedores que competem por cada troca na CoW é limitado pela capacidade do time da CoW DAO de atrair e avaliar novos participantes. A BYOS tira essa dependência: a disputa por preço passa a crescer com o interesse do mercado, não com a capacidade de avaliação de um time. Isso abre espaço pra cobrir trocas que hoje nenhum provedor credenciado prioriza, e pra capturar mais do volume que hoje vai pra corretoras tradicionais — sem que a CoW DAO precise crescer o time que audita e sustenta essa competição.</p>
<p>A BYOS participa do mecanismo de recompensa padrão da CoW e foi desenhada pra se sustentar com as trocas que vence, sem depender de subsídio contínuo depois do lançamento. É mais um capítulo de uma parceria de infraestrutura de vários anos entre a Bleu e a CoW Protocol.</p>
<p>O alcance real desse potencial depende de quantos provedores externos entrarem depois do lançamento.</p>
<p>Bleu — engenheiros de produto que entendem o problema antes de pegar nas ferramentas.</p>
]]></content:encoded>
    </item>
    <item>
      <title>Antes de automatizar, mapear a operação</title>
      <link>https://bleu.builders/pt/blog/o-pedido-era-automacao/</link>
      <guid isPermaLink="true">https://bleu.builders/pt/blog/o-pedido-era-automacao/</guid>
      <pubDate>Thu, 23 Jul 2026 12:00:00 GMT</pubDate>
      <dc:language>pt-BR</dc:language>
      <description>O que encontramos ao acompanhar uma operação que atende a indústria de mineração antes de propor qualquer sistema.</description>
      <category>descoberta</category>
      <category>operação</category>
      <category>automação</category>
      <content:encoded><![CDATA[<p>O fundador pediu automação. Eram quatro décadas de operação em mineração e meio ambiente, milhares de processos ativos e demandas importantes chegando diretamente pelo WhatsApp dele. À primeira vista, fazia sentido tirar a rotina manual do caminho.</p>
<p>Antes de propor qualquer sistema, passamos um dia no escritório da consultoria. Entrevistamos o fundador, a responsável administrativa que controla as exigências há 24 anos, o geólogo do fluxo minerário e o coordenador ambiental. Não para cumprir uma etapa de diagnóstico: o que aparece em uma reunião não é a operação inteira.</p>
<p>A imersão mostrou que a rotina reunia o conhecimento de poucas pessoas-chave. Automatizar apenas uma etapa preservaria a concentração de contexto. Por isso, o trabalho começou pelo mapa da operação inteira.</p>
<p>Mapeamos sete fluxos operacionais, agrupamos nove dores e nomeamos quatro problemas centrais. Isso virou um documento de decisão: diagnóstico, frentes priorizadas, o que fica pra depois. Liderança e equipe passaram a discutir a operação com os mesmos nomes.</p>
<p>A primeira entrega saiu antes de o plano fechar. Um monitor regulatório lê o Diário Oficial e o SEI todos os dias e cruza as publicações com os processos da consultoria. Quando a exigência aparece primeiro no SEI, o time ganha tempo antes da publicação no DOU. Em mineração, um prazo perdido pode parar a operação de um cliente.</p>
<p>A experiência da migração anterior orientou uma transição em camadas: o sistema sugere, uma pessoa confirma e a autonomia cresce conforme a equipe valida a ferramenta nova.</p>
<p>Na conversa de encerramento, o fundador resumiu o resultado que buscava: mais tempo para visitar clientes. Automatizar foi o gatilho do contato. O trabalho é mudar a operação em fases, sem parar o que está rodando.</p>]]></content:encoded>
    </item>
    <item>
      <title>Como validamos um marketplace antes da IA ficar pronta</title>
      <link>https://bleu.builders/pt/blog/validar-antes-da-ia-ficar-pronta/</link>
      <guid isPermaLink="true">https://bleu.builders/pt/blog/validar-antes-da-ia-ficar-pronta/</guid>
      <pubDate>Thu, 23 Jul 2026 12:00:00 GMT</pubDate>
      <dc:language>pt-BR</dc:language>
      <description>A decisão de separar a validação de mercado do treinamento do modelo em uma empresa de proteína animal.</description>
      <category>validação</category>
      <category>IA</category>
      <category>marketplace</category>
      <content:encoded><![CDATA[<p>A empresa chegou com dois produtos pra construir: um marketplace de carcaças e um sistema de IA para análise de qualidade. A tentação era tratar tudo como um projeto só, porque no desenho final um alimenta o outro.</p>
<p>Só que os dois têm relógios diferentes. Treinar e validar o modelo leva tempo. O marketplace começa a ensinar alguma coisa quando compradores reais respondem. Amarrar um ao outro significaria passar meses sem aprender sobre o mercado.</p>
<p>Dividimos o trabalho em duas frentes independentes. Uma ficou com o sistema de análise de qualidade, usando os dispositivos OAK-1 e o pipeline de IA. A outra ficou com o marketplace, que saiu com fotos enviadas manualmente pelos fundadores. Assim, os compradores puderam testar a vitrine antes de o modelo ficar pronto.</p>
<p>Essa separação levou a pergunta real a campo cedo. Passamos a primeira semana dentro do frigorífico, acompanhando o carregamento de caminhões, a escolha de carcaças e a gestão dos pedidos. Foi de lá, não do briefing, que saiu a decisão principal: um marketplace aberto reduziria o controle do frigorífico sobre a composição do estoque. O modelo virou estoque controlado.</p>
<p>A Bleu conduziu a validação de mercado enquanto os fundadores cuidavam da captação. Testamos a vitrine com açougues e supermercados, e os testes de usabilidade mudaram os fluxos antes da construção completa.</p>
<p>O piloto entrou no ar em um frigorífico real, com vendedores e compradores reais, enquanto o modelo ainda era treinado. O produto abriu conversas com 26 frigoríficos no pipeline da incubadora; esse número representa oportunidade comercial, não adoção concluída. Quando a IA ficar pronta, ela entrará em um produto ao qual o mercado já respondeu.</p>
<p>Quando uma parte do produto segue o prazo da pesquisa e outra precisa responder ao mercado, separar as duas não é gambiarra. É o que deixa a empresa apresentar evidência em vez de tese.</p>]]></content:encoded>
    </item>
    <item>
      <title>30 meses sem virar carga de gestão</title>
      <link>https://bleu.builders/pt/blog/30-meses-sem-virar-carga-de-gestao/</link>
      <guid isPermaLink="true">https://bleu.builders/pt/blog/30-meses-sem-virar-carga-de-gestao/</guid>
      <pubDate>Thu, 23 Jul 2026 12:00:00 GMT</pubDate>
      <dc:language>pt-BR</dc:language>
      <description>O que a relação com o CoW Protocol exigiu na prática: pegar contexto, decidir com pouca especificação e responder por iniciativas completas.</description>
      <category>parceria</category>
      <category>delegação</category>
      <category>autonomia</category>
      <content:encoded><![CDATA[<p>Existe um medo legítimo em delegar uma frente inteira: ganhar um fornecedor pra gerenciar. Se cada entrega exige especificação completa, acompanhamento e cobrança, o time não se livrou do trabalho. Trocou execução por coordenação.</p>
<p>Nossa parceria mais longa, mais de 30 meses com o CoW Protocol, funciona porque essa troca não aconteceu. Nesse período saíram 16 iniciativas: SDKs, re-arquitetura de frontend, ferramentas de AMM, dados de governança. E o time principal seguiu concentrado no protocolo.</p>
<p>Olhando pra trás, três práticas explicam por que isso não virou carga de gestão.</p>
<p>A primeira: pegar o problema, não o ticket. As iniciativas chegam com pouca especificação. A gente monta o plano, valida a direção e toca. O custo de escrever a especificação completa é exatamente o custo que o time quer evitar quando delega.</p>
<p>A segunda: decidir dentro do contexto, não em abstrato. Re-arquitetar o SDK TypeScript ao redor do Viem, com adaptadores pra Ethers v5, v6, Viem e Wagmi, exigiu entender por que o ecossistema estava concentrado em um único stack e como preservar a compatibilidade em cada caminho.</p>
<p>A terceira: responder por iniciativas completas, não por tarefas. O AMM Deployer saiu em duas semanas porque o pacote inteiro era nosso pra resolver, e não uma lista de tickets repartida entre dois times.</p>
<p>O teste honesto pra qualquer relação desse tipo vem depois de alguns meses: o cliente está gastando mais ou menos tempo com a frente que delegou? No caso da CoW, a resposta aparece na rotina do time principal, que segue no protocolo em si.</p>]]></content:encoded>
    </item>
    <item>
      <title>Zero-Downtime Deployments for Ponder Indexer</title>
      <link>https://bleu.builders/blog/ponder-zero-downtime-deployments/</link>
      <guid isPermaLink="true">https://bleu.builders/blog/ponder-zero-downtime-deployments/</guid>
      <pubDate>Wed, 28 Jan 2026 12:00:00 GMT</pubDate>
      <dc:language>en</dc:language>
      <description>Using a schema-based blue-green approach for Ponder deployments.</description>
      <category>ponder</category>
      <category>crypto</category>
      <content:encoded><![CDATA[<p>Blockchain indexers present a unique challenge for deployments. Unlike typical stateless web services, indexers maintain significant state. They need to process and store historical blockchain data, which can take hours or even days to synchronize. How do you deploy a new version without interrupting API consumers or losing indexed data?</p>
<p>This article explains how we implemented zero-downtime deployments for our <a href="https://ponder.sh/">Ponder</a> indexer on Kubernetes. Ponder was already designed with this problem in mind. It ships with <a href="https://ponder.sh/docs/api-reference/ponder/database">schema isolation</a>, a <a href="https://ponder.sh/docs/production/self-hosting">standalone serve mode</a> for horizontal scaling, and built-in health endpoints for orchestration. Our job was to wire those primitives into Kubernetes properly.</p>
<h2>The Problem</h2>
<p>Traditional deployment strategies fall short for blockchain indexers.</p>
<p><strong>Rolling deployments</strong> assume new pods can start serving traffic quickly. That&#39;s not the case here. A fresh indexer might need 12+ hours to process historical blockchain data before it can respond to queries. During that time, the deployment appears stuck. Worse, if the new version has bugs, you&#39;ve already terminated working pods.</p>
<p><strong>Traditional blue-green</strong> deployments would require duplicating the entire database. Syncing a new database from scratch defeats the purpose of quick switchovers, and resource costs double during deployment windows.</p>
<p><strong>Canary deployments</strong> split traffic between versions, but an unsynced indexer returns incomplete data. Users would get inconsistent responses depending on which pod handles their request.</p>
<p>We needed something different: a strategy that keeps serving traffic from the old version until the new one is fully ready, shares database resources between versions, allows the new indexer to take as long as needed to sync, and switches traffic atomically once ready.</p>
<h2>The Solution: Schema-Based Blue-Green</h2>
<p>Our approach uses <strong>PostgreSQL schema isolation</strong> combined with <strong>Kubernetes readiness probes</strong> to achieve zero-downtime deployments. The key insight:</p>
<blockquote>
<p>Instead of duplicating databases, we duplicate schemas within the same database. Each deployment version writes to its own schema, and Kubernetes routes traffic only to pods that are ready to serve.</p>
</blockquote>
<h3>Architecture Overview</h3>
<p><img src="/blog/arch-overview-zero-downtime-ponder-deployments.svg" alt="Zero-Downtime Ponder Deployment Architecture"></p>
<h3>Two-Tier Deployment Pattern</h3>
<p>We separate the indexer into two distinct Kubernetes deployments.</p>
<p>The <strong>Indexer Deployment</strong> (<code>bleu-indexer-indexer</code>) runs <code>pnpm ponder start</code>, the process that indexes blockchain data. It runs as a single replica since indexing is a sequential operation. This is where the heavy compute happens: it creates and populates its own database schema, consuming significant CPU and memory.</p>
<p>The <strong>API Deployment</strong> (<code>bleu-indexer-api</code>) runs <code>pnpm ponder serve</code>, a read-only HTTP server that Ponder provides specifically for this pattern. As described in their <a href="https://ponder.sh/docs/production/self-hosting">self-hosting guide</a>, <code>ponder serve</code> runs the API layer without the indexing engine, so multiple replicas can operate behind a load balancer reading from the same database schema. We run 3 replicas in production.</p>
<p>This separation is crucial: the API tier can have multiple replicas for availability and load distribution, while the indexer runs as a single instance doing the heavy lifting. Ponder was designed with this decoupling in mind.</p>
<h2>Implementation Details</h2>
<h3>Dynamic Schema Naming</h3>
<p><a href="https://ponder.sh/docs/api-reference/ponder/database">Ponder uses PostgreSQL schemas to isolate each deployment</a>. The target schema is controlled via the <code>DATABASE_SCHEMA</code> environment variable (or the <code>--schema</code> CLI flag). Ponder&#39;s docs suggest using Kubernetes pod names, git commit hashes, or deployment IDs. We compute it at pod startup:</p>
<pre><code class="language-bash"># From the deployment entrypoint
export DATABASE_SCHEMA=&quot;bleu-indexer-v1.2.3-$(env | grep -E &#39;RPC_URL(_[0-9]+)?=&#39; | sort | sha256sum | cut -c1-8)&quot;
exec pnpm ponder start
</code></pre>
<p>The schema name combines the release name prefix (<code>bleu-indexer</code>), the image tag (e.g., <code>v1.2.3</code>), and a hash of all RPC URL environment variables. This ensures different versions never collide when we push a new release, and changing RPC providers triggers a fresh re-index (intentionally). Multiple schemas coexist in the same database; we clean up old ones periodically.</p>
<p>Ponder enforces a safety rule here: once an instance claims a schema via <code>ponder start</code>, no other instance can use it, even after the original stops. This prevents data corruption during concurrent deployments. It also means crash recovery works automatically: restarting a pod with the same schema resumes indexing from the last checkpoint instead of starting over.</p>
<h3>The Magic: Readiness Probes as Traffic Gates</h3>
<p>The key to zero-downtime is in the readiness probe configuration:</p>
<pre><code class="language-yaml">readinessProbe:
  httpGet:
    path: /ready
    port: 3000
  initialDelaySeconds: 30
  periodSeconds: 10
  failureThreshold: 129600 # ~36 hours
</code></pre>
<p>That <code>failureThreshold: 129600</code> is not a typo.</p>
<p>A new indexer might need 12+ hours to process historical blockchain data. During that time, pods stay &quot;not ready&quot; and Kubernetes won&#39;t route traffic to them. The previous version continues handling all requests. Once <code>/ready</code> returns 200, Kubernetes <a href="https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/">adds the pod to the Service endpoints</a> and traffic shifts automatically. No manual intervention, no deployment scripts.</p>
<p>Ponder ships with two health endpoints designed for exactly this orchestration: <code>/health</code> returns <code>200</code> immediately on process startup, while <code>/ready</code> returns <code>200</code> only when indexing has reached realtime across all chains, returning <code>503</code> during the backfill. We didn&#39;t build custom health checks; we just pointed Kubernetes at what Ponder already provides.</p>
<h3>Liveness vs Readiness</h3>
<p>We use both probes with different purposes:</p>
<pre><code class="language-yaml">livenessProbe:
  httpGet:
    path: /health
    port: 3000
  initialDelaySeconds: 30
  periodSeconds: 10
  failureThreshold: 3

readinessProbe:
  httpGet:
    path: /ready
    port: 3000
  initialDelaySeconds: 30
  periodSeconds: 10
  failureThreshold: 129600
</code></pre>
<p>The <strong>liveness probe</strong> (<code>/health</code>) answers &quot;Is the process alive?&quot; If it fails three times, Kubernetes restarts the pod. The <strong>readiness probe</strong> (<code>/ready</code>) answers &quot;Can this pod serve traffic?&quot; If it fails, Kubernetes removes the pod from the Service endpoints.</p>
<p>A pod can be alive but not ready. That&#39;s the syncing state, and it&#39;s perfectly fine.</p>
<h2>Deployment Flow</h2>
<p>Here&#39;s what happens when we deploy a new indexer version:</p>
<p><img src="/blog/final-arch-ponder-zero-downtime-deployments.svg" alt="Zero-Downtime Ponder Deployment Detect Change"></p>
<h2>Database Architecture</h2>
<p>Ponder requires PostgreSQL and <a href="https://ponder.sh/docs/production/self-hosting">recommends</a> keeping database roundtrip latency under 50ms. We use <a href="https://cloudnative-pg.io/">CloudNativePG</a> to run PostgreSQL directly inside the Kubernetes cluster with a 3-replica cluster:</p>
<pre><code class="language-yaml"># Simplified from our Helm template
apiVersion: postgresql.cnpg.io/v1
kind: Cluster
metadata:
  name: bleu-indexer-postgres
spec:
  instances: 3
  postgresql:
    parameters:
      shared_buffers: &quot;256MB&quot;
      max_connections: &quot;200&quot;
  storage:
    size: 10Gi
</code></pre>
<p>All schemas live in the same database. Connection pools, memory, and storage are shared across versions. Ponder also maintains a shared <code>ponder_sync</code> schema that caches RPC requests across instances (it&#39;s lock-free, so multiple deployments can safely share it). Old indexing schemas stick around for easy rollback if needed. We just point the API back to a previous schema. Cleanup happens as a maintenance task: periodically drop schemas that are no longer in use.</p>
<h2>Configuration</h2>
<p>We use Helm with environment-specific value files. The base <code>values.yaml</code> defines defaults: 1 indexer replica, 2 API replicas, modest resource requests. Production overrides in <code>instances/vultr1.prod.yaml</code> bump resources and enable ingress:</p>
<pre><code class="language-yaml"># values.yaml
indexer:
  replicas: 1
  resources:
    requests:
      cpu: 500m
      memory: 512Mi

api:
  replicas: 2
  resources:
    requests:
      cpu: 500m
      memory: 512Mi

postgres:
  instances: 3
  storage:
    size: 10Gi
</code></pre>
<pre><code class="language-yaml"># -- production overrides `instances/vultr1.prod.yaml`
indexer:
  resources:
    requests:
      cpu: 1000m
      memory: 2Gi
    limits:
      memory: 4Gi

ingress:
  enabled: true
  hosts:
    - host: api-v3.bleu.builders
      paths:
        - path: /
          pathType: Prefix
  tls:
    - secretName: bleu-indexer-tls
      hosts:
        - api-v3.bleu.builders
</code></pre>
<p>Sensitive configuration like RPC URLs and API keys live in Kubernetes Secrets, referenced via <code>envFrom</code>. We use <a href="https://github.com/stakater/Reloader">Stakater Reloader</a> to automatically restart pods when secrets change. Just annotate the deployment with <code>reloader.stakater.com/auto: &quot;true&quot;</code>.</p>
<h2>Why This Works</h2>
<table>
<thead>
<tr>
<th>Aspect</th>
<th>Traditional Blue-Green</th>
<th>Schema-Based Blue-Green</th>
</tr>
</thead>
<tbody><tr>
<td>Database duplication</td>
<td>Full database copy required</td>
<td>Single database, multiple schemas</td>
</tr>
<tr>
<td>Resource cost</td>
<td>2x during deployment</td>
<td>Minimal overhead</td>
</tr>
<tr>
<td>Sync time</td>
<td>Must pre-sync before cutover</td>
<td>Sync happens in-place</td>
</tr>
<tr>
<td>Rollback</td>
<td>Switch DNS/LB back</td>
<td>Old schema still available</td>
</tr>
<tr>
<td>Complexity</td>
<td>Separate infrastructure</td>
<td>Single cluster, schema isolation</td>
</tr>
</tbody></table>
<p>The old version serves traffic until the new one is fully ready (true zero-downtime). No duplicate infrastructure needed, so it&#39;s cost efficient. Kubernetes handles all the orchestration; we don&#39;t maintain custom deployment scripts. Everything lives in version control (GitOps), and we get standard Kubernetes metrics and logs for observability.</p>
<h2>Monitoring</h2>
<p>We track deployments through Kubernetes events for pod lifecycle, Prometheus metrics for indexer sync progress and API latency, and BetterStack for external uptime monitoring:</p>
<pre><code class="language-hcl">resource &quot;betteruptime_monitor&quot; &quot;bleu_indexer&quot; {
  url             = &quot;https://api-v3.bleu.builders/ready&quot;
  monitor_type    = &quot;status&quot;
  check_frequency = 60
}
</code></pre>
<h2>What We Learned</h2>
<p>Readiness probes are your traffic switch—configure them carefully. That 36-hour failure threshold seemed aggressive at first, but it&#39;s exactly what we needed.</p>
<p>Separating indexing from serving was the right call. They have fundamentally different scaling needs: one is a single stateful process, the other is stateless and horizontally scalable.</p>
<p>Schema isolation beats database duplication. It&#39;s simpler, cheaper, and gives us easy rollback for free.</p>
<p>Let Kubernetes do the orchestration. We tried building custom deployment scripts early on. They were fragile and hard to maintain. The readiness probe approach is declarative and self-healing.</p>
<p>Plan for long syncs. Blockchain history only grows. What takes 4 hours today will take 8 hours next year.</p>
<h2>Conclusion</h2>
<p>Zero-downtime deployments for blockchain indexers don&#39;t require complex custom tooling. By combining schema-based isolation, Kubernetes readiness probes, and a two-tier architecture, we get reliable automated deployments where users never see downtime, even when the new indexer takes hours to synchronize.</p>
<p>The key insight is treating the indexer and API as separate concerns with different lifecycles. The indexer is a stateful, slow-starting process. The API is stateless and can scale horizontally. By separating them and using schemas for isolation, we get the benefits of blue-green deployments without the infrastructure overhead.</p>
<h2>References</h2>
<ul>
<li><a href="https://ponder.sh/docs/production/self-hosting">Ponder — Self-Hosting in Production</a> — schema isolation, <code>ponder serve</code>, health endpoints, and the views pattern</li>
<li><a href="https://ponder.sh/docs/api-reference/ponder/database">Ponder — Database Configuration</a> — schema naming, <code>ponder_sync</code> cache, build ID recovery, and lifecycle rules</li>
<li><a href="https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/">Kubernetes — Configure Liveness, Readiness and Startup Probes</a> — how readiness probes control traffic routing</li>
<li><a href="https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#container-probes">Kubernetes — Pod Lifecycle</a> — probe types and their effect on Service endpoints</li>
<li><a href="https://cloudnative-pg.io/">CloudNativePG</a> — PostgreSQL operator for Kubernetes</li>
<li><a href="https://github.com/stakater/Reloader">Stakater Reloader</a> — auto-restart pods on Secret/ConfigMap changes</li>
<li><a href="https://argo-cd.readthedocs.io/">ArgoCD</a> — GitOps continuous delivery for Kubernetes</li>
</ul>
]]></content:encoded>
    </item>
    <item>
      <title>mustachio-ruby: The Postmark template engine in Ruby</title>
      <link>https://bleu.builders/blog/mustachio-ruby/</link>
      <guid isPermaLink="true">https://bleu.builders/blog/mustachio-ruby/</guid>
      <pubDate>Wed, 21 Jan 2026 12:00:00 GMT</pubDate>
      <dc:language>en</dc:language>
      <description>Use your Postmark templates in Ruby with this template engine port.</description>
      <category>ruby</category>
      <category>rails</category>
      <content:encoded><![CDATA[<p>Mustachio is the template engine that powers Postmark templates. While similar to Mustache, it has key differences in syntax for handling arrays and destructuring that make it uniquely suited for email templating.</p>
<p>You might wonder: why create another template engine when we already have excellent solutions like ERB, HAML, or Slim? I wouldn&#39;t recommend abandoning these tools for general web development. However, if you&#39;re already using Postmark templates, mustachio-ruby can help reduce your dependency on Postmark&#39;s service.</p>
<p>At <a href="https://bleu.builders">Bleu</a>, most of our projects use Postmark for transactional emails. We love their service and build our templates directly in their platform. However, in 2024, Postmark experienced an incident where emails took significantly longer to deliver. OTP codes were delayed by 40+ minutes. While rare, this incident made us realize we couldn&#39;t be completely dependent on a single email service. We needed a fallback system using an alternative SMTP provider like Resend.</p>
<h2>The Problem: Template Lock-in</h2>
<p>The quick solution was to create a fallback system that used Resend to send emails:</p>
<pre><code class="language-ruby">module FallbackMailing
  extend ActiveSupport::Concern

  included do
    if Rails.application.config.use_fallback_mailer_service
      def template_model=(model)
        @template_model = model
      end

      def template_model
        @template_model
      end
    end
  end
end

class ApplicationMailer &lt; ActionMailer::Base
  default from: &quot;no-reply@example.com&quot;

  if Rails.application.config.use_fallback_mailer_service
    include FallbackMailing
  else
    include PostmarkRails::TemplatedMailerMixin

    def mail(headers = {}, &amp;block)
      # remove not allowed attributes when using Postmark
      %i[subject header body content_type].each { |key| headers.delete(key) }
      super
    end
  end
end
</code></pre>
<p>This solution allowed us to send emails through alternative SMTP providers, but we faced another challenge: our templates were stored exclusively in Postmark.</p>
<p>We didn&#39;t want to abandon Postmark or maintain duplicate template versions. Our solution was to sync templates—keeping identical copies of our Postmark templates in our codebase. However, we discovered that Postmark&#39;s <a href="https://github.com/ActiveCampaign/mustachio?tab=readme-ov-file">template engine</a> was written in C#, not Ruby. This led us to create <strong>mustachio-ruby</strong>: a Ruby port of the original Mustachio template engine.</p>
<h2>Installation</h2>
<p>Add this line to your application&#39;s Gemfile:</p>
<pre><code class="language-ruby">gem &#39;mustachio-ruby&#39;
</code></pre>
<p>And then execute:</p>
<pre><code class="language-bash">bundle install
</code></pre>
<h2>How mustachio-ruby Works</h2>
<h3>Core Components</h3>
<p>The template engine consists of four main components that work together to parse, compile, and render templates:</p>
<p><strong>1. Tokenizer</strong> (<a href="https://github.com/bleu/mustachio-ruby/tree/main/lib/mustachio_ruby/tokenizer.rb">lib/mustachio_ruby/tokenizer.rb</a>)</p>
<p>Parses raw template strings into structured tokens using regex patterns to identify template elements like variables, conditionals, and loops.</p>
<p><strong>2. Parser</strong> (<a href="https://github.com/bleu/mustachio-ruby/tree/main/lib/mustachio_ruby/parser.rb">lib/mustachio_ruby/parser.rb</a>)</p>
<p>Transforms tokens into executable template functions that can be called with data.</p>
<p><strong>3. Context Object</strong> (<a href="https://github.com/bleu/mustachio-ruby/tree/main/lib/mustachio_ruby/context_object.rb">lib/mustachio_ruby/context_object.rb</a>)</p>
<p>Manages data access during rendering, including:</p>
<ul>
<li>Dot-notation access (<code>user.profile.name</code>)</li>
<li>Parent scope access (<code>../</code>)</li>
<li>Existence checks (<code>exists?</code> method)</li>
</ul>
<p><strong>4. Token Types</strong> (<a href="https://github.com/bleu/mustachio-ruby/tree/main/lib/mustachio_ruby/token_tuple.rb">lib/mustachio_ruby/token_tuple.rb</a>)</p>
<p>Defines template element types: HTML-escaped variables, raw variables, conditional blocks, array iteration, and negated conditionals.</p>
<h2>Basic Usage</h2>
<h3>Simple Variable Interpolation</h3>
<pre><code class="language-ruby">template = MustachioRuby.parse(&quot;Hello {{name}}!&quot;)
content = template.call({&quot;name&quot; =&gt; &quot;World&quot;})
# =&gt; &quot;Hello World!&quot;
</code></pre>
<h3>Array Iteration</h3>
<pre><code class="language-ruby">template = &quot;{{#each Company.ceo.products}}&lt;li&gt;{{ name }} and {{version}} and has a CEO: {{../../last_name}}&lt;/li&gt;{{/each}}&quot;
renderer = MustachioRuby.parse(template)

model = {
  &quot;Company&quot; =&gt; {
    &quot;ceo&quot; =&gt; {
      &quot;last_name&quot; =&gt; &quot;Smith&quot;,
      &quot;products&quot; =&gt; [
        { &quot;name&quot; =&gt; &quot;name 0&quot;, &quot;version&quot; =&gt; &quot;version 0&quot; },
        { &quot;name&quot; =&gt; &quot;name 1&quot;, &quot;version&quot; =&gt; &quot;version 1&quot; },
      ]
    }
  }
}

result = renderer.call(model)
# =&gt;
# &lt;li&gt;name 0 and version 0 and has a CEO: Smith&lt;/li&gt;
# &lt;li&gt;name 1 and version 1 and has a CEO: Smith&lt;/li&gt;
</code></pre>
<h3>Conditional Rendering</h3>
<pre><code class="language-ruby"># Show content when user exists
template = MustachioRuby.parse(&quot;{{#user}}Welcome {{name}}!{{/user}}&quot;)

# Show content when user doesn&#39;t exist
template = MustachioRuby.parse(&quot;{{^user}}Please log in{{/user}}&quot;)
</code></pre>
<h3>Configuration Options</h3>
<pre><code class="language-ruby">options = MustachioRuby::ParsingOptions.new
options.disable_content_safety = true # Disable HTML escaping
options.source_name = &quot;my_template&quot; # For error reporting
options.token_expanders = [expander] # Custom extensions

template = MustachioRuby.parse(source, options)
</code></pre>
<h2>HTML Email Templates</h2>
<p>You can follow the Postmark <a href="https://postmarkapp.com/support/article/1077-template-syntax">template syntax</a> to build your email templates and then use mustachio-ruby (or the original C# version) to interpolate your variables:</p>
<pre><code class="language-ruby">mustachio_template = &lt;&lt;~HTML
  &lt;div&gt;
    &lt;h1&gt;Hello {{name}}!&lt;/h1&gt;
    {{#user}}
      &lt;p&gt;Welcome back!&lt;/p&gt;
    {{/user}}
    {{^user}} &lt;!-- negative check --&gt;
      &lt;p&gt;Please log in&lt;/p&gt;
    {{/user}}
    &lt;ul&gt;
      {{#each items}}
        &lt;li&gt;{{name}}: ${{price}}&lt;/li&gt;
      {{/each}}
    &lt;/ul&gt;
  &lt;/div&gt;
HTML

data = {
  &quot;name&quot; =&gt; &quot;John&quot;,
  &quot;user&quot; =&gt; { &quot;name&quot; =&gt; &quot;John&quot; },
  &quot;items&quot; =&gt; [
    { &quot;name&quot; =&gt; &quot;Apple&quot;, &quot;price&quot; =&gt; 1.50 },
    { &quot;name&quot; =&gt; &quot;Banana&quot;, &quot;price&quot; =&gt; 0.75 }
  ]
}

template = MustachioRuby.parse(mustachio_template)
result = template.call(data)

# =&gt;
# &lt;div&gt;
#   &lt;h1&gt;Hello John!&lt;/h1&gt;
#   &lt;p&gt;Welcome back!&lt;/p&gt;
#   &lt;ul&gt;
#     &lt;li&gt;Apple: $1.5&lt;/li&gt;
#     &lt;li&gt;Banana: $0.75&lt;/li&gt;
#   &lt;/ul&gt;
# &lt;/div&gt;
</code></pre>
<h2>Ruby on Rails Integration</h2>
<p>To use mustachio-ruby in Rails, set the body to be the parsed HTML content and the mail content_type to be &quot;text/html&quot; (or &quot;text/plain&quot; if you&#39;re using mustachio to interpolate variables in a plain text string):</p>
<pre><code class="language-ruby">def mail(headers = {}, &amp;)
  template_content = get_template(template_alias)
  options = MustachioRuby::ParsingOptions.new
  options.disable_content_safety = true
  renderer = MustachioRuby.parse(template_content, options)
  html_content = renderer.call(template_model.deep_stringify_keys)
  headers[:body] = html_content
  headers[:content_type] = &quot;text/html&quot;

  super
end
</code></pre>
<h2>Final Thoughts</h2>
<p>Postmark is a fantastic service, and we continue to use it every day. mustachio-ruby isn&#39;t a replacement—it&#39;s a safety net. It lets you render templates in pure Ruby and send emails even when you don&#39;t have access to Postmark.</p>
<p>If your team relies on Postmark templates, I hope mustachio-ruby gives you the flexibility to build resilient email systems without vendor lock-in.</p>
<h2>Learn More</h2>
<ul>
<li><a href="https://github.com/bleu/mustachio-ruby">mustachio-ruby on GitHub</a></li>
<li><a href="https://postmarkapp.com/support/article/1077-template-syntax">Postmark Template Syntax Documentation</a></li>
<li><a href="https://github.com/ActiveCampaign/mustachio">Original Mustachio (C#) Repository</a></li>
</ul>
]]></content:encoded>
    </item>
  </channel>
</rss>
