What I build
I build backend systems that ingest, process, and deliver data reliably in production.
My work includes real-time pipelines, backend services, and event-driven systems used in industrial and high-throughput environments.
I focus on software that stays reliable under load, is easy to evolve, and solves real operational problems.
Systems Over Features
Think in terms of system behavior, data contracts, and failure modes, not just feature delivery.
Built for Load
Design for throughput, correctness, and stable behavior under real production traffic.
Operational Reliability
Prioritize fault isolation, graceful degradation, and systems that stay dependable under pressure.
Evolving Architecture
Build modular backends that are easier to scale, test, and change as requirements grow.
What I work with
Tools and technologies I rely on to build production-grade backend systems.
Languages
Backend & APIs
Messaging & Real-Time
Databases & Caching
Cloud & DevOps
Frontend
Testing & Quality
Featured projects
Production-style systems that showcase backend depth, distributed architecture, and real-world reliability.
How I think about systems
The engineering convictions that shape how I design, build, and reason about backend systems.
Design for Failure First
If the external dependency goes down, if the message duplicates, if the connection drops — what happens? I design around these cases before thinking about the happy path.
Clear Boundaries Enable Scale
Clear service boundaries, explicit data contracts, and isolated failure domains make systems independently scalable and safe to evolve. Monoliths are fine — until they're not.
Idempotency Is Not Optional
In distributed systems, "at-least-once" delivery is the reality. Every write path needs to handle retries safely. I build deduplication and idempotency in from the start.
Observe Before You Optimize
I load-test before tuning, instrument before diagnosing, and measure before claiming improvement. k6 load tests and SonarCloud analysis are part of my build process.
State Reconstruction Over State Storage
Event logs that can replay. Redis-backed hydration that survives restarts. The system's current state should be derivable from its event history — not assumed to persist.
Clarity Scales Better Than Context
Code is maintained longer than it is written. Clarity, explicit contracts, and test coverage are acts of engineering respect.
From the blog
Writing about backend systems, distributed architecture, and engineering decisions.
No articles found. Check back soon.
Let's work together
Open to discussing backend systems, distributed architecture, and practical engineering problems.
Start a conversation
For opportunities, collaborations, or thoughtful engineering discussions.