Juspay routes payments for some of the largest merchants in India. I joined as an SDE intern in August 2025 on payment routing and reconciliation, and went full-time in June 2026. The work spans three layers: core infrastructure (a Snowflake-style distributed ID service, an active-active cell migration, a shared Rust service framework, an ETL platform), developer tooling that changes how the team ships (ART, a record-and-replay regression platform), and production AI agents — an agentic root-cause-analysis tool on-call engineers use from Slack, and a Haskell → Rust transpiler built on an AI-agent pipeline with deterministic fallbacks.

1. Agentic RCA tool, in production use by on-call engineers

   A Slack mention starts an orchestrator that delegates to specialist sub-agents across team docs, Bitbucket code, Jira and live telemetry, then posts a structured RCA back to the thread. I wrote its Python MCP server over the Slack, Grafana, Kibana and VictoriaMetrics REST APIs and Bitbucket, with retrieval on self-hosted LLMs and a Next.js UI that streams each investigation live and keeps shareable reports.

   contribution · 01
2. ART: every release replays real traffic first

   Automated Regression Testing is a full-stack TypeScript platform (Next.js UI, Node.js REST API) that tests new reconciliation code against replayed production traffic before every release. Its record-and-replay pipeline captures 1–2% of live traffic over a 7–14 day sliding window and runs as a Jenkins stage. Used by 20+ engineers across 2 teams.

   contribution · 02
3. 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 · 03
4. 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 · 04
5. 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 · 05
6. A shared Rust service framework

   Database-agnostic and cloud-agnostic layers so one service runs on AWS or on-prem unchanged. Reconciliation code moved from panic-prone unwrap/expect to typed, propagated errors.

   contribution · 06
7. Haskell → Rust, via an AI-agent pipeline

   Building a transpiler for the core payment-routing codebase: parse → semantic mapping → property-test verification → human review, with a deterministic classical fallback wherever probabilistic generation drifts. The point is to move type-rich Haskell semantics to memory-safe Rust without lift-and-shift breakage.

   contribution · 07
8. On-call and observability

   Operate production services on Docker/Kubernetes across AWS and on-prem with zero-downtime releases; Grafana dashboards and alerts for the services I own, and a seat on the on-call rotation.

   contribution · 08

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.

• Built an agentic RCA tool in production use by on-call engineers: a Slack mention starts an orchestrator that delegates to specialist sub-agents across docs, Bitbucket, Jira and live telemetry through an MCP server I wrote over Slack, Grafana, Kibana and VictoriaMetrics.
• Built ART, a record-and-replay regression platform that tests new reconciliation code against 1–2% of live traffic over a 7–14 day window before every release; used by 20+ engineers across 2 teams.
• 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.
• Built a shared Rust service framework (database- and cloud-agnostic, one service runs on AWS or on-prem unchanged) and a fault-tolerant ETL platform — in-memory → Redis Streams → database fallback — serving 15+ analytical pipelines.