At Glance Background
Payment moving from a wallet through a fraud check to a bank, with an undo arrow back to the wallet, illustrating the saga pattern

Where Did the Money Go? The Saga Pattern, Explained for Finance Teams

A payment passes through several systems, and one can fail halfway through. Here is how the saga pattern keeps every system in agreement, why it matters to finance, and what to ask your engineers.

Published: | Author: Levon Hovsepyan

A customer taps "Send." The money leaves their wallet, but it never arrives at the bank. Or it arrives twice. Or the payment sits on "pending" for days while your support team tries to work out what happened.

These problems rarely come from one big failure. They come from a payment passing through several separate systems, and one of them failing halfway. The saga pattern is the method engineers use to make sure that when this happens, every system ends up in agreement and no money is lost, duplicated, or stuck.

You don't need to be an engineer to understand it, and if you're responsible for payments, finance operations, or a financial product, it's worth knowing. This guide explains what the saga pattern is in plain language, why it matters to the business, and what to ask your engineering team.

The saga pattern in 60 seconds

  • The problem: modern payments pass through several systems, such as a wallet, a fraud check, and a bank connection. If one fails halfway, the others can end up out of step.
  • The solution: the saga pattern breaks a payment into small steps. If any step fails, the steps already done are reversed in a planned way, so everything goes back to a consistent state.
  • A simple comparison: it works like booking a trip. If the hotel is unavailable, you cancel the flight you already booked, instead of being left with half a trip.
  • Why finance should care: it prevents double charges, stuck payments, and records that don't match, which are the problems that cost money, trust, and audit time.
  • The trade-off: for a few moments, a payment is "in progress." A good design shows that clearly instead of hiding it.

Why do payments get stuck, lost, or charged twice?

Because a single payment is no longer handled by a single system. A typical digital payment touches a wallet or account system, a fraud check, a connection to a bank or card processor, and a notification service. Each one keeps its own records, and each one can fail on its own.

In older systems, everything sat in one database, and the database itself guaranteed "all or nothing": either the whole payment happened, or none of it did. Once a payment is spread across separate systems, that built-in guarantee no longer covers the whole journey, as Microsoft's architecture guidance explains. And an outside bank or processor was never covered by your database to begin with.

Without a deliberate design, this is what goes wrong:

  • Charged twice: a request times out, the system tries again, and both attempts go through.
  • Money leaves but never arrives: the first step succeeds, a later one fails, and nothing reverses the first.
  • Stuck on "pending": nobody can tell which steps finished, so the payment sits unresolved.
  • Records that don't match: your system says one thing, the bank's report says another, and someone has to investigate by hand.

Four payment failures: double charges, lost money, stuck payments and mismatched records

What is the saga pattern, in simple terms?

The saga pattern is a way of completing a multi-step process across several systems so that it either finishes completely or is undone cleanly. Each step is completed on its own. If a later step fails, the earlier steps are reversed by planned "undo" actions, which engineers call compensating transactions.

Think of booking a trip online: a flight, a hotel, and a rental car, each from a different company. If the hotel turns out to be full after the flight is booked, a good booking site cancels the flight for you, instead of leaving you with a plane ticket to nowhere. That is a saga.

The idea isn't new. It comes from a 1987 database research paper by Hector Garcia-Molina and Kenneth Salem, and it became widely used once software was split into separate services.

Here is how it works for a payment, where a customer sends money from a digital wallet to a bank account:

Four-step wallet-to-bank payment saga with planned undo steps that release the hold if a step fails.

The money is only held, not moved, until the bank confirms. So if the bank says no, the hold is simply released, and the customer's balance is exactly as it was.

The order matters too. Sending money to the bank is the hardest step to take back, so it happens last, after every cheaper check has passed. Putting the step that can't be undone at the end is one of the most important decisions in designing any payment flow.

Why should finance and operations leaders care?

Because every payment that ends up in the wrong state becomes a cost: a refund to process, a customer to calm down, an investigation for the finance team, and an awkward question in the next audit. The saga pattern is how those problems are prevented by design instead of cleaned up by hand.

Your platform may need a closer look if you recognize any of these signs:

  • Customers report being charged twice, or payments stuck on "pending."
  • Finance spends hours each week matching your records against bank or processor reports.
  • Nobody can quickly explain what happened to a specific transaction.
  • Adding a new bank, payment method, or partner feels risky, because changes break other parts of the flow.
  • Auditors ask for a transaction's full history, and assembling it takes days.

What are the two ways to run a saga?

There are two approaches, and the difference is easy to picture. In choreography, each system reacts to the others, like dancers who follow the music without a leader. In orchestration, one coordinator directs every step, like a conductor leading an orchestra.

 

Choreography (no leader)

Orchestration (a coordinator)

How it works

Each system announces what it did, and the next one reacts

A coordinator tells each system what to do and tracks progress

Main advantage

Simple for short flows; no single point of failure

The whole payment journey can be seen, tested, and audited in one place

Main drawback

Hard to see the full journey or test it end-to-end

One more component to build and run

Best for

Short flows with a few steps

Payments and other regulated flows

Choreography vs. orchestration for running a payment saga.

For money, orchestration is usually the safer choice, because it gives you one clear record of what happened to every transaction. Microsoft's guidance describes the same trade-offs in technical detail.

What keeps a payment saga safe?

