I'm a backend-first full stack engineer with 3+ years of experience designing and shipping production-grade, distributed systems. I specialize in event-driven architecture, serverless infrastructure, and high-throughput data pipelines — while retaining enough frontend depth to ship features end-to-end without handoffs.

I care deeply about system correctness under failure — idempotency, at-least-once delivery guarantees, race condition safety, and dead-letter queue handling are not afterthoughts in my systems; they're first-class design constraints.

⚙️  Architecture   →   Event-driven · Distributed · Serverless · Domain-Driven
📐  Philosophy     →   Design for failure first. Optimize for scale second.
🔭  Currently      →   Owning backend systems & core business logic at duochat
🌍  Open To        →   Backend / Full Stack roles in product-driven teams

• Architected multi-consumer Kafka pipelines with topic partitioning for parallelism, consumer group isolation, and lag monitoring
• Implemented at-least-once delivery with idempotency keys to prevent duplicate processing across retries
• Designed SQS FIFO queues for strict ordering with deduplication IDs and visibility timeouts tuned per job complexity
• Built SNS fan-out patterns for decoupled, multi-subscriber event broadcasting across service domains
• Applied dead-letter queue (DLQ) routing with CloudWatch alarms and automated replay strategies for failed events
• Implemented transactional outbox pattern to guarantee consistency between DB writes and event emissions

• Built Lambda-based async workflows triggered via SQS, SNS, and API Gateway with cold-start mitigation via provisioned concurrency
• Designed fully decoupled serverless pipelines for lead scoring, webhook ingestion, and scheduled report generation
• Used API Gateway + Lambda authorizers for custom JWT/token-based auth enforced at the edge
• Implemented S3 event-driven processing — file upload → SQS → Lambda → DB ingestion pipelines
• Configured CloudWatch dashboards & metric filters for real-time alerting on Lambda errors, DLQ depth, and P95 latency
• Managed infrastructure patterns across EC2, VPC, IAM roles/policies, and Secrets Manager

• Designed compound and partial indexes supporting high-cardinality filter queries with sub-10ms response times
• Built multi-stage aggregation pipelines ($lookup, $unwind, $group, $facet) powering live analytics dashboards
• Applied bucket pattern for time-series chat data to reduce document count and improve range query efficiency
• Implemented read preference tuning (secondary reads for analytics) to offload the primary and reduce hot-spot writes
• Used MongoDB change streams as lightweight event triggers for cache invalidation and downstream service sync
• Performed systematic query profiling via explain() and slow query logs — achieving meaningful P95 latency reductions in production

• Designed WebSocket gateway in NestJS with room-based namespacing for multi-tenant chat isolation
• Built Kafka-backed fan-out — socket events emitted from a Kafka consumer, not the originating service, enabling horizontal scaling
• Implemented presence tracking with Redis TTL keys and heartbeat intervals for accurate agent online/offline state
• Handled socket reconnection logic with event buffering and replay windows to prevent message loss on disconnect
• Designed backpressure-aware consumers to throttle ingestion when downstream services are degraded

• Structured large NestJS codebases using modular DDD — domain-bounded modules, use-case interactors, and repository interfaces
• Applied CQRS pattern with command/query separation for write-heavy domains (chat assignment, analytics writes)
• Used custom interceptors for request logging, response serialization, and distributed tracing header propagation
• Implemented custom exception filters for structured error responses and Sentry/CloudWatch error forwarding
• Wrote unit + integration tests with Jest and Supertest — service logic fully isolated via mock repositories
• Enforced contract-first API design with Swagger decorators and class-validator DTOs with complete type safety

• Implemented exponential backoff + jitter on SQS/Kafka retry handlers to prevent thundering herd on cascading failure
• Designed circuit breaker wrappers (via opossum) around third-party calls (Stripe, external APIs) with half-open probes
• Applied optimistic locking on MongoDB documents for concurrent update conflicts (e.g., agent assignment races)
• Built idempotency middleware for webhooks and payment events — deduplication via Redis with configurable TTL windows
• Structured services for graceful shutdown — drain in-flight messages before SIGTERM completes in ECS/Kubernetes environments
• Maintained saga-style distributed transactions across services with compensating rollback actions on partial failure

Real-time communication & customer engagement platform. I own core backend systems and business logic powering live chat at scale.

✅  High-throughput event pipelines    →   Kafka, SQS, SNS, outbox pattern, fan-out
✅  AWS serverless architectures       →   Lambda, API Gateway, S3 triggers, provisioned concurrency
✅  MongoDB schema design at scale     →   Aggregations, indexing strategy, change streams
✅  Resilient system design            →   DLQ, circuit breakers, idempotency, sagas, backpressure
✅  Clean, modular NestJS codebases    →   CQRS, DDD, dependency injection, clean boundaries
✅  Real-time systems                  →   WebSockets, presence tracking, Kafka-backed fan-out

Open to backend-heavy or full-stack roles. I bring architectural clarity, production discipline, and end-to-end ownership.