Senior Software Engineer (Founding Engineer)

_

At Jumbo, I build the quiet backends behind 700K req/min of real-time gaming — correct under load, observable, and cheap to run.

700req / min
30in-game txn / day
5peak payments / day
200postgres managed
2clickhouse managed
100MAU
80weekly active

About me

I build the quiet kind of high-scale backends.

Systems that move ~700K req/min, settle ₹5 Cr of payment throughput at peak, and shepherd tens of crores in in-game transactions without losing a paisa to float drift.

4.5+ years of designing and scaling real-time systems on AWS. I care about correctness under load, clean service boundaries, and the kind of observability that turns a three-a.m. page into a five-minute fix.

I'm strongest where systems design, performance, and execution leadership meet — atomicity and idempotency in payments, tail-latency hunting with Locust and Percona, Kinesis + Glue + Athena pipelines, WebSocket fleets, and Redis-backed event aggregation.

Skills

My toolkit, by category.

Languages

  • TypeScript
  • JavaScript
  • Go
  • Python
  • SQL

Backend

  • Node.js
  • gRPC
  • REST
  • WebSockets
  • Microservices
  • Distributed Systems
  • Event-driven
  • CDC
  • ETL
  • System Design

Databases

  • PostgreSQL RDS / Aurora
  • MySQL Aurora
  • ClickHouse
  • MongoDB
  • Redis

AWS Cloud

  • Lambda
  • EC2
  • EKS
  • S3
  • API Gateway
  • Kinesis
  • Firehose
  • Step Functions
  • Glue
  • Athena
  • SQS
  • Cognito
  • CloudWatch
  • Personalize

DevOps & Tools

  • Docker
  • Kubernetes
  • Terraform
  • NGINX
  • Airflow
  • CI/CD
  • Datadog
  • Locust
  • Percona
  • Tailscale
  • Git

AI

How I work with AI.

AI is woven through how I build and operate — from writing code to investigating production incidents.

Primary tool

Claude Code

My daily driver for coding, architecture discussions, code reviews, refactoring and debugging — running the Superpowers plugin with skills like brainstorming, writing plans, etc.

MCP Model Context Protocol

Heavily integrated into my daily workflow for incident investigation, debugging, operational insights and cross-system analysis — for faster decisions.

Connected to

  • AWS
  • Datadog
  • Databases
  • GitHub
  • Slack
  • Linear

ChatGPT

Brainstorming, ideation, solution exploration and design discussions.

Cursor

AI-assisted IDE for day-to-day development and fast code completion.

Projects

Things I build after hours.

ctx-router

Transport-agnostic API router — write handlers once and run them across HTTP, Lambda, SQS, and gRPC through one ctx pipeline, keeping transport concerns at the boundaries.

  • TypeScript
  • npm
GitHub

ketsoc

Geographically distributed WebSocket layer built on Cloudflare Durable Objects, with hibernation for low-cost, stateful connections at the edge.

  • TypeScript
  • Durable Objects
GitHub

homing-trade

Paper-trading lab for crypto futures — multi-strategy tournament, backtester, RL/AI strategies (Q-learning + a Bull/Bear/Risk committee), daily risk controls and a kill switch.

  • Python
  • RL / AI
GitHub

Blogs

Notes from the build.

Work

Where I've shipped at scale.

Jumbo · Senior Software Engineer (Founding Engineer)

Building the gaming platform from zero to ~700K req/min.