A saga only protects money if it is built with a few safeguards. Each has a technical name, but the idea behind each one is simple:

  1. Pressing "pay" twice only charges once. Engineers call this idempotency. Every request carries a unique reference, so if it's sent again after a timeout, the bank or processor recognizes it and doesn't repeat it.
  2. Every "undo" is planned in advance. Some actions can't simply be reversed: money already sent to another bank is gone, so the undo is a refund or a reversal, with its own rules.Microsoft's guidance on compensating transactions also notes that an undo can fail itself, so the system must be able to pick up where it stopped.
  3. The step that can't be undone goes last. Everything that can still fail cheaply happens first.
  4. Every step is recorded. If a system restarts in the middle of a payment, it knows exactly where it stopped. The same record gives auditors a complete history of each transaction.
  5. "In progress" is shown honestly. While a payment is running, customers see a clear pending status, and held money can't be spent twice.
  6. The books are checked against the bank. Regular reconciliation between your records and the bank's or processor's reports catches anything the saga itself couldn't see.

One more: a payment that stays pending longer than expected should alert someone automatically, not wait for a customer to complain.

Questions to ask your engineering team or technology partner

You don't need to review code to know whether your payment flows are protected. These questions, asked in plain language, will tell you a lot:

  • If a payment fails halfway, what exactly happens to the money, and who finds out?
  • Can a retried request ever charge a customer twice? How do we know?
  • For each step that moves money, what is the planned way to undo it?
  • Can we see the full history of any single transaction in minutes, not days?
  • How often do we reconcile our records with the bank and processors, and is it automated?
  • What alerts us when a payment is stuck?

Clear, confident answers are a good sign. Vague ones usually mean the problem is being handled by people after the fact, not by the system's design.

What does this look like in real financial systems?

The same ideas show up in every financial system that moves money or data between services: check before acting, track every transaction from start to finish, handle failures on purpose, and keep a complete record. 2 platforms VOLO has built as a technological partner in finance show how this looks in practice.

A national digital wallet. For MobiDram, a mobile wallet VOLO has built and evolved for more than ten years, a dedicated transaction engine routes, settles, and reconciles payments across banks and telecom providers. It follows every transaction from the first check, through any exceptions, to the final balance, across more than 50 connected services and banks. Read the MobiDram case study.

Automated regulatory reporting for a bank. For one of Armenia's leading banks (anonymized as IBank), VOLO built an event-driven platform that sends regulatory reports automatically to the central bank and other authorities. Every report is checked before it is sent, with encryption, access controls, and a full audit trail built in from day one, and the platform was delivered well ahead of a Q4 2025 regulatory deadline. Read the IBank case study.

The bottom line

When a payment passes through several systems, something will eventually fail halfway. The saga pattern makes sure that when it does, the money ends up exactly where it should: completed, or cleanly returned. For finance teams, that means fewer double charges, fewer stuck payments, and far less time spent matching records by hand.

If payments on your platform get stuck, duplicated, or hard to trace, talk to our engineers. You can also see how we approach cloud and system architecture and our work for the financial sector.

At Glance Background
levon hovsepyan avatar

Levon is an experienced technology consultant leading the strategic direction of VOLO. His work focuses on AI enablement, digital transformation, and how organizations adopt and govern technology at scale.

With a background in engineering and product leadership, he brings a systems-level perspective to technology and business decisions. His writing explores AI adoption, engineering discipline, and leadership in building reliable digital systems in complex, regulated environments.

Levon Hovsepyan Chief Executive Officer

Related Blogs

Cta Background

Subscribe to our Newsletter

Frequently Asked 
Questions

Still have a question?

Contact us We'll be happy to help you.

Levon HovsepyanNune Darbinyan

It completes a process that spans several systems, so it either finishes fully or is cleanly undone. Each step runs on its own, and if a later step fails, the earlier ones are reversed by planned undo actions.

Booking a trip with a flight, a hotel, and a car from different companies. If the hotel fails, the flight is cancelled. In payments: money is held in a wallet, checks run, the transfer goes to the bank, and if the bank rejects it, the hold is released.

Usually because the payment passed through several systems and one step didn't confirm. Without a clear record of which steps finished, the system can't decide whether to complete the payment or reverse it, so it waits.

In a well-designed system, the steps already completed are reversed automatically, such as releasing held funds or issuing a refund, and the customer sees a clear status. In a poorly designed one, money can end up in the wrong place until someone fixes it by hand.

It's the planned undo for a step that has already happened. Sometimes that's a simple reversal, like releasing a hold; sometimes it's a new action, like a refund, because the original can't be erased.

It means that sending the same payment request twice has the same effect as sending it once. It's what prevents a retried request from charging a customer twice.

Not quite. A database rollback erases changes as if they never happened. A saga can't erase a step that's already finished, so it runs a new undo action instead, and the full history stays on record.

Two-phase commit makes every system wait and lock its data until all of them agree, so every system must take part. A saga lets each step finish on its own and relies on undo actions if something fails later. Sagas work with outside banks and processors; two-phase commit generally doesn't.

No specific tool is required. RabbitMQ, Kafka, and cloud services such as Azure Service Bus and Amazon SQS can all carry the messages a saga needs. The right choice depends on volume, history needs, and what the team already runs.

When a process lives inside one system and one database, or when failures are mostly temporary and a simple retry is enough. A saga adds complexity, so it should solve a real problem.

Looking for a technology partner who understands the complexity of financial systems?

  • 24 hrs average response time
  • Team of Experts
  • 100% delivery rate