// Software Engineer · Distributed Systems
Anurag
Khanna
Building distributed systems and large-scale infrastructure that hold under load, at scale, in production.
// carrier-pricing-engine
// tracking-engine
// order-ingestion
About
Most backend systems are built to pass code review — not to survive production.
Latency creeps. DB connections exhaust. A webhook fires twice and an order duplicates. The tracking system that handled 5 carriers quietly breaks at 32. Engineers patch symptoms. Few design for root causes.
That gap is where I work. As Founding SWE at Openleaf, I design and ship fault-tolerant distributed systems: high-concurrency tracking engines, event-driven microservices with exactly-once delivery, large-scale PostgreSQL schemas built for multi-tenant load.
I'm also a competitive programmer — ICPC Asia-Taiwan, India Rank 3 — which means data structures and algorithms aren't theory. They show up in every system I design: O(n²)→O(n+m) tag-matching, two-tier cache TTL selection, connection pool sizing under concurrent load.
Looking for engineering roles where correctness, scale, and craft actually matter.
Experience
Where I've shipped
production systems.
Founding Software Engineer
- Shipped a zero-error carrier pricing engine in Go serving 13+ carriers and 9+ e-commerce channels — hierarchical lookup across 6 geographic tiers, 40+ charge types, backed by a 322-table PostgreSQL schema with bidirectional route matching and 5 WMS integrations.
- Eliminated 2 serial DB round-trips per job tick and saved ~7ms per job — engineered a 32-carrier tracking system on BullMQ at concurrency=128 with two-tier Redis caching (1h/7-day TTLs) and parallelised terminal-state writes via Promise.all.
- Built a fault-tolerant order ingestion service in Go on AWS SQS FIFO guaranteeing exactly-once delivery — eliminated N+1 cache lookups with batch queries, cut tag-matching from O(n²)→O(n+m), tuned PostgreSQL connection pool (25 open / 10 idle / 5-min lifetime).
- Unblocked AWS ElastiCache Serverless compatibility across all PM2 instances — migrated Socket.IO cluster adapter from redis-adapter (PSUBSCRIBE) to redis-streams-adapter, paired with a Playwright RPA service in Go with OTP-authenticated session persistence.
Software Engineer 1
- Reduced API latency by up to 300ms and cut DB load by 50–60% — optimised SQL queries, Redis caching strategies, and microservices backend logic across order, invoice, and delivery modules, lifting overall API performance 35–45%.
- Reduced production bugs by 90% and integration failures by 40% — implemented JWT + RBAC, API-level validations, rate-limiting, and standardised error handling with 85%+ test coverage across the service layer.
- Cut code duplication by 50% and eliminated 90% of object mapping errors — led an epic-wide object-oriented design migration standardising the Builder Pattern with builder caching across all core service modules.
- Reduced data sync time from minutes to seconds, cutting manual intervention by 40% — designed REST APIs integrating Twilio and third-party accounting ledgers, improving distributed system reliability by 30%.
Software Engineer Intern
- Delivered end-to-end REST API integrations for Wynk Music's web platform serving millions of users — built and integrated content and user-facing service APIs within an Agile engineering team at India's largest telecom.
Software Engineer Intern
- Improved network stability by 20% — identified and resolved critical vulnerabilities across Peaq Network and Canary Network through comprehensive testing on EVM-supporting chains and DePIN infrastructure.
Skills
Technical toolkit.
Engineering Highlights
Systems built for scale.
Carrier Pricing Engine
Production-grade pricing system with hierarchical geographic lookup across 6 tiers, 40+ charge types, and bidirectional route matching. Zero pricing errors serving 13+ logistics carriers.
32-Carrier Tracking Engine
High-concurrency shipment tracking at concurrency=128. Two-tier Redis caching eliminates serial DB round-trips. Parallelised terminal-state writes minimise per-job latency.
Fault-tolerant Order Ingestion
Event-driven order pipeline with exactly-once delivery semantics via SQS FIFO. Optimised from O(n²) to O(n+m) tag-matching, tuned connection pooling, eliminated all N+1 lookups.
Contact
Let's build something
that holds at scale.
Open to backend and distributed systems engineering roles. If you're working on hard infrastructure problems — let's talk.