Juspay routes payments for some of the largest merchants in India. I came in as an SDE intern on the payment-routing team. The codebase is Haskell — a real production Haskell shop — and the system runs as an active-active cellular deployment with strict latency budgets. My work centered on three pieces: a Snowflake-style distributed ID generator that scales linearly with cells, the routing engine's multi-armed bandit explore/exploit logic, and an internal ETL platform feeding analytical workflows.

1. Distributed ID gen at 16K+ IDs/ms per cell × 127 cells

   Designed and shipped a Snowflake-style generator with per-cell deterministic ID partitioning. Serves 300M+ daily transactions at sub-5ms p99 under peak production load. The architectural decision that mattered most: keeping the cell-id bits high enough that we never have to coordinate across cells to allocate.

   contribution · 01
2. Active-active cell migration for payment routing

   Migrated the closed-loop routing engine to a multi-region active-active cell architecture. Redesigned the multi-armed bandit explore/exploit logic with per-cell Redis sliding windows so statistical confidence holds under asymmetric regional traffic and a cell going down doesn't poison the others' priors.

   contribution · 02
3. Internal ETL platform with a three-tier data access strategy

   Built an analytics-feed ETL platform with in-memory → Redis Streams → DB fallback for fault-tolerant low-latency delivery. The tiering means slow queries never become hot-path latency; the fallback never becomes the steady state.

   contribution · 03
4. On-call and observability

   Built Grafana dashboards for latency/throughput SLOs on the services I owned. Handled live production incidents — the kind where you read logs, metrics, and traces in three browser tabs and decide whether to roll back.

   contribution · 04

Real production Haskell teaches you to actually use the type system as a design tool — invariants you declare in types stop being violated everywhere. And shipping cell-based architecture changes how you think about every component: 'what happens if this cell is unreachable?' becomes the default question, not a corner case.

• Architected and shipped a Snowflake-style distributed ID generation system processing 16K+ IDs/ms per cell across 127 isolated cells, serving a payments platform of 300M+ daily transactions at sub-5ms p99 under peak production load.
• Migrated a closed-loop payment routing engine to a multi-region active-active cell architecture, redesigning multi-armed bandit explore-exploit logic with per-cell Redis scoring sliding windows to preserve statistical confidence under asymmetric traffic.
• Building a Haskell-to-Rust transpiler for the core payment routing codebase, powered by a multi-agent pipeline (parse → semantic mapping → property-test verification → human review) with a deterministic classical fallback where probabilistic generation drifts — derisking the migration of type-rich Haskell semantics to memory-safe Rust without lift-and-shift breakage.