
Vlad Macovei
18 Nov 2026 / 10 Min Read
Nishant Sameer, Vice President, Product Strategy at Juspay, explains why businesses adding a second or third payment processor rarely need a full orchestration platform, and how Hyperswitch Prism makes the integrations available as an open-source library.
Most businesses start with one payment processor. Sooner or later, they add another. It might be to lift authorisation rates in a market where the first processor struggles, to cut processing costs, to have a backup when the main provider goes down, or to offer a payment method the first one doesn’t support. The reasons vary. The engineering problem that follows doesn’t.
Every processor has its own API, its own way of describing a payment, and its own webhooks, error codes, and reporting data. Adding a second one means learning all of that from scratch and making it work alongside the first. By the third or fourth, keeping those integrations running becomes a full-time job in itself.
For a lot of teams, this is where the real choice gets made, and it’s often made by default. They don’t need a full orchestration platform. They need to talk to a few more processors without rewriting their payment code each time. Yet the integrations they need have only ever come in one of two forms: built by hand or packaged inside an orchestration platform. This article looks at what changes when you can use them on their own, through Hyperswitch Prism, an open-source, stateless library that translates a single payment request format into the API of each processor it supports. A disclosure first: I work at Juspay, which builds both Prism and Hyperswitch, an open-source payment orchestration platform.
For many businesses, orchestration is exactly what they need.
If you process high volumes across many markets, route payments on cost and approval rates, retry failures automatically, keep card details in a vault, and reconcile everything at the end of the day, you need a platform. It has to hold the state of every payment, manage configuration across providers, and give a payments team the tools to run it all. That is what orchestration is for.
But a lot of businesses aren’t there yet. Think of a retailer adding a second processor for one new market, a marketplace that wants a backup in case its main provider fails, or a company testing whether a cheaper processor can take part in its domestic traffic. These teams need connections to a few processors and a handful of simple rules. They don’t need a platform that stores payment state, manages configuration, or runs advanced optimisation.
Many of them end up taking on a whole platform anyway, for a fraction of its value.
It’s tempting to think that connecting to a processor is just a matter of calling its API. In practice, no two processors describe a payment the same way, and the differences show up in the same places every time:
Payment status alone shows the scale of it. Across the processors Hyperswitch connects to, there are at least 881 different values describing where a payment stands. Trustpay uses 48 on its own. [VM5] Each one has to be translated into one of a few dozen statuses a business can act on. Get one wrong, and a pending payment is booked as paid, or a decline that would have succeeded on retry is treated as final.
Over four years, the Hyperswitch team built and hardened integrations for more than 100 processors. They worked well in production, but they were locked inside the orchestration platform. Anyone who only wanted the integrations had to adopt everything else as well.
So, the team pulled them out into a separate open-source component, Hyperswitch Prism. The name comes from what a prism does to light: one beam goes in and leaves as many colours. Prism takes a payment request in one standard format and turns it into whatever each processor expects, then does the same in reverse when the processor replies.
For a developer, this makes life much simpler. Instead of writing separate code for every processor, they write it once, in Prism’s standard format, and it works across all supported processors. That covers the full payment lifecycle, from taking and refunding payments to recurring payments, Apple Pay and Google Pay, 3D Secure, and incoming webhooks.
A few design choices make it practical for a team that just wants the connections.
It works in the language your team already uses. Prism is available for Java, JavaScript, Go, Rust, and Python, with more on the way, so there’s no need to adopt a new technology to use it.
The core is built once and shared. The logic that translates between the standard format and each processor is written a single time, in Rust, and every language uses that same core instead of its own copy. So, a fix for one processor reaches every language at the same time.
It fits how your team already builds software. The simplest option is to add Prism as a library, a package inside your own application like any other. There’s nothing extra to run; each translation adds negligible latency, and it works well for serverless and edge setups. In this form, Prism hands back the ready-made request, and your application sends it with the tools it already uses, so your existing security settings and timeouts stay in charge. Teams running many separate services in different languages can instead deploy Prism once as its own service, from a Docker image, and have every application call it over the network using gRPC (i.e. an open-source, high-performance universal Remote Procedure Call (RPC) framework, originally created by Google and now governed by the Cloud Native Computing Foundation (CNCF)).
The service then talks to the processors itself, every team gets the same behaviour, and integrations can be updated without touching the applications that depend on them.
It’s stateless. There’s no database and nothing is stored between calls, so there’s no extra infrastructure to look after.
The biggest difference is that adding or swapping a processor stops being a project. Because your payment code already uses the standard format, bringing in a new processor is mostly configuration. If a cheaper option appears, or your main provider has an outage, moving traffic becomes a decision rather than a rebuild.
Routing stays in your hands. Prism deliberately has no routing engine, so for a team with simple needs, a few rules in its own code are enough: send this card type here, fail over to that processor if the first one is down.
The choice isn’t permanent either. If your payments operations grow to the point where a full orchestrator makes sense, the integrations underneath don’t have to change, because they are the same ones Hyperswitch uses.
The standard format Prism uses is defined in an open specification, written in Protobuf, a widely used language-neutral format, and kept separate from the code that implements it. Software that sits between a business and many vendors has to be neutral to be trusted. With an open specification, anyone can build their own implementation, and a business isn’t tied to the company that proposed it.
Software has been here before. JDBC gave Java applications one way to talk to any database, with each vendor supplying a driver. OpenTelemetry did the same for monitoring data. Payments has never had an equivalent, and processors have little reason to build one, so it has to come from the people who use their APIs.
Extending the approach beyond payments
Payments is the starting point. Payouts, fraud screening, and card vaulting have the same shape: many vendors, no common format, and the same translation rebuilt by every business that uses more than one of them.
Not every payments problem needs a platform. When the job is connecting to a few more processors, what matters is the integrations. Take them on their own, keep your own logic, and add a platform later if you ever need one.

Nishant Sameer is Vice President, Product Strategy at Juspay, where he leads new products bringing Hyperswitch to the US – the open-source composable payments infrastructure for merchants, banks, and vertical SaaS platforms. Nishant's work spans payment infrastructure, orchestration, and autonomous, interoperable systems built in partnership with merchants and fintechs. Before payments, he built products across biometrics, identity, adtech, and ecommerce, and spent a decade in devices, wireless, and multimedia systems engineering.
Juspay is a global payments technology company, redefining payments for 500+ global enterprises and banks. Founded in 2012, the company processes over 400 million daily transactions, exceeding an annualised total payment volume (TPV) of $1 trillion with 99.999% reliability. Headquartered in Bangalore, India, Juspay is powered by a global network of 1,500+ payment experts operating across San Francisco, Dublin, São Paulo, Singapore, and Dubai.
The Paypers is a global hub for market insights, real-time news, expert interviews, and in-depth analyses and resources across payments, fintech, and the digital economy. We deliver reports, webinars, and commentary on key topics, including regulation, real-time payments, cross-border payments and ecommerce, digital identity, payment innovation and infrastructure, Open Banking, Embedded Finance, crypto, fraud and financial crime prevention, and more – all developed in collaboration with industry experts and leaders.
Current themes
No part of this site can be reproduced without explicit permission of The Paypers (v2.7).
Privacy Policy / Cookie Statement
Copyright