Transactional Resilience in Banking Microservices: A Comparative Study of Saga and Two-Phase Commit for Distributed APIs
Keywords:
Distributed transactions, Saga pattern, two-phase commitAbstract
Background:
Banking platforms are undergoing rapid transformation as monolithic core systems are decomposed into microservices and exposed via API ecosystems to partners, fintechs, and customer-facing channels. This architectural evolution exposes a long-standing tension in distributed systems: how to maintain transactional correctness across multiple services and databases without compromising availability, scalability, and responsiveness (Bucchiarone et al., 2019; Hasselbring & Steinacker, 2017). Classical distributed transaction protocols such as two-phase commit (2PC) were designed for tightly controlled database clusters, not for heterogeneous, failure-prone microservice landscapes; yet financial institutions still require strong guarantees for money movements and ledger consistency (Mohan et al., 1986; Gray, 1981; Hebbar, 2025).
Objective:
This article develops an in-depth, publication-ready conceptual analysis of distributed transaction management in banking APIs, comparing the Saga pattern and 2PC across architectural, operational, and business dimensions. Building strictly on the given references, it aims to synthesize a theoretically grounded view of when Saga-based orchestration or choreography should be preferred over 2PC, how each approach behaves under microservice failures, and how their trade-offs align with the constraints of the CAP theorem, reactive systems thinking, and modern high-availability design patterns (Garcia-Molina & Salem, 1987; Boner et al., 2018; Gilbert & Lynch, 2012; Ahluwalia & Jain, 2006; Hebbar, 2025).
Methods:
A qualitative methodology is used, consisting of a structured narrative review and conceptual comparison. Foundational work on transactions, recovery, and distributed databases is combined with contemporary literature on microservices, reactive architectures, and distributed transactions in microservice ecosystems (Haerder & Reuter, 1983; Mohan et al., 1986; Thomson et al., 2012; Bucchiarone et al., 2019; Salah et al., 2016; Lungu & Nyirenda, 2024). This is complemented by focused analyses of seminal and recent Saga-related contributions, including the original Saga formulation, enhanced Saga variants, and Saga frameworks such as SagaMAS, as well as refinements of 2PC for replicated state machines (Garcia-Molina & Salem, 1987; Limón et al., 2018; Daraghmi et al., 2022; Uyanik & Ovatman, 2020). Hebbar’s banking-specific comparison of Saga and 2PC serves as an anchor for financial-domain interpretation (Hebbar, 2025).
Results:
The synthesis shows that 2PC offers simple, strong atomicity semantics in relatively synchronous and tightly coupled environments but becomes increasingly brittle in microservice ecosystems characterized by partial failures, independent deployability, and cross-organizational boundaries (Mohan et al., 1986; Gray, 1981; Helland, 2007; Helland & Campbell, 2009). Enhancements like those proposed for replicated state machines mitigate some blocking behavior but do not fundamentally resolve the tension between global coordination and availability (Uyanik & Ovatman, 2020; Gilbert & Lynch, 2012). In contrast, Saga-based approaches trade strict atomicity for long-lived, semantically compensating transactions, aligning more naturally with microservice autonomy, reactive principles, and high availability but introducing complexity in the design of compensations, partial-failure handling, and observability (Garcia-Molina & Salem, 1987; Richardson, 2019; Štefanko et al., 2019; Lungu & Nyirenda, 2024; Hebbar, 2025).
Conclusion:
For modern banking APIs that must support openness, elasticity, and resilience while managing business-critical money flows, the evidence favors Saga-based designs as the default strategy for cross-service transactions, with 2PC reserved for bounded domains with strong coordination capabilities and tight control over participants (Hebbar, 2025; Helland, 2007; Lungu & Nyirenda, 2024). The article argues that practitioners should frame Saga versus 2PC not as a binary choice but as part of a broader design space governed by domain semantics, consistency requirements, and architectural boundaries, and calls for further empirical research on performance, fault behavior, and developer productivity under each paradigm.
References
Ahluwalia, K. S., & Jain, A. (2006). High availability design patterns. In Proceedings of the 2006 Conference on Pattern Languages of Programs (PLoP ’06) (p. 1). ACM Press.
Boner, J., Farley, D., Kuhn, R., & Thompson, M. (2018). The Reactive Manifesto. Retrieved from https://www.reactivemanifesto.org
Bucchiarone, A., Dragoni, N., Dustdar, S., Lago, P., Mazzara, M., Rivera, V., & Sadovykh, A. (2019). Microservices: Science and Engineering. Springer International Publishing.
Campbell, R. H., & Richards, P. G. (1981). SAGA: A system to automate the management of software production. In Proceedings of the May 4–7, 1981, National Computer Conference (AFIPS ’81) (p. 231). ACM Press.
Daraghmi, E., Zhang, C. P., & Yuan, S. M. (2022). Enhancing saga pattern for distributed transactions within a microservices architecture. Applied Sciences, 12(12), 6242.
Garcia-Molina, H., & Salem, K. (1987). Sagas. ACM SIGMOD Record, 16(3), 249–259.
Gilbert, S., & Lynch, N. (2012). Perspectives on the CAP theorem. Computer, 45(2), 30–36.
Gray, J. (1981). The transaction concept: Virtues and limitations. In Proceedings of the Seventh International Conference on Very Large Data Bases (VLDB ’81) (pp. 144–154). VLDB Endowment.
Haerder, T., & Reuter, A. (1983). Principles of transaction-oriented database recovery. ACM Computing Surveys, 15(4), 287–317.
Hasselbring, W., & Steinacker, G. (2017). Microservice architectures for scalability, agility and reliability in e-commerce. In Proceedings of the 2017 IEEE International Conference on Software Architecture Workshops (ICSAW) (pp. 243–246). IEEE.
Hebbar, K. S. (2025). Optimizing distributed transactions in banking APIs: Saga pattern vs. two-phase commit (2PC). The American Journal of Engineering and Technology, 7(06), 157–169. https://doi.org/10.37547/tajet/Volume07Issue06-18
Helland, P. (2007). Life beyond distributed transactions: An apostate’s opinion. In CIDR 2007 (pp. 132–141).
Helland, P., & Campbell, D. (2009). Building on quicksand. CoRR, abs/0909.1788.
Limón, X., Guerra-Hernández, A., Sánchez-García, A. J., & Arriaga, J. C. P. (2018). SagaMAS: A software framework for distributed transactions in the microservice architecture. In 2018 6th International Conference in Software Engineering Research and Innovation (CONISOFT) (pp. 50–58). IEEE.
Little, M., Maron, J., & Pavlik, G. (2004). Java Transaction Processing. Prentice Hall.
Lungu, S., & Nyirenda, M. (2024). Current trends in the management of distributed transactions in micro-services architectures: A systematic literature review. Open Journal of Applied Sciences, 14(9), 2519–2543.
Messina, A., Rizzo, R., Storniolo, P., Tripiciano, M., & Urso, A. (2016). The Database-is-the-Service pattern for microservice architectures. In M. E. Renda, M. Bursa, A. Holzinger, & S. Khuri (Eds.), Information Technology in Bio- and Medical Informatics (Vol. 9832, pp. 223–233). Springer International Publishing.
Mohan, C., Lindsay, B., & Obermarck, R. (1986). Transaction management in the R* distributed database management system. ACM Transactions on Database Systems, 11, 378–396.
Richardson, C. (2019). Microservices Patterns: With Examples in Java. Manning Publications.
Salah, T., Zemerly, M. J., Yeun, C. Y., AlQutayri, M., & Al-Hammadi, Y. (2016). The evolution of distributed systems towards microservices architecture. In 2016 11th International Conference for Internet Technology and Secured Transactions (ICITST) (pp. 318–325). IEEE.
Štefanko, M., Chaloupka, O., & Rossi, B. (2019). The saga pattern in a reactive microservices environment. In Proceedings of the 14th International Conference on Software Technologies (pp. 483–490). SCITEPRESS.
Thomson, A., Diamond, T., Weng, S.-C., Ren, K., Shao, P., & Abadi, D. J. (2012). Calvin: Fast distributed transactions for partitioned database systems. In Proceedings of the 2012 International Conference on Management of Data (SIGMOD ’12) (p. 1). ACM Press.
Uyanik, H., & Ovatman, T. (2020). Enhancing two-phase commit protocol for replicated state machines. In Proceedings of the 2020 28th Euromicro International Conference on Parallel, Distributed and Network-Based Processing (PDP) (pp. 118–121). IEEE.
Bucchiarone, A., Dragoni, N., Dustdar, S., Lago, P., Mazzara, M., Rivera, V., & Sadovykh, A. (2019). Microservices: Science and Engineering. Springer International Publishing.
Boner, J., Farley, D., Kuhn, R., & Thompson, M. (2018). Reactive manifesto. https://www.reactivemanifesto.org
Fowler, M. (2018). CQRS. https://martinfowler.com/bliki/CQRS.html
Downloads
Published
How to Cite
Issue
Section
License
Copyright (c) 2025 Lucas Meyer (Author)
This work is licensed under a Creative Commons Attribution 4.0 International License.
Authors retain the copyright of their manuscripts, and all Open Access articles are disseminated under the terms of the Creative Commons Attribution License 4.0 (CC-BY), which licenses unrestricted use, distribution, and reproduction in any medium, provided that the original work is appropriately cited. The use of general descriptive names, trade names, trademarks, and so forth in this publication, even if not specifically identified, does not imply that these names are not protected by the relevant laws and regulations.