Key Projects
Distributed systems, caching solutions, and real-time applications.
Product Catalog Voice Agent
A distributed conversational AI voice agent specifically designed to answer user questions based on a product's user manual. It uses a multi-stage LLM pipeline that leverages Retrieval-Augmented Generation (RAG) against a Neo4j graph database to find and inject grounded information from the manual, ensuring factual and accurate responses. The system orchestrates a React.js frontend, a Node.js audio gateway with Whisper.cpp for ASR, and a FastAPI backend, all communicating via WebSockets and Server-Sent Events (SSE) for a low-latency, real-time user experience.
View Case Study ->
Distributed Cache Decorator
A Python decorator providing Redis-backed distributed caching with automatic invalidation. When function code changes, the decorator detects modifications via source code hashing and automatically purges stale cache entries across all application instances. This eliminates manual cache management and prevents bugs from outdated cached data in distributed systems.
View Case Study ->
Distributed Rate Limiter
A horizontally scalable rate limiting service using Go, Redis, and Lua scripts. Implements the Token Bucket algorithm with atomic operations to prevent race conditions across distributed server instances. Features NGINX load balancing, Docker containerization, and stateless architecture that can scale by adding more server containers while maintaining consistent rate limit enforcement.
View Case Study ->
Real-time Clipboard Sync
A distributed Go backend enabling instant clipboard synchronization across multiple devices. Uses WebSockets for real-time communication, Redis Pub/Sub for horizontal scaling, and JWT authentication for stateless sessions. The system supports thousands of concurrent connections while maintaining data consistency through PostgreSQL persistence and secure user management with bcrypt password hashing.
View Case Study ->
Technical Writing
Exploring concepts in distributed systems, performance, and data structures.
Node.js Streams Internals
This article explores how Node.js streams work under the hood, tracing the complete journey of HTTP request data from network packets to your application code, and response data from your code back to the network. Covers internal buffering, backpressure mechanisms, and the multi-layered architecture that makes streams efficient.
Read Article ->
MVCC, Autovaccume, and Bloat in PostgreSQL
A comprehensive guide to PostgreSQL's Multi-Version Concurrency Control (MVCC) system. Explores transaction IDs, system columns (xmin/xmax), and infomask flags through hands-on examples using pageinspect. Demonstrates how PostgreSQL maintains data consistency across concurrent transactions and explains the role of vacuum in cleaning up obsolete row versions.
Read Article ->
Building a Distributed Rate Limiter with Go, Redis, and Lua
This article discusses building a distributed rate limiter using Go, Redis, and Lua to control the flow of requests, prevent abuse, ensure fair use, and protect backend resources from overload.
Read Article ->
The Idea Behind Fault-Tolerant Systems
An overview of fault-tolerant systems, which are designed to continue operating without interruption despite the failure of one or more of its components
Read Article ->
Why B-trees Can Shorten SSD Lifespan
An article that explains how traditional databases that use B-Trees data structure and indexes can limit the shelf life of Solid States Drives (SSD).
Read Article ->
Understanding Native Graph Databases: Storage and Processing
An explanation of native graph databases, which are optimized for storing and processing graph data. They use index-free adjacency, meaning that each node directly references its adjacent nodes.
Read Article ->
Understanding the Node.js Event Loop
A look into the Node.js event loop, a mechanism that allows Node.js to perform non-blocking I/O operations despite being single-threaded, by offloading operations to the system kernel whenever possible.
Read Article ->
SSTables and LSM-Trees: The Secret Sauce Behind Modern Database Performance
An article detailing SSTables (Sorted String Tables) and LSM-Trees (Log-Structured Merge-Trees), which are used in modern databases to optimize for high-speed read/write operations and handle massive data sets.
Read Article ->
PostgreSQL Indexes, Shared Buffers, and Performance Optimization
Deep dive into PostgreSQL covering indexes, shared buffers, and memory optimization. Learn why column order matters, how to size shared buffers properly, tackle large dataset challenges through partitioning, and understand MVCC's impact on query performance.
Read Article ->
I specialize in building robust, scalable backend systems and integrating them with clean, performant frontends. My focus is on creating high-impact solutions that drive efficiency and solve complex technical challenges.
Certifications
AWS Certified Developer – Associate