I am a software engineer who builds distributed systems and backend infrastructure. Most of my work involves figuring out why things break, how to make them faster, and how to keep them running when parts inevitably fail.
I spend a lot of time on the "boring" stuff that turns out to matter: consistency trade-offs, failure modes, and understanding what's actually happening under the hood. Lately, I have been exploring AI engineering: how embeddings work, how to build retrieval systems, and how software engineers can work effectively with LLMs without needing a PhD in machine learning.
I write here to organize my own thinking and share what I learn. If you like understanding how things work rather than just using them, you might find something useful.
Technical areas I explore through writing, building, and hands-on experimentation.
Consensus algorithms, consistency models, fault tolerance, and distributed state management.
Storage engines, query optimization, indexing strategies, and transaction management.
Scalability patterns, architectural trade-offs, and designing for high availability.
Profiling, optimization techniques, bottleneck analysis, and latency reduction.
Kubernetes orchestration, containerization, cloud architecture, and IaC patterns.
RESTful APIs, microservices architecture, data pipelines, and event-driven systems.
RAG systems, vector databases, embedding models, and production ML infrastructure.
Model training, feature engineering, ML pipelines, and deployment strategies.
Break down complex problems to fundamental truths. Build from the ground up, not assumptions.
Every system should behave predictably. Infrastructure as code, deterministic builds, comprehensive testing.
Understand component interactions. Optimize for the whole, consider second-order effects.
Deep dives into distributed systems, performance optimization, and architectural patterns
A deep technical walkthrough of implementing the Raft consensus algorithm — leader election, log replication, durability, fast log backtracking, and the failure modes that taught me what distributed systems actually defend against.
Why one vector per word cannot capture meaning—and what this limitation reveals about the nature of language understanding.
From local context windows to global co-occurrence matrices—understanding how GloVe unifies prediction and counting methods.
Get insights on building scalable systems, performance optimization, and architectural patterns. Be among the first to receive deep technical content as I build this newsletter.
