I am a systems and backend engineer focused on high-throughput, cloud-native infrastructure in Go. I operate at the intersection of network sockets, zero-allocation memory pooling (sync.Pool), cache-line contention, and high-concurrency runtime primitives.

• Upstream contributor to Prometheus, Thanos, and OpenCost.
• Building benchmarked, low-latency data plane components (L4 reverse proxies, lock-striped rate limiters, concurrent storage engines).
• Relentless focus on correctness: race verification (go test -race), heap profiling (pprof), and table-driven test suites.

A production-grade API gateway and Layer-4 reverse proxy engineered for minimal overhead under heavy connection loads.

• Lock-Striped Rate Limiter: 32-shard partitioned concurrency model benchmarked at ~7.95M ops/s, completely eliminating global mutex contention.
• Observability & Draining: Integrated gRPC distributed tracing context propagation and clean graceful socket draining on termination.
• Stack: Go · L4 Proxy · Lock Striping · gRPC · Distributed Tracing · Benchmarks

A high-throughput Layer 4 TCP load balancer written in Go with least-connections routing, dynamic health-check daemon, and live Prometheus metric exposition.

• Zero-Allocation Data Plane: Benchmarked at 26 ns/op with 0 heap allocations/op using a global 32KB sync.Pool buffer recycling pipeline.
• Reliability: Built with atomic counters, net/http/pprof runtime profiling, and graceful socket connection draining.
• Stack: Go · TCP Sockets · sync.Pool · Prometheus · pprof · Benchmarks

An in-memory key-value database running over raw TCP sockets with active background TTL expiration.

• Throughput: Clocking 50M+ reads/sec (20.4 ns/op) and 31M+ writes/sec (31.8 ns/op) under -race verification with zero heap allocations on hot paths.
• Concurrency: Thread-safe read/write locking via sharded sync.RWMutex, active background eviction daemon preventing memory leaks.
• Stack: Go · Raw TCP Protocol · sync.RWMutex · Cobra CLI · Benchmarks

A multi-tenant production console that ingests raw production logs, aggregates errors using SHA-256 signatures and sliding-window rate-limiting, and utilizes an AI agent with RAG (pgvector) to draft hotfixes.

• Stack: Go / Next.js · Redis · PostgreSQL + pgvector · Prisma · Docker

• Languages: Go (Runtime internals, Goroutines, Channels, Atomics, Memory Pooling), TypeScript, SQL, Bash
• Systems & Networking: Layer-4 TCP Sockets, gRPC (HTTP/2), Reverse Proxies, Wire Protocols, Lock Striping, Cache Contention Mitigation
• Cloud-Native & Observability: Prometheus (client_golang, PromQL, metric exposition), OpenTelemetry, Jaeger, Thanos, Kubernetes (k8s.io/api, client-go)
• Diagnostics & Profiling: pprof (CPU/Heap/Block), go test -race, Benchmark Suites (testing.B), Linux systems programming, Docker

• Deepening low-level Go runtime internals, lockless data structures, and ring-buffer metric aggregation pipelines.
• Upstream contributions across the CNCF observability ecosystem (Prometheus, Thanos, OpenTelemetry).
• Targeting Tier-1 CNCF LFX Mentorships & GSoC 2027 in cloud-native systems.