- Job ID: 839658

- 6 - 8 Years

- 4 Openings
- Bangalore, Noida

Role description

Build the Agentic Platform That Powers Decisions at Paytm Scale

We're building AI systems that don't just assist — they operate directly inside India's largest payments ecosystem. Real decisions, real actions, real money..

Location: Bangalore

Skills

The Opportunity

This isn't your typical backend role

Paytm has changed how India pays. QR, UPI, and Soundbox run on systems that move real money for millions of merchants every minute. Latency, errors, or downtime directly affect customer experience, merchant trust, and revenue.

The next chapter is already underway. We're building an India-scale, AI-first decision platform where agents operate directly inside payments, risk, lending, collections, and customer support. These systems make real decisions, trigger real actions, and run continuously under production load. Our AI systems are ranked on Spider 2.0, a public benchmark for production-grade AI reasoning — the first Indian company represented.

"The bar is intentionally high: decisions must be correct, explainable, observable in production, and recoverable quickly when something goes wrong."

— Engineering team principle

Agentic Platform (Pi) is the core platform behind this shift. Pi runs agents directly inside live money-movement journeys — connecting them to apps, backend services, WhatsApp, voice systems, and devices like Soundbox. When it works, millions of merchants and users benefit. When it breaks, you hear about it fast.

You'll join a small, senior-heavy engineering team with end-to-end ownership. We're actively designing where agents are allowed to act, which tools they can invoke, how failures and model errors are handled, and how agent behaviour is evaluated continuously in production. The problems are hard. The feedback loops are tight. The impact is immediate.

What You'll Build

Core platform + real scenarios at scale

Pi isn't a single model or a single service. It's a platform under active build — real constraints, live traffic, strict latency budgets, and failure modes you can't simulate.

Core Platform Systems

Multi-model orchestration: Abstraction layer over GPT-4, Claude, Gemini, open-source models. Task-level routing, cost-aware selection, automatic fallback chains, latency budgets.

Durable workflow engine: Long-running workflows that survive crashes, restarts, and partial failures. Branching logic, retries with backoff, timeouts, parent-child agent patterns.

- Cross-channel state: User starts on voice, continues on WhatsApp, finishes on app — state follows. Session recovery, context handoff, replay for debugging.
- Tool calling framework: How agents invoke internal APIs safely. Schema validation, confirmation gates, rate limits, SLA enforcement, rollback on failure.
- Voice orchestration: Real-time STT/TTS, barge-in handling, DTMF fallback, warm transfers. Streaming responses coordinated with audio playback
- Guardrails & safety: PII detection and masking, hallucination checks, tone validation, cost caps, loop detection. Block before it reaches the user.
- Observability stack: Traces across agent model tool response. Token budgets, latency percentiles, decision outcomes. Every turn visible in production.
- Continuous evaluation: Detect drift, incorrect decisions, tone violations, cost spikes. LLM-as-judge for quality. Champion-challenger for prompt changes.





These systems power agents across the business — from voice calls that replace IVR menus to text support handling millions of queries, from proactive outreach for collections and retention to internal copilots that assist human agents in real-time. Some are already live at 100% traffic. Others are rolling out. You'll work across all of them.

You'll Fit Right In If

Engineers who've built systems that actually run — and AI-first builders who treat models as unreliable dependencies, not magic.

- You've debugged cascading failures in production and written post-mortems that changed how teams build.
- You've migrated live databases without downtime — and know why that's harder than it sounds.
- You've fixed race conditions and deadlocks in production without reproducible test cases.
- You've profiled memory leaks, tuned GC, or cut P99 latency when the dashboard was on fire.
- You've built durable workflows that survive restarts, retries, and partial failures — not just happy paths.
- You've run LLMs locally to understand latency, memory, and what breaks under load.
- You've hit streaming race conditions with model responses — and fixed them instead of disabling streaming.
- You've connected tools to models and learned that tool-calling is harder than demos suggest.
- You experiment with retries and guardrails because models behave differently every run.
- You've added tracing to side projects just to see where the time and tokens go.

IN SHORT, YOU’VE PROBABLY…

