# Razorpay

Razorpay's Engineering blog, decoding how we build India's Financial Infrastructure backbone - Medium

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## How Razorpay Moved 2,500 DAGs to Airflow 3, One DAG at a Time

DevFeed: [How Razorpay Moved 2,500 DAGs to Airflow 3, One DAG at a Time](<https://devfeed.tech/articles/how-razorpay-moved-2-500-dags-to-airflow-3-one-dag-at-a-time-100860.md>)

Original publisher: [Read original article](<https://engineering.razorpay.com/how-razorpay-moved-2-500-dags-to-airflow-3-one-dag-at-a-time-71419355a07b?source=rss----6407ad2e59af---4>)

Author: Manish Kumar Gupta

Published: 2026-10-26T10:23:23Z

Content type: article

Language: en

Sources: [Razorpay](<https://devfeed.tech/sources/razorpay-engineering-medium.md>)

Topics: [Deployment Strategies](<https://devfeed.tech/topics/deployment-strategies.md>), [blue-green deployment](<https://devfeed.tech/topics/blue-green-deployment.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [versioning](<https://devfeed.tech/topics/versioning.md>)

Tags: [adoption](<https://devfeed.tech/tags/adoption.md>), [airflow](<https://devfeed.tech/tags/airflow.md>), [api](<https://devfeed.tech/tags/api.md>), [api-server](<https://devfeed.tech/tags/api-server.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [batch](<https://devfeed.tech/tags/batch.md>), [bug](<https://devfeed.tech/tags/bug.md>), [ci](<https://devfeed.tech/tags/ci.md>), [code](<https://devfeed.tech/tags/code.md>), [config](<https://devfeed.tech/tags/config.md>), [crash](<https://devfeed.tech/tags/crash.md>), [dag](<https://devfeed.tech/tags/dag.md>), [data-engineering](<https://devfeed.tech/tags/data-engineering.md>), [data-pipelines](<https://devfeed.tech/tags/data-pipelines.md>), [database](<https://devfeed.tech/tags/database.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [drop-in](<https://devfeed.tech/tags/drop-in.md>), [executor](<https://devfeed.tech/tags/executor.md>), [import](<https://devfeed.tech/tags/import.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [razorpay](<https://devfeed.tech/tags/razorpay.md>), [software-development](<https://devfeed.tech/tags/software-development.md>)

### AI overview

Razorpay moved its Airflow workloads from 2.10 to 3 through a separate blue-green cluster and per-DAG cutovers, reaching 2,592 migrated DAGs in ten weeks with about 100 engineers. The central operational change is that Airflow 3 tasks send heartbeats, state updates and XCom through the Task Execution API instead of connecting directly to the metadata database. Slow API requests can stall heartbeats and cause running tasks to be failed as zombies; Razorpay split execution traffic from UI and REST traffic, ran at least two execution API replicas, and added availability and heartbeat alerts. The account also describes a scheduler crash loop in 3.2.1 fixed in 3.3.0, silent configuration changes, parser memory and task-pool limits, and migration issues involving missing Variables and Connections. Its practical approach included diffing effective configs, shipping drop-in v3 helper libraries, freezing v2 changes in CI on published dates, and migrating DAGs individually with rollback available.

### Source excerpt

Airflow, the scheduler behind Razorpay's batch data pipelines, now runs on version 3.3, and we led the move from 2.10. It runs more than 2,700 DAGs and about 11,000 task runs a day, and we got there without a big-bang cutover. The official upgrade guide is the place to start for code changes. This post is about what happened when we ran Airflow 3 at that scale: the architecture change behind most of our incidents, how we moved everything one DAG at a time, the tooling that made it easy for other teams, and the checklist we'd follow next time. If you read nothing else In Airflow 3, every running task talks to the API server, not the database. If the API server stalls, running tasks get killed. Run at least two replicas, and give task traffic its own API server deployment so a slow UI page can't fail tasks. Avoid 3.2.1. A scheduler bug there causes a crash loop that never recovers on its own. 3.3.0 fixes it. Diff the config your pods actually run with. Some of our v2 settings vanished during the move, and some keys were renamed with no warning. Go blue-green: run v3 next to v2, move DAGs one at a time, and freeze v2 in CI on published dates. The freeze did more for adoption than any tooling we wrote: about 100 engineers moved 2,500 DAGs in ten weeks. Make migrating an import swap. Bulk migration only took off once we shipped drop-in v3 versions of our internal helper libraries. Airflow in two minutes Airflow runs batch jobs on a schedule. You describe each pipeline in a Python file called a DAG: a set of tasks and the order they run in. For example: "pull yesterday's payments, then build the settlement report, then email it". A few moving parts matter for this post: The scheduler decides which tasks are due. The executor decides where tasks run. On Airflow 2 we used Celery: a fixed fleet of always-on worker processes that pull tasks off a Redis queue. On Airflow 3 we use the Kubernetes executor, which starts a new pod for every task and deletes it afterwards. The meta

## How We Deploy Reliably at Razorpay

DevFeed: [How We Deploy Reliably at Razorpay](<https://devfeed.tech/articles/how-we-deploy-reliably-at-razorpay-90581.md>)

Original publisher: [Read original article](<https://engineering.razorpay.com/how-we-deploy-reliably-at-razorpay-52ddf676caf8?source=rss----6407ad2e59af---4>)

Author: Anusha Musthaphak

Published: 2026-10-20T08:20:57Z

Content type: article

Language: en

Sources: [Razorpay](<https://devfeed.tech/sources/razorpay-engineering-medium.md>)

Topics: [progressive delivery](<https://devfeed.tech/topics/progressive-delivery.md>), [Deployment Strategies](<https://devfeed.tech/topics/deployment-strategies.md>), [canary release](<https://devfeed.tech/topics/canary-release.md>), [Production Engineering](<https://devfeed.tech/topics/production-engineering.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [alerts](<https://devfeed.tech/tags/alerts.md>), [blast-radius](<https://devfeed.tech/tags/blast-radius.md>), [canary](<https://devfeed.tech/tags/canary.md>), [canary-deployment](<https://devfeed.tech/tags/canary-deployment.md>), [deploy](<https://devfeed.tech/tags/deploy.md>), [kafka](<https://devfeed.tech/tags/kafka.md>), [logs](<https://devfeed.tech/tags/logs.md>), [on-call](<https://devfeed.tech/tags/on-call.md>), [payments](<https://devfeed.tech/tags/payments.md>), [process](<https://devfeed.tech/tags/process.md>), [production](<https://devfeed.tech/tags/production.md>), [progressive-delivery](<https://devfeed.tech/tags/progressive-delivery.md>), [razorpay](<https://devfeed.tech/tags/razorpay.md>), [reliability](<https://devfeed.tech/tags/reliability.md>), [risk](<https://devfeed.tech/tags/risk.md>), [services](<https://devfeed.tech/tags/services.md>), [traffic](<https://devfeed.tech/tags/traffic.md>), [transactions](<https://devfeed.tech/tags/transactions.md>), [version](<https://devfeed.tech/tags/version.md>)

### AI overview

Razorpay reduces deployment risk through progressive canaries that limit exposure, compare new and current versions, and automatically gate or roll back unhealthy changes. Web services use a default five-step traffic ladder from 1% to 15%, with two-hour analysis per step (longer for thin or bursty traffic); Kafka consumers get a parallel canary process that compares processing errors, lag, and latency. Rollouts are ordered by merchant criticality, keeping P0-P2 merchants on the current version until less critical traffic completes canary cycles. Canary checks draw eligible signals from live Prometheus alert rules, while Canary Sentinel compares logs during rollout and sends ambiguous results to a human. Deploy Sentinel performs six follow-up checks through 16 hours after deployment, combining logs, metrics, infrastructure health, and change-specific analysis; its weakest score determines the verdict. The article says overnight and multi-day bake periods and peak-aware rollout timing remain planned work because short observation windows can miss low-frequency or high-volume regressions.

### Source excerpt

Most production incidents do not begin with a server dying. They begin with a deployment: dozens a day, across hundreds of services, each the moment risk enters the system. We run payments infrastructure at Razorpay. When a payments system degrades, transactions fail: merchants lose revenue, customers lose trust, and someone's checkout page spins at the worst possible moment. Reliability is not a feature we ship; it is the thing everything else stands on. A system in steady state rarely breaks on its own. So if you are serious about reliability, you invest where the risk actually enters: not in the servers, but in the process that changes them. This is what that investment looks like for us today: progressive canaries with more and smaller steps, canaries for Kafka consumers, rollouts ordered by merchant criticality, canary analysis derived from the same alerts that page on-call, and AI judges that read logs during and after the rollout. What reliability means at deployment time You cannot ship software with zero risk. Any process that promises that is either lying or shipping nothing. So the goal is not to prevent every bad deployment; it is to control three quantities: Blast radius. How much traffic, and whose traffic, a bad change touches before anyone notices. Time to detect. How quickly you find out the change is bad, and whether a machine finds out before a customer does. Time to recover. How quickly you get back to a known-good state once you know. Progressive delivery is the discipline built on those three levers: expose a change to a small slice of reality, measure it honestly against the current version, expand only while it stays healthy, and revert automatically the moment it does not. In practice, that is a canary deployment. Everything below is one of those three levers, pulled harder. Smaller steps, longer looks Every production deployment spins up the new version as a canary next to a baseline: a fresh copy of the currently running version, started a

## Five Years of Kafka at Razorpay's UPI Switch

DevFeed: [Five Years of Kafka at Razorpay's UPI Switch](<https://devfeed.tech/articles/five-years-of-kafka-at-razorpay-s-upi-switch-24044.md>)

Original publisher: [Read original article](<https://engineering.razorpay.com/tryst-with-kafka-2f5cef766c45?source=rss----6407ad2e59af---4>)

Author: Kshitij Nawandar

Published: 2026-09-07T09:09:58Z

Content type: article

Language: en

Sources: [Razorpay](<https://devfeed.tech/sources/razorpay-engineering-medium.md>)

Topics: [Apache Kafka](<https://devfeed.tech/topics/apache-kafka.md>), [Amazon MSK](<https://devfeed.tech/topics/amazon-msk.md>), [Messaging](<https://devfeed.tech/topics/messaging.md>), [Event-Streaming](<https://devfeed.tech/topics/event-streaming.md>), [Publish-subscribe pattern](<https://devfeed.tech/topics/pubsub.md>), [razorpay](<https://devfeed.tech/topics/razorpay.md>), [Amazon Simple Queue Service (SQS)](<https://devfeed.tech/topics/amazon-simple-queue-service-sqs.md>), [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [aws-sns](<https://devfeed.tech/topics/aws-sns.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [aws](<https://devfeed.tech/tags/aws.md>), [aws-sns](<https://devfeed.tech/tags/aws-sns.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [event](<https://devfeed.tech/tags/event.md>), [growth](<https://devfeed.tech/tags/growth.md>), [kafka](<https://devfeed.tech/tags/kafka.md>), [messaging](<https://devfeed.tech/tags/messaging.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [payment](<https://devfeed.tech/tags/payment.md>), [payment-processing](<https://devfeed.tech/tags/payment-processing.md>), [performance](<https://devfeed.tech/tags/performance.md>), [platform](<https://devfeed.tech/tags/platform.md>), [queue](<https://devfeed.tech/tags/queue.md>), [razorpay](<https://devfeed.tech/tags/razorpay.md>), [switch](<https://devfeed.tech/tags/switch.md>), [upi](<https://devfeed.tech/tags/upi.md>)

### AI overview

Razorpay's UPI Switch grew from a monolith using two AWS SQS queues (handling a 400 TPS peak) into an event-driven system whose Kafka infrastructure became constrained by partition growth, connector routing failures, broker connection imbalance, stale DNS after MSK Serverless restarts, and an IAM-auth connection cap. The team replaced GoCloud Pub/Sub with the Kafka-native franz-go client, adding DNS recovery, connection controls, batching and metrics; it reports lower connection counts and publish latency, but marks those figures for verification. It also consolidated event topics by domain, parallelized consumer processing through worker pools while preserving per-partition ordering, isolated latency-sensitive and financial flows into separate gateway components, and moved to provisioned MSK with SASL/SCRAM. The excerpt says mixed-load benchmarks were run but gives no results. Remaining work includes consumer idempotency, restoring atomicity between database writes and Kafka publishing, and consistent retry/DLQ policies.

### Source excerpt

Preface The UPI Switch at Razorpay has evolved significantly in the five years since we started building it. The Switch is the platform that enables real-time payment processing with NPCI. When the team began, it was little more than an idea. Today it powers more than 70% of Razorpay's total UPI volume. Because UPI is inherently asynchronous, a messaging system sits at the heart of the Switch and has a direct impact on performance, reliability, and scale. What began as a straightforward queue became the core of the system, shaping how every new feature was designed and delivered. This post covers that evolution: the decisions that enabled growth, the ones that slowed us down, the operational issues that forced us to rethink our assumptions, and the optimizations that ultimately stabilized our Kafka-based infrastructure. This is the story of what we got right, what we got wrong, and how we eventually built something stable enough to grow on. The First Version: Monolith and SQS When we began building the UPI Switch, we weren't thinking about massive scale, distributed systems, or elegant event routing. So we built Switch v1 as a monolith. No microservices, no distributed orchestration: just one solid block of code doing everything. That was the right call. We needed to move fast, experiment, and learn, and we followed the Keep It Simple, Stupid (KISS) principle deliberately. For messaging, we picked AWS SQS: reliable, managed, and low on cognitive load. We didn't need ordering guarantees at the time, so a standard queue worked fine. We started with just two queues, and this setup held its ground. It handled a peak of 400 TPS during the IPL. The limitations showed up as the ecosystem grew. A single event, like a successful payment, needed to fan out into multiple workflows: Update NPCI with an API call Send callbacks to merchants about payment status Push structured data into our warehouse (AWS Redshift) To handle this, we started bolting on AWS SNS plus SQS for fan-ou

## How Razorpay Cut Its Metrics Bill by 62% Without Losing a Dashboard

DevFeed: [How Razorpay Cut Its Metrics Bill by 62% Without Losing a Dashboard](<https://devfeed.tech/articles/how-razorpay-cut-its-metrics-bill-by-62-without-losing-a-dashboard-24039.md>)

Original publisher: [Read original article](<https://engineering.razorpay.com/how-razorpay-cut-its-metrics-bill-by-62-without-losing-a-dashboard-2a7d5467df37?source=rss----6407ad2e59af---4>)

Author: Dhairya Mehta

Published: 2026-08-24T10:25:21Z

Content type: article

Language: en

Sources: [Razorpay](<https://devfeed.tech/sources/razorpay-engineering-medium.md>)

Topics: [observability](<https://devfeed.tech/topics/observability.md>), [observability pipelines](<https://devfeed.tech/topics/observability-pipelines.md>), [Logging and metrics](<https://devfeed.tech/topics/logging-and-metrics.md>), [Grafana](<https://devfeed.tech/topics/grafana.md>), [Prometheus](<https://devfeed.tech/topics/prometheus.md>)

Tags: [alerts](<https://devfeed.tech/tags/alerts.md>), [cardinality](<https://devfeed.tech/tags/cardinality.md>), [cost](<https://devfeed.tech/tags/cost.md>), [dashboard](<https://devfeed.tech/tags/dashboard.md>), [high-availability](<https://devfeed.tech/tags/high-availability.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [migration](<https://devfeed.tech/tags/migration.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [reliability](<https://devfeed.tech/tags/reliability.md>), [scraping](<https://devfeed.tech/tags/scraping.md>), [victoriametrics](<https://devfeed.tech/tags/victoriametrics.md>)

### AI overview

Razorpay reduced daily metrics ingestion from about 450 billion samples to about 170 billion while preserving useful dashboards and alerts. The audit found three sources of waste: infrastructure scraped every 30 seconds despite one-minute resolution being sufficient for its alerts and dashboards; high-availability vmagent pairs both scraped and sent the same samples, which VictoriaMetrics storage deduplication hid from queries but did not remove from pipeline costs; and 167 of the 500 highest-cardinality metrics were unused in alerts, dashboards, and observed queries over 90 days. Razorpay moved infrastructure scraping to 60 seconds, added leader-election sidecars so only one vmagent replica scraped at a time, and dropped unused metrics through reversible vmagent relabeling rules, removing about 50 billion daily samples. The active-standby design favors stopping scrapes during uncertainty to avoid split brain; reported failover took about seven seconds for graceful shutdown and 22 seconds after a hard crash.

### Source excerpt

Contributor: Saijal Shrivastava We cut our metrics ingestion by 62% without deleting a single useful dashboard or breaking an alert. Daily ingestion dropped from about 450 billion samples to about 170 billion. The surprising part was not one large optimization. It was three simple discoveries hiding in plain sight: Scrape intervals can multiply ingestion. High-availability scraping can silently send duplicate metrics when deduplication happens only at the storage layer. High-cardinality metrics are easy to create, expensive to keep, and hard to remove without ownership. We found these while preparing to move from a self-hosted VictoriaMetrics cluster to a managed monitoring platform. The migration started as a reliability project. The audit turned it into a cost and signal-quality project. We were not just moving monitoring data. We were moving years of accumulated assumptions about what was worth scraping. The Incident that Forced the Audit Our self-hosted VictoriaMetrics cluster had served us well for years. Then one storage node hit EBS volume throttling. Traffic shifted to the remaining storage nodes, the extra load pushed another node past its limits, and the storage layer collapsed. We saw the same pattern whenever a storage node became unavailable: traffic redistributed, the remaining nodes overloaded, and the cluster moved back toward failure. The collection, ingestion, and query components were still running, so the system looked alive from the outside. But the storage layer was down. Metrics stopped being persisted. Dashboards went blank. Alerts stopped evaluating. Recovery took hours. Teams fell back to logs and manual checks to understand production health. Figure 1: Cascading failure in the pipeline That made the reliability problem obvious. We needed a more stable monitoring architecture. We evaluated several options: self-hosted designs with disaster recovery built in, and fully managed alternatives. But when we priced the managed options, one number

## CI Doesn't Need On-Demand: Moving Our Build Pipelines to Spot Instances

DevFeed: [CI Doesn't Need On-Demand: Moving Our Build Pipelines to Spot Instances](<https://devfeed.tech/articles/ci-doesn-t-need-on-demand-moving-our-build-pipelines-to-spot-instances-24037.md>)

Original publisher: [Read original article](<https://engineering.razorpay.com/ci-doesnt-need-on-demand-moving-our-build-pipelines-to-spot-instances-6fff1cd92ba8?source=rss----6407ad2e59af---4>)

Author: Yuvraj Singh Singhel

Published: 2026-08-05T15:07:35Z

Content type: article

Language: en

Sources: [Razorpay](<https://devfeed.tech/sources/razorpay-engineering-medium.md>)

Topics: [CI/CD](<https://devfeed.tech/topics/cicd.md>), [self-hosted runner](<https://devfeed.tech/topics/self-hosted-runner.md>), [rate-limiting](<https://devfeed.tech/topics/rate-limiting.md>)

Tags: [artifacts](<https://devfeed.tech/tags/artifacts.md>), [aws](<https://devfeed.tech/tags/aws.md>), [build](<https://devfeed.tech/tags/build.md>), [builds](<https://devfeed.tech/tags/builds.md>), [ci](<https://devfeed.tech/tags/ci.md>), [ci-cd](<https://devfeed.tech/tags/ci-cd.md>), [costs](<https://devfeed.tech/tags/costs.md>), [github](<https://devfeed.tech/tags/github.md>), [github-actions](<https://devfeed.tech/tags/github-actions.md>), [job](<https://devfeed.tech/tags/job.md>), [jobs](<https://devfeed.tech/tags/jobs.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [node](<https://devfeed.tech/tags/node.md>), [pipelines](<https://devfeed.tech/tags/pipelines.md>), [pod](<https://devfeed.tech/tags/pod.md>), [pods](<https://devfeed.tech/tags/pods.md>), [reliability](<https://devfeed.tech/tags/reliability.md>), [retries](<https://devfeed.tech/tags/retries.md>), [runner](<https://devfeed.tech/tags/runner.md>), [self-healing](<https://devfeed.tech/tags/self-healing.md>)

### AI overview

Razorpay reports running 80% of its GitHub Actions CI workloads on AWS Spot instances, with a 60% reduction in CI compute spend and a 99.2% job success rate. Its Kubernetes recovery pipeline uses GitHub webhooks to detect failed jobs, classifies likely spot terminations by checking for a runner registration log line, retries jobs through the GitHub API, and periodically removes stale runner pods. The log check was a quick alternative to full AWS interruption-event correlation, but it broke after a runner update; metrics and safeguards now help catch divergence and prevent broad cleanup deletions. The account also describes histogram metrics to control Prometheus cardinality, idempotency keys and distributed locking to prevent duplicate retries, and exponential backoff with jitter and GitHub rate-limit handling to contain retry storms. The text notes that current classification can retry permanent failures and identifies finer failure classification, cost attribution, and multi-cluster support as future work.

### Source excerpt

Contributors: Guptaanuj CI/CD pipelines have always had a money-vs-stability problem. Run on-demand AWS instances and your build infrastructure is rock solid, expensive, and predictable. Run on spot instances and your costs drop 70-90%, but AWS can pull the rug with 2 minutes of warning. For most teams, this is a false choice. Either pay full price for reliability, or save money and accept that builds will fail in ways nobody can debug. At Razorpay, we stopped accepting that trade-off. We built a self-healing infrastructure layer for GitHub Actions on Kubernetes that runs 80% of our CI workloads on spot instances while maintaining a 99.2% job success rate. When AWS terminates a spot node mid-build, our system detects it, retries the job, cleans up the orphaned pods, and the developer never knows. This is the story of what we built, why polling wasn't an option, and the war stories that taught us how to do retries without burning everything down. The Problem With Spot Instances On CI Spot instances are AWS capacity that nobody else wants right now. The pricing is brutal compared to on-demand: a c5.2xlarge that costs around $0.34/hour on-demand drops to roughly $0.08/hour on spot. For workloads like CI/CD, where jobs are short-lived and parallelizable, the math is obvious. The catch is in the contract. AWS reserves the right to take spot capacity back at any moment, with a 2-minute warning. That works for some workloads. For others, it's catastrophic. GitHub Actions runners on Kubernetes is the hard case. A typical CI job goes like this: GitHub assigns the job to a runner. The runner is a pod on a Kubernetes cluster running on an AWS Spot instance. The job downloads dependencies, runs tests, builds artifacts. The runner reports back to GitHub. Now insert a spot termination at minute 4 of a 7-minute build. What happens? The runner pod dies mid-job. GitHub never gets a completion signal; the job hangs until timeout, then marks as "failed". A new runner pod gets schedule

## How We Refresh Razorpay's Data Warehouse 10x Faster with Graphs and Indexes

DevFeed: [How We Refresh Razorpay's Data Warehouse 10x Faster with Graphs and Indexes](<https://devfeed.tech/articles/how-we-refresh-razorpay-s-data-warehouse-10x-faster-with-graphs-and-indexes-24040.md>)

Original publisher: [Read original article](<https://engineering.razorpay.com/how-we-refresh-razorpays-data-warehouse-10x-faster-with-graphs-and-indexes-538abc244703?source=rss----6407ad2e59af---4>)

Author: Amit Prabhu

Published: 2026-07-14T14:06:16Z

Content type: article

Language: en

Sources: [Razorpay](<https://devfeed.tech/sources/razorpay-engineering-medium.md>)

Topics: [Analytics Pipeline](<https://devfeed.tech/topics/analytics-pipeline.md>), [Data pipelines](<https://devfeed.tech/topics/data-pipelines.md>), [data lake](<https://devfeed.tech/topics/data-lake.md>), [deltalake](<https://devfeed.tech/topics/deltalake.md>), [Apache Kafka](<https://devfeed.tech/topics/apache-kafka.md>), [Microservices](<https://devfeed.tech/topics/microservices.md>), [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [Data Quality](<https://devfeed.tech/topics/data-quality.md>), [sharding](<https://devfeed.tech/topics/sharding.md>), [parquet](<https://devfeed.tech/topics/parquet.md>)

Tags: [airflow](<https://devfeed.tech/tags/airflow.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [apache](<https://devfeed.tech/tags/apache.md>), [apache-iceberg](<https://devfeed.tech/tags/apache-iceberg.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [batch](<https://devfeed.tech/tags/batch.md>), [card](<https://devfeed.tech/tags/card.md>), [cardinality](<https://devfeed.tech/tags/cardinality.md>), [cdc](<https://devfeed.tech/tags/cdc.md>), [data](<https://devfeed.tech/tags/data.md>), [data-warehouse](<https://devfeed.tech/tags/data-warehouse.md>), [database](<https://devfeed.tech/tags/database.md>), [delta](<https://devfeed.tech/tags/delta.md>), [delta-lake](<https://devfeed.tech/tags/delta-lake.md>), [faster](<https://devfeed.tech/tags/faster.md>), [graphs](<https://devfeed.tech/tags/graphs.md>), [indexes](<https://devfeed.tech/tags/indexes.md>), [razorpay](<https://devfeed.tech/tags/razorpay.md>), [refresh](<https://devfeed.tech/tags/refresh.md>), [warehouse](<https://devfeed.tech/tags/warehouse.md>)

### AI overview

Razorpay replaced full refreshes for its five largest warehouse Facts with incremental batch processing, reporting about 90% less compute time and restored historical coverage that let it reduce TiDB retention. The pipeline models each Fact's joins as a dependency graph, reads daily deduplicated changes, and uses per-entity secondary indexes to find relevant S3 partitions and affected rows. Primary-table changes rebuild complete denormalised rows; secondary-table changes are traced back to affected primary keys and merged into only impacted partitions. High-cardinality dimensions can cause costly write amplification, so Razorpay instead supports some joins at query time: Iceberg tables bucketed by merchant_id let Trino prune scans when that key is included in join predicates. Rollout involved record-level reconciliation, shadow reports, and gradual traffic migration with fallback. The approach trades streaming for batch plus incremental work; the excerpt says the prior streaming system became too costly under highly mutable, high-volume joins. Reported gains apply to the five migrated Facts, with broader migration and real-time index work still on the roadmap.

### Source excerpt

Contributors: Utkarsh Koppikar Rohan Background Razorpay provides the payment infrastructure for millions of merchants globally. Behind every payment, settlement, and refund is a microservices architecture where each service owns its own database. While this keeps services independent and scalable, it creates a challenge for stakeholders who need to see across those boundaries. The Data Platform team manages the infrastructure that bridges this gap. Transactional data flows into the lake via CDC pipelines, ingested onto S3 in Delta Lake, Apache Iceberg, or plain Parquet formats. On top of the lake, we build domain-specific warehouse tables -- wide, pre-joined tables that co-locate all the data a consumer needs, queryable via Trino. These power two use cases: Analytics (internal dashboards on Tableau and Superset) and Reporting (merchants and regulated entities who download structured data exports; Razorpay generates nearly a million such reports per month). The warehouse tables that power both use cases are called Facts. A Fact is a flat denormalised table on S3, produced by joining 10 to 30 microservice tables and materialising the result once. A settlement Fact, for example, merges payments, refunds, adjustments, and card details into a single wide row so that a dashboard or report reads from a single table instead of joining across services in real time. It is closer to a domain-specific materialised view than a classical data warehouse fact table. We maintain over 50 such Facts, and approximately 40% of all merchant reports are served directly from them. As data volumes and the number of entities per fact grew, the batch generation pipeline began to show its limits, prompting us to rethink the refresh strategy, the data layout, and how to handle high-cardinality dimensions. The rest of this post covers that journey. The Full Refresh Pipeline: Our Baseline and the Pain The original full-refresh pipeline was straightforward. Schedule: Airflow schedules Spark jobs o

## How Razorpay runs network-isolated Hermes AI agents for employees

DevFeed: [How Razorpay runs network-isolated Hermes AI agents for employees](<https://devfeed.tech/articles/running-hermes-at-razorpay-a-network-isolated-self-improving-second-brain-for-every-employee-24042.md>)

Original publisher: [Read original article](<https://engineering.razorpay.com/running-hermes-at-razorpay-a-network-isolated-self-improving-second-brain-for-every-employee-f91d56bea3f1?source=rss----6407ad2e59af---4>)

Author: ashwath kumar

Published: 2026-07-12T14:22:53Z

Content type: article

Language: en

Sources: [Razorpay](<https://devfeed.tech/sources/razorpay-engineering-medium.md>)

Topics: [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>), [data](<https://devfeed.tech/topics/data.md>), [Embeddings](<https://devfeed.tech/topics/embeddings.md>), [Graphs](<https://devfeed.tech/topics/graphs.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [credentials](<https://devfeed.tech/tags/credentials.md>), [embeddings](<https://devfeed.tech/tags/embeddings.md>), [github](<https://devfeed.tech/tags/github.md>), [google](<https://devfeed.tech/tags/google.md>), [graph](<https://devfeed.tech/tags/graph.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [network](<https://devfeed.tech/tags/network.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [slack](<https://devfeed.tech/tags/slack.md>)

### AI overview

Razorpay describes its platform for running Hermes, an open-source AI agent, for employees. Each agent runs in an isolated Kubernetes namespace with encrypted storage, a separate cloud identity, and its own network policy. The article explains how the platform supports persistent autonomous sessions while limiting access to other employees' data and the public internet.

### Source excerpt

How we run a personal AI agent for everyone at Razorpay: always on, multi-model, and safe by construction. Contributors: Siddharth Tripathi Today, more than 220 Razorpay employees each have their own always-on AI agent. On a typical day, about 84 of them are actively working. Every one runs in its own isolated Kubernetes namespace, with its own encrypted storage, its own cloud identity, and its own network policy. It learns new skills as its owner works, and it keeps running long after they close their laptop: one employee's agent has already logged more than 15,000 sessions, 90% of them while its owner was asleep or away. Provisioning a new one takes under two minutes. Running the agents was never the hard part. Running them safely was: 220 of them, each with shell access and live credentials, without any single agent becoming a path into another employee's data or out to the open internet. The answer came down to one design choice, and everything in this post is a consequence of it: Isolation is a property of the infrastructure, not the application. Hermes itself is an open-source agent by Nous Research; what we built is the platform that runs it safely & isolated, for the whole company. Proof It's Real: One Instance, Eight Weeks In Before any of the architecture, here's the proof that people actually use this. The following is one real instance from our cluster, over its first eight weeks (numbers pulled live, the person anonymised). In eight weeks, this one user's Hermes ran 15,039 sessions. Only 391 of those were the person sitting down to chat with it; the other 13,570 were autonomous runs the agent kicked off on its own schedule while its owner was asleep or in meetings. That ratio is the whole idea in one statistic: the assistant does most of its work when you're not there. What is it doing in those runs? They'd wired up 21 always-on scheduled jobs that turn Hermes into a personal intelligence service: Ingest. Every hour it pulls from 23 Slack channels (plus

## Turning Scattered Data Into Queryable Segments at Scale: How Razorpay Built Its Customer Data...

DevFeed: [Turning Scattered Data Into Queryable Segments at Scale: How Razorpay Built Its Customer Data...](<https://devfeed.tech/articles/turning-scattered-data-into-queryable-segments-at-scale-how-razorpay-built-its-customer-data-24045.md>)

Original publisher: [Read original article](<https://engineering.razorpay.com/turning-scattered-data-into-queryable-segments-at-scale-how-razorpay-built-its-customer-data-3937c4b012de?source=rss----6407ad2e59af---4>)

Author: Varun Meka

Published: 2026-06-26T08:06:33Z

Content type: article

Language: en

Sources: [Razorpay](<https://devfeed.tech/sources/razorpay-engineering-medium.md>)

Topics: [data lake](<https://devfeed.tech/topics/data-lake.md>), [Apache Spark](<https://devfeed.tech/topics/spark.md>), [database-optimization](<https://devfeed.tech/topics/database-optimization.md>), [etl](<https://devfeed.tech/topics/etl.md>)

Tags: [banking](<https://devfeed.tech/tags/banking.md>), [campaign](<https://devfeed.tech/tags/campaign.md>), [card](<https://devfeed.tech/tags/card.md>), [cdp](<https://devfeed.tech/tags/cdp.md>), [consent](<https://devfeed.tech/tags/consent.md>), [customer-data](<https://devfeed.tech/tags/customer-data.md>), [customer-data-platform](<https://devfeed.tech/tags/customer-data-platform.md>), [devices](<https://devfeed.tech/tags/devices.md>), [discount](<https://devfeed.tech/tags/discount.md>), [fashion](<https://devfeed.tech/tags/fashion.md>), [growth](<https://devfeed.tech/tags/growth.md>), [job](<https://devfeed.tech/tags/job.md>), [loyalty](<https://devfeed.tech/tags/loyalty.md>), [native](<https://devfeed.tech/tags/native.md>), [net](<https://devfeed.tech/tags/net.md>), [pii](<https://devfeed.tech/tags/pii.md>), [razorpay](<https://devfeed.tech/tags/razorpay.md>), [saas](<https://devfeed.tech/tags/saas.md>), [scale](<https://devfeed.tech/tags/scale.md>), [spark](<https://devfeed.tech/tags/spark.md>)

### AI overview

Razorpay describes an in-house CDP that turns rules over derived customer attributes into reusable audience segments, replacing a former workflow that took 2-3 days with daily processing and real-time membership checks reported at under 30 ms and more than 1,500 requests per second. Its Airflow and Spark pipeline loads only attributes referenced by each rule set, canonicalizes definitions for deduplication, and reuses computed datasets across consumers. Batch segments are served from S3; low-latency segments are imported into versioned DynamoDB tables through retryable Temporal workflows, with promotion after validation to keep the prior version available during refresh. Lookup uses caller-supplied SHA-256 identifiers, so the serving layer does not store raw phone numbers. For quick audience sizing, Theta Sketches support AND, OR, and NOT set operations without full Spark runs; the excerpt reports estimates within ±3% for segments above a few thousand members 95% of the time, while small segments remain exact. The account says sketches are periodically rebuilt to limit drift and notes that near-real-time updates are still a future goal.

### Source excerpt

Turning Scattered Data Into Queryable Segments at Scale: How Razorpay Built Its Customer Data Platform A consent-native CDP that serves audience segments across 500M+ user profiles in under 30ms, with PII isolated to the source systems. The Problem We Were Solving A customer opens her favourite online shopping app, adds a few items to her cart, and pays INR 1,200 via UPI, powered invisibly by Razorpay. A week later she returns and pays using a saved Visa card from her laptop. Later that month, she places a larger INR 8,500 order through net banking from work. Three transactions. Three different payment instruments. Three different devices. To the merchant's engineering team, and to Razorpay's data systems, these could look like three completely different people, unless you've done the hard work of figuring out they're all the same customer. Now suppose this is a D2C fashion brand approaching their Diwali sale. The merchant's growth team has a clear plan: "Identify customers who have transacted at least once in the last 30 days, have spent more than INR 5,000 cumulatively this quarter, and haven't enrolled in our loyalty programme. Send them an early-access nudge with a personalized discount 48 hours before the public sale opens." A year ago, answering that question at Razorpay meant filing a cross-team data request, waiting for an analyst to write a custom Spark job, and getting an answer in 2-3 days. By the time the merchant had the segment, the Diwali sale was already live. The early-access window had closed. The campaign got sent to a broader, less-targeted audience, wasting spend on customers who would have bought anyway and leaving cold customers untouched. Now multiply that pain by millions of merchants. Razorpay powers payments and growth for over 12 million merchants. From D2C fashion brands and SaaS startups to subscription platforms, ed-tech companies, and the 2 million+ local merchants accepting QR payments every day. Together, they process billions of transaction

## From 750 Hours to 2 Hours: AI-Powered Security Triage at Razorpay

DevFeed: [From 750 Hours to 2 Hours: AI-Powered Security Triage at Razorpay](<https://devfeed.tech/articles/from-750-hours-to-2-hours-ai-powered-security-triage-at-razorpay-24038.md>)

Original publisher: [Read original article](<https://engineering.razorpay.com/from-750-hours-to-2-hours-ai-powered-security-triage-at-razorpay-c8baeac3a1d3?source=rss----6407ad2e59af---4>)

Author: Prathamesh Joshi

Published: 2026-06-09T14:56:35Z

Content type: news

Language: en

Sources: [Razorpay](<https://devfeed.tech/sources/razorpay-engineering-medium.md>)

Topics: [alert triage](<https://devfeed.tech/topics/alert-triage.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [code security](<https://devfeed.tech/topics/code-security.md>), [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [Secret Scanning](<https://devfeed.tech/topics/secret-scanning.md>), [software composition analysis](<https://devfeed.tech/topics/software-composition-analysis.md>), [human review](<https://devfeed.tech/topics/human-review.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-powered](<https://devfeed.tech/tags/ai-powered.md>), [api-key](<https://devfeed.tech/tags/api-key.md>), [backlog](<https://devfeed.tech/tags/backlog.md>), [context-aware-ai](<https://devfeed.tech/tags/context-aware-ai.md>), [engineering-velocity](<https://devfeed.tech/tags/engineering-velocity.md>), [false-positives](<https://devfeed.tech/tags/false-positives.md>), [noise](<https://devfeed.tech/tags/noise.md>), [razorpay](<https://devfeed.tech/tags/razorpay.md>), [sast](<https://devfeed.tech/tags/sast.md>), [scanners](<https://devfeed.tech/tags/scanners.md>), [security](<https://devfeed.tech/tags/security.md>), [security-findings](<https://devfeed.tech/tags/security-findings.md>), [static-analysis](<https://devfeed.tech/tags/static-analysis.md>), [triage](<https://devfeed.tech/tags/triage.md>)

### AI overview

Razorpay describes a live AI system that triages security findings and proposes fixes to reduce manual review. L1 fetches Semgrep findings and surrounding repository code, then uses relevant skills from a set of 29 to classify issues; reported accuracy is 75-80%. L2 generates fixes and pull requests for confirmed findings, with automatic remediation limited to verdicts above 85% confidence and lower-confidence cases sent for human review. The system loads 2-4 skills per finding, reducing analysis context from about 50K to 2.5K tokens. Harness orchestrates scheduled L1 runs every six hours and real-time L2 processing, with audit and observability features; humans review triage results before action. Trusted security reviewers' ticket comments can update skills. L3 rule tuning is planned for when L1 reaches 90% accuracy. The authors identify skill quality, accuracy improvement, and context across repositories as ongoing challenges.

### Source excerpt

Co-authors: Mahlaqahaque Mh, Keertiv, Hari Prasad Pujari How we taught AI to read code like a senior security engineer Every day, Razorpay engineers ship thousands of lines of code. Every line births new security findings. SAST scanners flag suspicious patterns. Dependency checkers find vulnerable libraries. Secret detection tools catch hardcoded credentials. The alerts pile up. Hundreds become thousands. The backlog becomes noise. We hit a breaking point. Developers faced security ticket counts climbing into the thousands, with most of them turning out to be false positives. The classic "alert that cried wolf" scenario played out daily. When everything is marked critical, nothing is. Developers stopped trusting security findings altogether. Security engineers weren't having a better time. Validating issues manually while fielding constant ad-hoc requests from frustrated developers. Trying to stop a waterfall with a teaspoon. The human bottleneck became the limiting factor in our security posture. The core problem was simple. Traditional static analysis tools excel at finding patterns that might be vulnerabilities. They lack context. They can't distinguish between a properly sanitized SQL query and a vulnerable one. Between a test API key and a production secret. Between a dangerous data flow and one protected by business logic. For every 10 alerts, 7-8 were false positives. Manual triage became the bottleneck. Security couldn't scale with engineering velocity. That's when we built what we call the Autonomous Security Special Ops system. An AI-powered engine that handles the heavy lifting so humans can focus on what actually matters. The Three-layer Intelligence System Rather than throwing more human hours at the problem, we built an AI architecture operating in three layers. L1: Context-Aware AI Triage (Live). Our intelligent first responder. Powered by 29 specialized sub-skills , it reads code context like a senior security engineer. When a SAST finding lands, L1

## Razorpay Oncall Agent: From 30-Minute Investigations to 90-Second AI Analysis

DevFeed: [Razorpay Oncall Agent: From 30-Minute Investigations to 90-Second AI Analysis](<https://devfeed.tech/articles/razorpay-oncall-agent-from-30-minute-investigations-to-90-second-ai-analysis-24041.md>)

Original publisher: [Read original article](<https://engineering.razorpay.com/razorpay-oncall-agent-from-30-minute-investigations-to-90-second-ai-analysis-5be7bcc461a4?source=rss----6407ad2e59af---4>)

Author: Anuj Gupta

Published: 2026-04-29T06:56:11Z

Content type: article

Language: en

Sources: [Razorpay](<https://devfeed.tech/sources/razorpay-engineering-medium.md>)

Topics: [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [supervisor agent pattern](<https://devfeed.tech/topics/supervisor-agent-pattern.md>), [hierarchical agent systems](<https://devfeed.tech/topics/hierarchical-agent-systems.md>), [Production Engineering](<https://devfeed.tech/topics/production-engineering.md>), [observability](<https://devfeed.tech/topics/observability.md>), [razorpay](<https://devfeed.tech/topics/razorpay.md>), [site-reliability-engineering](<https://devfeed.tech/topics/site-reliability-engineering.md>), [infrastructure monitoring](<https://devfeed.tech/topics/infrastructure-monitoring.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Retrieval Augmented Generation (RAG)](<https://devfeed.tech/topics/retrieval-augmented-generation-rag.md>), [telemetry](<https://devfeed.tech/topics/telemetry.md>), [health check](<https://devfeed.tech/topics/health-check.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [alert](<https://devfeed.tech/tags/alert.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [automated](<https://devfeed.tech/tags/automated.md>), [dashboards](<https://devfeed.tech/tags/dashboards.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [error](<https://devfeed.tech/tags/error.md>), [investigations](<https://devfeed.tech/tags/investigations.md>), [langgraph](<https://devfeed.tech/tags/langgraph.md>), [llm](<https://devfeed.tech/tags/llm.md>), [logs](<https://devfeed.tech/tags/logs.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [multi-agent](<https://devfeed.tech/tags/multi-agent.md>), [multi-agent-ai](<https://devfeed.tech/tags/multi-agent-ai.md>), [observability](<https://devfeed.tech/tags/observability.md>), [on-call](<https://devfeed.tech/tags/on-call.md>), [payment](<https://devfeed.tech/tags/payment.md>), [razorpay](<https://devfeed.tech/tags/razorpay.md>)

### AI overview

Razorpay's Oncall Agent automates initial incident investigation, cutting reported investigation time from 20-40 minutes to under 90 seconds. Built with LangGraph and an LLM, it uses a Supervisor Agent, architecture and runbook RAG, and parallel Kubernetes, Observability, PromQL, and AWS specialists. The system records structured evidence, correlates timelines, ranks root-cause hypotheses, and posts cited findings, confidence scores, and recommended actions to Slack. After three months in shadow mode, Razorpay reports an 80% reduction in mean time to investigate, a 50-60% improvement in mean time to resolve, and 6-8 engineering hours saved weekly. The article says the system is not yet in production: Razorpay is targeting 80%+ accuracy and plans rollout after validating it across hundreds of incident cases.

### Source excerpt

Our on-call engineers were spending 30 minutes investigating every production alert. Here's what happened when we automated it. At 3 AM, alerts don't care about your sleep schedule. When our payment infrastructure threw an error last month, our on-call engineer spent 32 minutes jumping between six different monitoring systems before understanding what was broken. One tool for metrics. Another for logs. Third tool for pod health. And multiple more for infrastructure, deployment history and database health. By the time they identified the root cause (a bad deployment), payment failures had already impacted customers for nearly 40 minutes. This wasn't their fault. They followed our runbook perfectly. The problem was that no single system could tell them "here's what's wrong and why." They had to manually connect dots across disconnected observability tools. That's when we asked ourselves: what if AI could do this investigation for us? The Metric Nobody Optimizes For The SRE world talks endlessly about Mean Time to Detect (how fast you catch problems) and Mean Time to Resolve (how fast you fix them). But there's a critical phase hiding between them: Mean Time to Investigate. MTTI is the gap from "we know it's broken" to "we know what to fix." At Razorpay, this phase was consuming 20-40 minutes per incident. With 15-20 incidents weekly, that's 6-8 hours of engineering time spent doing repetitive investigative work. Worse, the quality was inconsistent. Senior engineers knew exactly which systems to check for payment alerts. Junior engineers sometimes checked irrelevant dashboards or missed critical correlations. The investigation depended entirely on who was on-call that night. What We Built (And Why It Works) Razorpay Oncall Agent is a multi-agent AI system that automates incident investigation. The architecture is built on LangGraph, a framework for creating stateful workflows with conditional logic, and uses LLM as the reasoning engine. Here's how the components work t

## Razorpay's Linked Payments Architecture for Combining Payment Methods

DevFeed: [Razorpay's Linked Payments Architecture for Combining Payment Methods](<https://devfeed.tech/articles/the-checkout-frustration-razorpay-fixed-combining-payment-methods-24043.md>)

Original publisher: [Read original article](<https://engineering.razorpay.com/the-checkout-frustration-razorpay-fixed-combining-payment-methods-0e0b05fdf104?source=rss----6407ad2e59af---4>)

Author: Vatsal Mehta

Published: 2026-04-08T09:56:17Z

Content type: article

Language: en

Sources: [Razorpay](<https://devfeed.tech/sources/razorpay-engineering-medium.md>)

Topics: [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [Microservices](<https://devfeed.tech/topics/microservices.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [architectures](<https://devfeed.tech/tags/architectures.md>), [authorization](<https://devfeed.tech/tags/authorization.md>), [fintech](<https://devfeed.tech/tags/fintech.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [monolithic-architecture](<https://devfeed.tech/tags/monolithic-architecture.md>), [payment](<https://devfeed.tech/tags/payment.md>), [payment-gateway](<https://devfeed.tech/tags/payment-gateway.md>), [payment-processing](<https://devfeed.tech/tags/payment-processing.md>), [payments](<https://devfeed.tech/tags/payments.md>), [razorpay](<https://devfeed.tech/tags/razorpay.md>), [recovery](<https://devfeed.tech/tags/recovery.md>), [technical](<https://devfeed.tech/tags/technical.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

Razorpay describes Linked Payments, an architecture that lets customers combine a gift card with card, UPI, or another payment method for one order. The article explains the resulting challenges around authorization sequencing, failure recovery, and split settlement across payment-method microservices.

### Source excerpt

You have a $50 gift card. Your cart is $75. The checkout says "pick one payment method." This is a solvable problem. If you've ever tried to use a gift card for an online purchase, you know this frustration intimately. The gift card covers most of it, but not quite all. The checkout forces you to choose: use the gift card and abandon some items, or ignore the gift card and pay the full amount another way. Either choice feels wrong. This isn't a technical limitation of payment processing. It's an architectural one. Most payment systems treat each method as an isolated, complete transaction. You pay with a card OR UPI OR a gift card. The concept of composing multiple methods to fulfill a single order simply doesn't exist in traditional payment gateway architectures. At Razorpay, this limitation was costing merchants real money. Gift card redemption rates suffered because customers abandoned partial-value cards. Average order values stayed lower because customers couldn't combine store credit with additional payment. The business case for solving this was clear. That's why we built Linked Payments, a system that treats payment methods as composable building blocks. Customers can now use a gift card for $50, then cover the remaining $25 via card, UPI, or any other method. The system handles authorization sequencing, failure recovery, and settlement splitting automatically. The Complexity Hidden in "Just Combine Them" The challenge sounds simple until you consider what payment systems actually do. Traditional payment flows are beautifully simple. Customer initiates payment. System authorizes the full amount from one method. If authorization succeeds, capture the funds. Settle to the merchant. Either the payment worked or it didn't. One authorization, one capture, one settlement. Linked payments shatter this simplicity. Now you have multiple authorizations for a single order. Sequential dependencies where the second payment only happens if the first succeeds. Partial fail