Architecture protects product speed
Clear boundaries, explicit contracts and small, cohesive modules keep systems adaptable, without hiding complexity behind generic layers.
Anderson Espindola
I'm a senior software engineer focused on backend. I build APIs, distributed systems and the reliability layer that keeps them running, with TypeScript, Node.js and functional programming. Most of my recent work has been on large-scale fintech at Itaú and PicPay.
14+
years working across backend and product engineering
2
large-scale financial platforms in production (Itaú, PicPay)
15+
languages and tools I use across APIs, data and infrastructure
24/7
reliability and operations as part of the job, not an afterthought
notes.sh
~/systems$start from the product constraints, then the boundaries
~/systems$model the domain as pure transformations
~/systems$ship the service, watch latency, saturation and errors
~/systems$scale with queues, caches and clear contracts
architecture.tstyped boundaries
01type SystemBoundary = {02 domain: PureRules;03 application: UseCases;04 adapters: Ports;05 infrastructure: Effects;06};0708const ship = compose(09 validateContracts,10 isolateSideEffects,11 observeRuntimeBehavior,12 keepProductFeedbackTight,13);About
I build backend that holds up in production and stays easy to understand as the team grows.
I work across backend, distributed systems and reliability, with a bias toward systems that stay readable long after the first release.
My work sits between full-stack delivery, backend architecture, distributed systems and reliability. I care about systems that stay understandable after they ship, and about teams that keep delivering without piling up hidden risk.
I lean on functional programming where it pays off: immutable data, explicit boundaries, composition and isolated effects. OOP, SOLID, Onion and Clean Architecture are practical tools here, not ceremony.
Senior backend engineer
TypeScript & Node.js
Functional programming
Distributed systems
APIs & integrations
Reliability & SRE
TypeScript and functional programming
Distributed backend systems
Performance and reliability
Backend architecture
Engineering philosophy
Good architecture is what keeps a system easy to understand as it grows.
The way I work is built on explicit boundaries, feedback from production and evolving systems over the long term.
Functional core, infrastructure shell
Business rules are modeled as predictable transformations. Infrastructure effects stay isolated, observable and replaceable.
Performance is a design decision
Latency, memory and failure modes are part of the first decisions, not a late optimization pass.
Architecture
Backend architecture guided by Onion and Clean Architecture, with the domain protected at the center.
Business rules stay at the center. Frameworks, runtimes, brokers and databases are replaceable details around them.
Systemsarchitecture
TypeScriptNode.jsReactNext.jsElixirRustKafkaK8sPostgresRedis
Interface
Next.js, API clients, typed contracts
Application
Use cases, orchestration, policy
Domain
Pure rules, value objects, invariants
Infrastructure
Databases, brokers, queues, cloud
Technical expertise
A broad stack, organized by responsibility.
What I use at each layer: interface, backend, data, messaging, operations and design.
Functional JavaScript
Functional JavaScript and TypeScript: pure functions, immutability, composition and isolated side effects.
JavaScriptTypeScriptPure functionsImmutabilityCompositionType-driven design
Frontend systems
React, Next.js and UI architectures built for maintainable, predictable product surfaces.
ReactNext.jsTypeScriptTailwindCSS
Backend platforms
Node.js, Python, Go, C#, Rust and Elixir, and service boundaries that hold up under real load.
Node.jsPythonGolangC#RustElixir
Data and persistence
Relational, document, graph (Neo4j) and cache systems, chosen by the access pattern of the problem.
PostgreSQLMySQLSQL ServerMongoDBNeo4jRedisKeyDB
Messaging and distribution
Event-driven architecture, queues, consistency tradeoffs and async collaboration between services.
KafkaRabbitMQEvent streamsWorkersOutbox patterns
Cloud and operations
Containers, orchestration, deployment flows and observability, built into how I deliver.
DockerKubernetesCI/CDSRECloud-native
Software design
Clean Architecture, Onion Architecture, SOLID, OOP and functional modeling, applied pragmatically.
SOLIDOnion ArchitectureMVCMVTClean Architecture
Throughput
Observability
Scalability
Resilience
Distributed systems
I design services as product infrastructure.
A distributed system is a set of tradeoffs: latency, consistency, isolation, observability and what happens when something fails.
API boundary
typed contracts
Event stream
Kafka / RabbitMQ
Workers
idempotent effects
Storage
SQL / Graph / Cache
Performance engineering
Fast interfaces and predictable systems come from the same discipline.
- SSR and streaming for a fast first paint
- Bundle splitting and lazy sections
- GPU-accelerated motion
- Memoized interaction surfaces
- Operational attention to latency and saturation
Functional programming
Immutable data, composition and explicit effect boundaries make complex backend easier to test, operate and evolve.
Featured projects
Open source with a product-engineering shape.
Public tools that show what I like to build: developer workflows, local-first systems and practical automation.
minuta
MinutaAI
Legal platform for drafting, reviewing and analysing documents, with the Mia assistant supporting the daily work of lawyers and firms.
open https://minutaai.com
AI-assisted document work on a strict, functional, architecture-guarded codebase.
Next.jsReact 19TypeScriptFunctional coreMongoDBOnion Architecture
gestao-paroquial
Gestão Paroquial
Multi-tenant SaaS for parish treasury, organising finances, members and operations across separate workspaces.
open https://gestaoparoquial.com
A real operational platform on a clean monorepo, with isolated domain rules and async workers.
FastifyNext.jsTypeScriptMongoDBRedisBullMQ
@andespindola/brainlink
Brainlink
Local-first knowledge memory for agent workflows, with Markdown vaults, backlinks, indexing and context retrieval.
npm install @andespindola/brainlink
Turns loose notes into engineering context I can actually retrieve.
TypeScriptNode.jsMCPSQLiteCLIKnowledge graph
pingu-dev-agent
Pingu Dev Agent
Real-time pair programming agent for Vim, Neovim and LazyVim workflows, packaged as an npm CLI.
npm install -g pingu-dev-agent
Assistant workflows that live in the terminal, close to how I work.
TypeScriptNode.jsCLINeovimLazyVimAI agent
font-crowquill-mono
Crowquill Mono
A monospace programming font that auto-bolds language reserved words, built from a custom Iosevka build, with a matching monochrome (ink) editor theme for Neovim and VS Code.
brew install --cask font-crowquill-mono
The weight of the syntax itself becomes a readability cue, straight from the typeface.
Type DesignOpenTypeIosevkafontToolsNeovimHomebrew
crowquill-theme
Crowquill Ink
A strictly monochrome (black & white) theme for editors and terminal (Neovim, VS Code, Ghostty, tmux, fish and starship), companion to the Crowquill Mono font.
open https://github.com/andersonflima/crowquill-theme
One ink palette across the whole toolchain, with keywords and shell commands in pure white.
ThemeMonochromeNeovimVS CodeGhosttytmux
Experience timeline
A path through backend, architecture and reliability, mostly inside financial products.
Experience shaped by fintech products, production reliability and backend systems under real operational pressure.
2024 - Present
Software Engineer & SRE
Itau Unibanco
Reliability, deployment flows, cloud operations and backend service evolution in production environments that demand operational discipline.
2021 - 2024
Software Engineer
PicPay
Backend services, GraphQL APIs, Kafka workers, data-intensive flows, Neo4j social graph features and distributed system delivery.
2024 - 2027
Systems Analysis and Development
PUC Minas
A formal engineering foundation, expanded through architecture, backend design, systems thinking and collaborative delivery.
Contact
Have a system worth building? Let's talk.
Open to senior backend, architecture and platform work, and to complex systems that need technical depth.