- Fixed production issues before they became incidents
- Migrated something live without users noticing
- Run an LLM locally to see how it actually behaves
- Discovered reliability is the real problem
- Debugged with traces and metrics, not vibes
- Broken a demo and turned it into a system

You don't need to have done all of this — but you should be excited to learn it hands-on.

Day to Day

What you'll actually do

We're hiring Senior Engineers and Tech Leads. In both cases, you'll build backend services that orchestrate agents inside live payment, risk, lending, collections, and support flows. You'll use AI tools where they help — while staying accountable for what runs in production.

- Critical Path Systems: Design backend services in the money-movement path where decisions must be correct, explainable, and fast under load.
- Workflow Orchestration: Turn messy, manual processes into consistent, production-grade decisioning across payments, risk, lending, and collections.
- Failure Mode Engineering: Handle partial failures, timeouts, flaky downstreams, and non-deterministic model behaviour — then document the patterns.
- Actionable Observability: Build traces, metrics, and logs that make it obvious when something is slow, brittle, or too expensive — and lead the fixes.
- Cross-Domain Debugging: Debug incidents cutting across code, data, infra, and models. Put guardrails, runbooks, and post-mortems in place.
- Outcome-Driven Collaboration: Work with product, risk, and operations to turn "we need this outcome" into concrete system changes with measurable impact.





Other details

What We Look For

Skills that matter here

We care more about what you've built, how you work, and how you communicate than any specific framework or stack.

- You've built systems people depend on

Backend or distributed systems that real users and teams rely on. You can point to a few systems you're genuinely proud of.

- You know your languages and runtimes

Comfortable with Java, Go, Rust, Python, C++ (or similar). You can explain what makes a system perform well — profiling, latency, DB behaviour under load.

- You've debugged hard production problems

Issues that cross services, databases, caches, and networks. Comfortable with concurrency (threads, pools, locks, async, queues).

- You treat AI as your best engineering buddy

You don't mind going deep into open-source code and team repos with AI code agents by your side. You get onboarded in recent codebases faster, think like an AI-native engineer, and constantly ask: how can I make this code better, faster, more reliable? — then use AI to get there.

- You stay responsible for what ships

AI accelerates our work — judgment, correctness, and ownership stay human. You review what it writes, understand why it works, and own the result.

- You've shipped LLM or agent systems Bonus

Real systems beyond demos. You understand trade-offs around latency, cost, reliability, and failure modes.

Interview Process

How we evaluate

Our process is designed to be transparent and practical. We want to see how you think, build, and communicate.

R1 — Coding & Problem Solving

Engineering basics and how you think

Live Coding / Pair Programming — we save the code and discuss trade-offs

- Understands the problem before jumping into code
- Asks clarifying questions (inputs, edge cases, limits)
- Can explain how code behaves when things fail
- Handles timeouts, retries, and error semantics
- Correctness under concurrency, idempotency

R2 — System Design

Design systems that hold up in production

Whiteboard Discussion

- Thoughtful handling of partial failures and graceful degradation
- Explicit trade-offs, not idealized designs
Strong observability instincts: metrics logs
- traces
- Real incident experience with clear follow-ups
- Safe rollout and migration strategies

R3 — Technical Leadership & Ownership

Judgment, ownership, and how you work with others

Behavioral Discussion

- Honest reflection on decisions that didn't go as planned
- Strong execution and ownership within your domain
- System-level thinking and proactive failure awareness
- System-level thinking and proactive failure awareness

Build AI systems that make real decisions with real money on the line

Hard problems. Real production traffic. End-to-end ownership. A team that ships weekly and learns from what breaks.

Just as Paytm transformed how India pays, we're now building AI systems designed for real-world scale — engineered in India, trusted globally.

About One97 Communications Ltd

Paytm (Pay Through Mobile) is India's leading digital payments and financial services platform, started by One97 Communications in 2010, offering services from mobile recharge, bill payments, and shopping to UPI payments, travel booking, and wealth management (Paytm Money), serving millions of users and merchants with a focus on financial inclusion and innovation, known for its QR code system and growing ecosystem of financial products.

📌 Backend - Technical Lead (Risk Tech) (India)
🏢 Paytm
📍 India