joinjumbo.com · New Delhi · Aug 2024 — Present

  • Scaled the gaming platform from ~15K to ~700K req/min for ~100K+ MAU (80K+ weekly active), reliably handling ₹5 Cr peak payment throughput and 30 Cr+ in-game transaction volume.
  • Rewrote the core transaction service in Go + gRPC, cutting latency from ~150 ms to ~50 ms; engineered financial correctness via atomicity, idempotency, running balances, and integer currency normalization to eliminate float drift.
  • Owned end-to-end system architecture for the in-house cricket fantasy game (like Dream11) — service boundaries, schema, and API contracts.
  • Designed a multi-currency wallet ledger with liability tracking and automated clawback reconciliation for accurate, auditable balances across product lines.
  • Built the fantasy contest engine — concurrency-safe contest join, automated reward calculation & distribution, live leaderboards, and refund / cancellation flows.
  • Built a vendor-agnostic event pipeline: one typed event is batched, streamed via Redis, and fanned out to multiple analytics vendors (CleverTap, PostHog, Matomo) while persisted first-party in ClickHouse — removing third-party lock-in.
  • Built a CDC pipeline using Postgres logical replication to stream production data into BigQuery in near real time, without loading the primary database.
  • Delivered a scalable WebSocket platform (API Gateway + Redis) for connection state, channel broadcasts, and WS-based API calls.
  • Rolled out Datadog observability (APM, metrics, dashboards, alerting) across all production services, improving incident detection and response.
  • Primary escalation owner for production incidents — debugging, resolution, release execution, and unblocking the team.
  • Built an async recharge + KYC orchestration layer with a vendor-agnostic Adapter Pattern, reducing third-party cost by ~70%.
  • Cut backend load and CDN cost by ~40–50% by moving low-change / high-read APIs behind a CDN with correct cache-control and invalidation.
  • Scaled database reads with read replicas and managed high concurrent connection volume via RDS Proxy + pgBouncer pooling, keeping the primary stable under peak load.
  • Reclaimed ~30% of database storage with pg_repack (table rebuilds, reindex, dead-tuple cleanup) and upgraded PostgreSQL 17 → 18.
  • Improved tail latency and peak resilience through API + DB bottleneck analysis and load testing with Locust and Percona.
  • Eliminated OOM crashes in the Go transaction service by setting GOMEMLIMIT — the GC runs more aggressively as the heap nears the cap, keeping memory stable under load.
  • Built centralized logging + trace correlation on Node.js async_hooks, reducing MTTR and surfacing perf bottlenecks across services.
  • Modernized AWS infra with AWS Organizations, CI/CD pipelines, IAM Identity Center RBAC, and Tailscale-secured internal access.
  • Performed zero-downtime rotation of JWT signing keys (kid-based) across all production services, with no forced user logout.
  • Strengthened account safety with OTP-abuse prevention and multi-device concurrency conflict handling.
  • Built an Aviator game from scratch, scaling 0 → ~1,000 CCU; improved velocity using AI-assisted tooling and MCP database workflows.
Juego Studios · Software Engineer

AWS pipelines, multiplayer infra & Web3 wallet flows.

juegostudio.com · Mangalore · Aug 2021 — Jan 2024

  • Built a resilient AWS ingestion platform using Kinesis, cutting projected infra cost $1,200 → $400/mo (~66%) while improving throughput.
  • Delivered analytics pipelines using Glue ETL (PySpark) + Glue Catalog + Athena, converting raw data to columnar Parquet to cut storage and query latency from ~7s → 1–2s.
  • Improved DB scalability via Aurora MySQL tuning, SQL transactions, indexing, and Redis caching — sustained ~1,000 CCU and 1,000 RPS.
  • Provisioned cloud infra with Terraform for reproducible deployments.
  • Deployed multiplayer game servers on Kubernetes, integrating Agones as a PoC for dedicated server scaling.
  • Delivered backend game logic across multiple multiplayer titles (Texas Hold'em Poker, Rummy, and an RPG with a quest / marketplace) — matchmaking and concurrency-safe state.
  • Implemented M2M auth architecture, JWT access/refresh token flows, and AWS Cognito + Secrets Manager with role-based permissions.
  • Integrated wallet auth flows with Metamask and Keplr for Web3 gaming.
  • Mentored engineers; collaborated across gameplay, frontend, CMS, and game-design teams.

§ Internal innovation

  • Built a Lambda RAM picker that benchmarks functions across memory configurations to find the most cost-efficient allocation.
  • Replaced NAT Gateway with a repurposed EC2 NAT instance, cutting egress cost.
  • R&D on Amazon Personalize for in-app recommendation use cases.
  • Designed a room handler with a bucket system to organize server-side game loops at scale, with match-filling bots to sustain gameplay during low player counts.
  • Established a caching strategy for master tables to cut read pressure on the primary DB.
  • Implemented database synchronization tooling to keep table structure consistent across environments.

Education

B.E. Computer Science Engineering

Srinivas Institute of Technology, Mangalore · 2021

Contact me

Have a hard backend problem? Let's talk.

Scale, correctness, or a system quietly bleeding cost — I'd love to hear about it.