About Experience Skills Projects Contact

// Software Engineer · Distributed Systems

Anurag
Khanna

Building distributed systems and large-scale infrastructure that hold under load, at scale, in production.

★ ICPC Asia-Taiwan · India #3 Founding SWE @ Openleaf Go · Distributed Systems ex-Airtel IIITM '25
Get in touch ↗ LinkedIn ↗ GitHub ↗
production_status.sh
$ ./deploy --env prod

// carrier-pricing-engine
carriers 13+
channels 9 e-commerce
schema 322 tables
errors 0
status ✓ live

// tracking-engine
concurrency 128
carriers 32
cache 2-tier Redis
status ✓ live

// order-ingestion
delivery exactly-once
queue SQS FIFO
status ✓ live

$
300ms
latency cut
50–60%
DB load reduced
90%
prod bugs down
13+
carriers integrated
322
table schema
#3
ICPC India rank

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.

Open to SWE3 opportunities at companies that care about correctness, scale, and engineering craft.

// Currently
Founding Software Engineer
Openleaf · Mumbai, India
Apr 2026 – Present
// Education
B.Tech, Computer Science
IIIT Senapati, Manipur · 2025
// Achievement
ICPC Asia-Taiwan · India Rank 3
International Collegiate Programming Contest
// Volunteering
Google Product Expert
Google · Aug 2022 – Present

Experience

Where I've shipped
production systems.

Founding Software Engineer
Openleaf
Apr 2026 – Present
Mumbai · On-site
  • 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.
GoPostgreSQLRedis AWS SQS FIFOBullMQ Event-drivenDistributed Systems Fault Tolerance
Software Engineer 1
Facilgo (Anukta Infotech)
Dec 2024 – Apr 2026
Hyderabad · On-site
  • 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%.
MicroservicesRedisPostgreSQL REST APIOODJWT/RBAC Distributed Systems
Software Engineer Intern
Airtel
May 2024 – Jul 2024
Gurugram · On-site
  • 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.
REST APIBackend EngineeringAgile
Software Engineer Intern
SkyTrade
Jan 2024 – Dec 2024
United States · Remote
  • 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.
RustEVMDistributed SystemsSecurity Testing

Skills

Technical toolkit.

// Languages
Go C++ Python TypeScript JavaScript Rust SQL
// Systems
Distributed Systems Large-scale Infrastructure System Design Event-driven Architecture Microservices Fault Tolerance Concurrency High-throughput Backends
// Data & Infrastructure
PostgreSQL Redis AWS SQS / S3 ElastiCache BullMQ Docker MySQL Linux
// Practices
Data Structures & Algorithms Code Review Design Review Object-oriented Design Design Patterns API Design Testing Observability Production Engineering

Engineering Highlights

Systems built for scale.

// Pricing System · Go · PostgreSQL

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.

carriers integrated13+
e-commerce channels9+
schema size322 tables
pricing errors0
GoPostgreSQL System DesignLarge-scale
// Tracking System · BullMQ · Redis

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.

concurrency128
DB round-trips saved2 per tick
latency saved~7ms / job
carriers tracked32
BullMQRedis ConcurrencyGo
// Pipeline · Go · AWS SQS FIFO

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.

delivery guaranteeexactly-once
tag-matchingO(n²) → O(n+m)
conn pool (open/idle)25 / 10
duplicate orders0
GoAWS SQS FIFO Fault ToleranceEvent-driven

Contact

Let's build something
that holds at scale.

Open to SWE3 opportunities at top-tier tech companies. If you're a Google recruiter or building distributed systems at scale — I'd love to connect.

anurag.khanna@openleaf.tech LinkedIn ↗ GitHub ↗