Ankush
Srivastava
Techincal Lead
I build and design systems that handle millions of events per second — WebSocket platforms, payment gateways, and real-time data pipelines — and I care deeply about what happens under load.
peak throughput
1000 TPS
memory cut
−80%
startup time
20min → 1min
I've been thinking about distributed systems since before they were cool.
My journey started in 2016 in Chennai, automating billing pipelines at TCS for Bank of America. It was unglamorous work — stored procedures, invoice templates, edge cases — but it taught me that reliability is a feature, not a given.
I moved into the data world at PromptCloud, where I built 100+ web crawlers and helped launch JobsPikr from the ground up. Wiring ML pipelines into data pipelines, eliminating 30% of duplicate records — this is where I developed my instinct for data quality and system correctness.
At Techmojo I found my real domain: high-frequency, event-driven sports platforms. The problems here are genuinely hard — millions of WebSocket clients, sub-second pricing updates, payment flows that must not lose money. I re-architected a pub-sub system handling 10M+ markets, turned a 20-minute startup into a sub-minute cold boot, and profiled Go runtimes at 2,500+ updates/second.
Outside of systems: I competed in CodeVita in 2014 and 2015, ranking 167th and 98th nationally. I won first place in the Kreate Hackathon 2019 building an image spam buster. These early competitions built something that prod incidents reinforce — the ability to think clearly under pressure.
Quick facts
- Based inHyderabad (Remote)
- Current roleTech Lead @ Techmojo
- LanguagesGo, Java, SQL
- EducationB.Tech IT, KNIT Sultanpur
- Competed inTCS CodeVita × 2
- HackathonKreate 2019 Winner 🏆
- Open toSenior / Staff / Architect roles
Fun fact: I once reduced a service's cold startup from 20 minutes to under 60 seconds. The old number wasn't from bad code — it was a fundamental architectural assumption that had calcified over time. I find these moments the most satisfying to fix.
Systems over features
I think in feedback loops, not task lists. Before writing code I ask: what breaks this at 10× scale? The answer shapes every design decision.
Obsessed with less
Cutting memory 80%, slashing startup time from 20 minutes to under one — these aren't wins measured in lines added, but in lines removed.
Production profiling as craft
I've spent late nights with pprof traces, hunting goroutine leaks and GC pauses. There's something meditative about finding the exact bottleneck.
Mentorship as multiplier
A team that understands the why builds better than one that follows orders. I invest in growing engineers around me, not just the code.
The problems that shaped how I think
These aren't just resume bullets. Here's what the problems actually looked like, and what it took to solve them.
WebSocket pub-sub for 10M+ markets
Situation
A revenue-critical sports platform was delivering live pricing to thousands of concurrent clients via WebSocket. The subscription model, caching, and concurrency design were all struggling under load — and every failure was visible to users mid-bet.
Approach
I re-architected the core subscription model: redesigned the Kafka fan-out strategy, rebuilt the caching layer for hot data, and overhauled concurrency patterns. Every design choice was benchmarked against the worst-case throughput we'd seen in production.
Result
System now reliably delivers pricing across 10M+ markets and 1M+ events without throttling under peak load.
markets served
10M+
concurrent events
1M+
CPU reduction
>50%
Payment gateway handling 1.5M txn/day
Situation
Building a payment system that processes real money is unforgiving. The existing flow had no circuit breaking, no retry logic, and manual reconciliation for failed payments — each failure meant either lost revenue or customer support overhead.
Approach
Designed from scratch with Spring Boot: JWT+HMAC authentication, rate limiting per client, circuit breaker patterns to isolate downstream failures, and automated retry reconciliation that caught and recovered failed payments without human intervention.
Result
System handles 1,000 TPS at peak, processes 1.5M transactions per day, and auto-recovers 95% of failed payments.
transactions/day
1.5M
peak throughput
1000 TPS
auto-recovered
95%
20-minute cold boot → under 1 minute
Situation
A service was preloading its entire working set into memory on startup. This architectural decision had made sense early on, but had calcified into a liability: 20-minute cold boots meant slow horizontal scaling, painful deployments, and fragile high-availability posture.
Approach
Transformed the service to lazy-load data from Redis on demand. This eliminated Kafka's role as a persistent store, cut the in-memory footprint dramatically, and decoupled availability from pre-warming time. Also ran deep pprof profiling (CPU, heap, goroutine) to fix object allocation patterns and GC pressure.
Result
Cold start dropped from 20 minutes to under 60 seconds. Memory footprint cut by 80%+. Teams could now scale horizontally in response to load spikes.
startup time
20m → <1m
memory cut
80%+
Kafka dependency
eliminated
Techmojo Pvt. Ltd.
Tech Lead — Member of Technical Staff
Feb 2022 — Present
Hyderabad (Remote)
Leading backend architecture for a high-stakes sports betting platform. Everything I do here is measured in milliseconds and millions — market throughput, transaction accuracy, and uptime under load.
- →Re-architected the WebSocket pub-sub engine powering 10M+ markets via Kafka fan-out
- →Built payment gateway processing 1.5M transactions/day at 1000 TPS with 95% auto-recovery
- →Reduced service memory footprint 80%+ by moving from in-memory preload to lazy Redis architecture
- →Profiled Go runtime (pprof: CPU, heap, goroutine) to cut peak CPU >50% at 2500+ updates/sec
- →Led integration of Live Sports Streaming, Bonus Engine, and Bet Builder features
PromptCloud Technologies Pvt. Ltd.
Tech Lead
Nov 2018 — Feb 2022
Bengaluru
Worked in the data extraction and structuring space — a domain where correctness is everything and scale is relentless. Shipped 100+ crawlers and co-built a job data product from zero.
- →Delivered 100+ custom web crawlers extracting structured data (XML, JSON, CSV, JSON-LD)
- →Built JobsPikr from scratch, integrating ML pipelines with data pipelines
- →Engineered duplicate job detection and expired listing removal, cutting redundancy by 30%+
- →Won 1st place at Kreate Hackathon 2019 with an image spam buster built at speed
Tata Consultancy Services
Systems Engineer
Aug 2016 — Oct 2018
Chennai
Started my career in large-scale enterprise software for Bank of America. Learned to respect the complexity of financial systems, automated painful manual processes, and built my first observability tools.
- →Automated billing & invoice generation for Bank of America using Java, Spring MVC, MySQL
- →Built real-time logging & alerting with Spring AOP, cutting MTTD incidents by ~50%
- →Created a JAR for dynamic Excel/PDF report generation from user-defined templates
- →Ranked 98th of 67,000 in TCS CodeVita 2015; 167th in CodeVita 2014
Education
B.Tech in Information Technology
Kamla Nehru Institute of Technology, Sultanpur, UP
May 2016
Tools I trust at 3am in production
Not a skills list — a map of what I actually reach for when something's on fire.
Core languages
The languages I reach for first
Primary language at Techmojo
9 years, Spring ecosystem expert
MySQL, PostgreSQL
Supporting/frontend
Architecture & frameworks
How I wire systems together
Design + migration
Deep production usage
Internal service comms
Real-time platform core
Data & messaging
Moving and storing data at scale
Fan-out, event sourcing
Caching, pub-sub, lazy-load
AWS managed
Message queuing
Infrastructure & cloud
Where my code lives in production
Container orchestration
Core services
Metrics & alerting
Logging & search
Monitoring & observability
The instruments I use to understand what's happening in prod
Things I've figured out the hard way
Production war stories, architecture decisions, and honest post-mortems — written for engineers who work at scale.
Why I Switched a Service from Full In-Memory to Lazy Redis Loading
A 20-minute cold boot was a symptom, not the problem. Here's the architectural assumption that caused it and exactly how I dismantled it without breaking production.
Profiling Go in Production: What pprof Actually Tells You
CPU flame graphs, heap profiles, goroutine dumps — three real incidents from our sportsbook platform where profiling data changed how I understood the system entirely.
Building a Payment Gateway That Doesn't Lose Money
Circuit breakers, HMAC signatures, idempotent retries — the non-negotiable patterns behind a gateway processing 1.5M transactions a day, and why each one exists.
Let's build something that holds up under load.
Whether you're scaling a platform, re-architecting a bottleneck, or just want to talk distributed systems — I'm interested. Especially if the problem is genuinely hard.