Cache Your Sessions: From Memcached to Client-Side Tools
Dormando's classic article about session management with Memcached is an essential guide for any developer who needs to scale web applications without losing session data. The article was widely circulated in the web development community and represents the state of the art for handling user state in distributed systems.
The problem at the time: web servers did not share state. If the load balancer sent the user to a different server, their session disappeared -- shopping carts vanished, login states reset, form data was lost. Memcached solved this by centralizing sessions in a distributed cache layer. It was elegant: instead of sticky sessions (which limited scalability) or database-backed sessions (which were slow), Memcached offered a fast, shared, in-memory session store that any server in the cluster could read from.
The Evolution: From Server to Client
Dormando's article dealt with an infrastructure problem: how to maintain user state between requests to the server. In 2026, the most elegant solution is different: do not depend on the server for anything. Modern web tools can run entirely in the browser. The state lives on the client -- localStorage, sessionStorage, IndexedDB. There is no server session to cache because there is no server involved in the processing.
This shift is not just architectural -- it is philosophical. The entire Memcached conversation was about solving a problem that should not exist in the first place. If the computation happens on the client, there is no session to manage, no state to synchronize across servers, no cache to invalidate. The problem simply disappears. The best solution to a distributed systems problem is often to not have a distributed system.
Privacy as a Consequence
When processing is local, the user's data never leaves their device. No server session means no data on the server means nothing to leak. The architecture that started as a performance optimization (eliminating server round-trips) became a privacy architecture. This matters enormously in Brazil, where data protection under the LGPD (Lei Geral de Protecao de Dados) is legally required. A tool that never sends user data to a server is LGPD-compliant by design -- there is no personal data processing on the server because there is no server processing at all.
Consider what this means for sensitive financial data. When someone calculates their severance pay, they enter their salary, length of service, and termination type. This is private information. With a server-based architecture, this data would travel over the network, sit in a session store (possibly Memcached), and be processed on a machine the user does not control. With a client-side architecture, the data never leaves the browser tab. When the user closes the tab, the data is gone.
The Practical Impact
Stimuli's tools follow this principle rigorously. When you use a calculator, your data (salary, length of service, termination type) never leaves your browser. The calculation happens locally. The result appears instantly. There is no session to cache, no Memcached cluster to maintain, no data center to secure against breaches.
The same applies to every tool in the suite. Generators create valid CPFs and CNPJs using algorithms that run locally. Converters transform data on the device. Simulators model financial scenarios without sending a single byte to any server. The architecture that Dormando wrote about solving -- distributed session management -- is not a problem we need to solve because we designed it out of existence.
From Memcached to no cache needed at all. From sessions spread across server clusters to no sessions at all. From complex distributed state management to state that lives and dies in the browser. Dormando's article matters because infrastructure matters. Stimuli builds tools where infrastructure is invisible -- because the best infrastructure is the one the user never has to think about.
🇧🇷 Em Portugues
O artigo classico de Dormando sobre gerenciamento de sessoes com Memcached e um guia essencial para qualquer desenvolvedor que precisa escalar aplicacoes web sem perder dados de sessao. O artigo foi amplamente circulado na comunidade de desenvolvimento web e representa o estado da arte para lidar com estado do usuario em sistemas distribuidos.
O problema na epoca: servidores web nao compartilhavam estado. Se o load balancer enviasse o usuario para um servidor diferente, sua sessao sumia -- carrinhos de compra desapareciam, estados de login resetavam, dados de formulario eram perdidos. Memcached resolvia isso centralizando as sessoes em uma camada de cache distribuido. Era elegante: em vez de sticky sessions (que limitavam escalabilidade) ou sessoes no banco de dados (que eram lentas), Memcached oferecia um armazenamento de sessoes rapido, compartilhado e em memoria que qualquer servidor no cluster podia ler.
A evolucao: do servidor para o cliente
O artigo de Dormando tratava de um problema de infraestrutura: como manter estado do usuario entre requisicoes ao servidor. Em 2026, a solucao mais elegante e outra: nao depender do servidor para nada. Ferramentas web modernas podem rodar inteiramente no navegador. O estado vive no cliente -- localStorage, sessionStorage, IndexedDB. Nao ha sessao no servidor para cachear porque nao ha servidor envolvido no processamento.
Essa mudanca nao e apenas arquitetural -- e filosofica. Toda a conversa sobre Memcached era sobre resolver um problema que nao deveria existir em primeiro lugar. Se a computacao acontece no cliente, nao ha sessao para gerenciar, nao ha estado para sincronizar entre servidores, nao ha cache para invalidar. O problema simplesmente desaparece. A melhor solucao para um problema de sistemas distribuidos e frequentemente nao ter um sistema distribuido.
Privacidade como consequencia
Quando o processamento e local, os dados do usuario nunca saem do dispositivo. Sem sessao no servidor significa sem dados no servidor significa nada para vazar. A arquitetura que comecou como otimizacao de performance (eliminar round-trips ao servidor) se tornou uma arquitetura de privacidade. Isso importa enormemente no Brasil, onde a protecao de dados sob a LGPD (Lei Geral de Protecao de Dados) e legalmente exigida. Uma ferramenta que nunca envia dados do usuario para um servidor e compativel com a LGPD por design -- nao ha processamento de dados pessoais no servidor porque nao ha processamento no servidor.
Considere o que isso significa para dados financeiros sensiveis. Quando alguem calcula sua rescisao, insere salario, tempo de servico e tipo de demissao. Essa e informacao privada. Com uma arquitetura baseada em servidor, esses dados viajariam pela rede, ficariam em um armazenamento de sessoes (possivelmente Memcached) e seriam processados em uma maquina que o usuario nao controla. Com uma arquitetura no lado do cliente, os dados nunca saem da aba do navegador. Quando o usuario fecha a aba, os dados se vao.
O impacto pratico
As ferramentas do Stimuli seguem esse principio rigorosamente. Quando voce usa uma calculadora, seus dados (salario, tempo de servico, tipo de demissao) nunca saem do seu navegador. O calculo acontece localmente. O resultado aparece instantaneamente. Nao ha sessao para cachear, nao ha cluster Memcached para manter, nao ha data center para proteger contra brechas.
O mesmo se aplica a toda ferramenta da suite. Geradores criam CPFs e CNPJs validos usando algoritmos que rodam localmente. Conversores transformam dados no dispositivo. Simuladores modelam cenarios financeiros sem enviar um unico byte para qualquer servidor. A arquitetura sobre a qual Dormando escreveu -- gerenciamento de sessoes distribuidas -- nao e um problema que precisamos resolver porque nos o projetamos para nao existir.
De Memcached para nenhum cache necessario. De sessoes espalhadas por clusters de servidores para nenhuma sessao. De gerenciamento complexo de estado distribuido para estado que vive e morre no navegador. O artigo de Dormando importa porque infraestrutura importa. O Stimuli constroi ferramentas onde infraestrutura e invisivel -- porque a melhor infraestrutura e aquela que o usuario nunca precisa pensar.