Software Engineer · Distributed Systems · SRE
Building and operating production backend systems with Golang, Java, and Python. Specialising in distributed systems, Kubernetes, and Kafka — writing software that is reliable, observable, and built to scale.
Each project is a complete distributed system — designed, deployed, monitored, and tuned for real workloads. Architecture decisions, metrics, and trade-offs included.
Real-time video analytics platform that processes concurrent camera streams through a bounded goroutine worker pool, runs AI threat detection via a FastAPI inference service, and publishes events to Kafka — with automatic backpressure under load.
Built in Go with a Sarama Kafka producer (Snappy compression), Redis per-camera state with 30-second TTL, and a Python FastAPI inference service running mock CNN analysis at 45ms p99. Goroutine pool drops frames gracefully under backpressure rather than blocking the ingestion path.
Three industries, one through-line: building distributed systems that hold up under real-world traffic, failure modes, and scale.
@ SkylarkLabs
@ NeoXam
@ Seven Mentor
A focused stack covering the full distributed systems lifecycle — from streaming and orchestration to ML serving and observability.
Golang
Python
Java
TypeScript
Kafka
gRPC
NATS
Event-Driven Architecture
CQRS / Event Sourcing
System Design
Microservices
Service Mesh
Kubernetes
Docker
AWS
Helm
Terraform
TensorFlow
PyTorch
Prompt Engineering
LLM Systems
XGBoost
AI Infrastructure
PostgreSQL
Redis
ElasticSearch
ClickHouse
Spark
MySQL
Prometheus
Grafana
OpenTelemetry
Distributed Tracing
Spring Boot
FastAPI
Next.js
React
The metrics below describe the systems I've owned in production — what they handled, what they delivered, and what they survived.
Live camera feeds processed in real time.
Sub-50ms inference pipelines under load.
Across distributed production systems.
Solved across DS, graphs, DP, and concurrency.
Across event-driven backend platforms.
Across Golang, Java, and Python stacks.
Deep dives and engineering notes on the systems-level topics I work in every day. Click any note to read the full article.
Versioning, structured error types, middleware chains, request validation, graceful shutdown, and the patterns that separate a hobby project from a service that runs at 3 AM.
Worker pools, fan-out/fan-in, errgroup structured concurrency, backpressure with buffered channels, and how to keep goroutine counts bounded under unpredictable load.
How to define SLOs that reflect user experience, spend error budgets intentionally, design symptom-based alerts, and build runbooks that survive a 2 AM incident.
How Kafka guarantees ordering, how ISR replication shapes durability, producer acknowledgement trade-offs, consumer group rebalancing, and the knobs that matter for throughput.
When CPU-based HPA stops working — custom metrics with Prometheus Adapter, event-driven autoscaling with KEDA, VPA right-sizing, Cluster Autoscaler tuning, and topology spread.
Idempotency keys, transactional outbox, saga pattern, dead letter queues, event replay strategies, and the operational hygiene needed to keep distributed state correct.
I build infrastructure for the kind of systems that have to be right, fast, and observable at the same time. Distributed by default. Intelligent where it matters.
My work sits at the intersection of distributed systems and AI infrastructure — the layer where latency budgets, fault tolerance, and model behavior all collide. I've built platforms that process thousands of real-time camera streams, financial event pipelines clearing millions of daily transactions, and predictive systems that catch infrastructure failures before they happen.
I care about the parts that don't demo well: backpressure, idempotency, replay semantics, observability, and the operational hygiene that makes 99.99% a sustained number — not a screenshot. Production is the only review that matters.
Outside of work, I'm a long-form thinker on system design, a competitive problem-solver (600+ LeetCode), and a believer that the next decade of AI will be won at the infrastructure layer — not the model layer.
Engineering decisions ripple — through latency, cost, on-call burden, and team velocity. I optimize for the whole graph, not the local edge.
Designs that hold their shape under 10x load. Bounded contexts, idempotent paths, explicit failure modes — by design, not by accident.
ML lives or dies on the systems around it. Feature pipelines, model serving, GPU economics, and observability are the real product.
CAP-aware design, replication topologies, consensus where required, eventual consistency where it suffices — chosen, not assumed.
Domain logic separated from transport, storage, and frameworks. Code that can be tested without infrastructure and replaced without rewrites.
SLOs that mean something, error budgets that get respected, runbooks that are written before the incident — not during it.
Available for software engineering roles across backend, distributed systems, and SRE — and open to advisory work and high-leverage engineering collaborations.
Prefer the direct path? Send a message — I read everything.
Start a Conversation