Architectural Trade-offs in Modern Software Engineering: A Comparative Study of Monolithic, Modular Monolithic, and Microservices Paradigms
Keywords:
Software architecture, monolithic architecture, microservices, modular monolith, distributed systems, Conway's Law, system design, architectural trade-offsAbstract
Choosing a software architecture is one of the most consequential decisions a software engineering team makes, yet in practice this choice is often driven by industry fashion rather than reasoned analysis. This paper examines three dominant architectural paradigms — the monolithic architecture, the modular monolithic architecture (colloquially the "minilith"), and the microservices architecture — and analyses their practical trade-offs across six engineering dimensions: deployment complexity, transactional consistency, independent scalability, fault isolation, cognitive load, and evolutionary migration potential. The central argument is that the modular monolithic architecture occupies an underused but practically valuable position in the design space, delivering the structural discipline of microservices without the distributed systems overhead those systems impose on teams that are not ready for it. A practitioner decision framework supported by three illustrative case scenarios is presented to guide architectural selection. The paper draws on peer-reviewed literature in software architecture, distributed systems, and organizational theory, and makes an explicit case against the trend of adopting microservices by default rather than by deliberate design.
References
Bass, L., Clements, P., & Kazman, R. (2012). Software architecture in practice (3rd ed.). Addison-Wesley.
Cerny, T., Donahoo, M. J., & Trnka, M. (2018). Contextual understanding of microservice architecture: Current and future directions. ACM SIGAPP Applied Computing Review, 17(4), 29–45. https://doi.org/10.1145/3241961.3241963
Conway, M. E. (1968). How do committees invent? Datamation, 14(4), 28–31.
Dragoni, N., Giallorenzo, S., Lafuente, A. L., Mazzara, M., Montesi, F., Mustafin, R., & Safina, L. (2017). Microservices: Yesterday, today, and tomorrow. In M. Mazzara & B. Meyer (Eds.), Present and ulterior software engineering (pp. 195–216). Springer. https://doi.org/10.1007/978-3-319-67425-4_12
Foote, B., & Yoder, J. (1999). Big ball of mud. In N. Harrison, B. Foote, & H. Rohnert (Eds.), Pattern languages of program design 4 (pp. 654–692). Addison-Wesley.
Forsgren, N., Humble, J., & Kim, G. (2018). Accelerate: The science of lean software and DevOps. IT Revolution Press.
Fowler, M. (2015, June 3). MonolithFirst. martinfowler.com. https://martinfowler.com/bliki/MonolithFirst.html
Fowler, M., & Lewis, J. (2014, March 25). Microservices. martinfowler.com. https://martinfowler.com/articles/microservices.html
Garcia-Molina, H., & Salem, K. (1987). Sagas. ACM SIGMOD Record, 16(3), 249–259. https://doi.org/10.1145/38714.38742
Hansson, D. H. (2016, February 29). The majestic monolith. Signal v. Noise. https://m.signalvnoise.com/the-majestic-monolith/
Jamshidi, P., Pahl, C., Mendonça, N. C., Lewis, J., & Tilkov, S. (2018). Microservices: The journey so far and challenges ahead. IEEE Software, 35(3), 24–35. https://doi.org/10.1109/MS.2018.2141039
Kleppmann, M. (2017). Designing data-intensive applications. O'Reilly Media.
Kolny, M. (2023, March 22). Scaling up the Prime Video audio/video monitoring service and reducing costs by 90%. Amazon Prime Video Tech. https://www.primevideotech.com/video-streaming/scaling-up-the-prime-video-audio-video-monitoring-service-and-reducing-costs-by-90
MacCormack, A., Rusnak, J., & Baldwin, C. Y. (2006). Exploring the structure of complex software designs: An empirical study of open source and proprietary code. Management Science, 52(7), 1015–1030. https://doi.org/10.1287/mnsc.1060.0552
Nagappan, N., Murphy, B., & Basili, V. (2008). The influence of organizational structure on software quality. In Proceedings of the 30th International Conference on Software Engineering (pp. 521–530). ACM. https://doi.org/10.1145/1368088.1368160
Newman, S. (2021). Building microservices (2nd ed.). O'Reilly Media.
Richards, M., & Ford, N. (2020). Fundamentals of software architecture. O'Reilly Media.
Richardson, C. (2018). Microservices patterns: With examples in Java. Manning Publications.
Segment Engineering. (2018, October 2). Goodbye microservices: From 100s of problem children to 1 adoptable monolith. Segment Engineering Blog. https://segment.com/blog/goodbye-microservices/
Shaw, M., & Garlan, D. (1996). Software architecture: Perspectives on an emerging discipline. Prentice Hall.
Shopify Engineering. (2019, September 19). Deconstructing the monolith: Designing software that maximizes developer productivity. Shopify Engineering Blog. https://shopify.engineering/deconstructing-monolith-designing-software-maximizes-developer-productivity
Skelton, M., & Pais, M. (2019). Team topologies: Organizing business and technology teams for fast flow. IT Revolution Press.
Taibi, D., Lenarduzzi, V., & Pahl, C. (2017). Processes, motivations, and issues for migrating to microservices architectures: An empirical investigation. IEEE Cloud Computing, 4(5), 22–32. https://doi.org/10.1109/MCC.2017.4250931
Taibi, D., & Systä, K. (2019). From monolithic systems to microservices: A decomposition framework. In Proceedings of the 9th International Conference on Cloud Computing and Services Science (pp. 153–164). SciTePress. https://doi.org/10.5220/0007755301530164
Downloads
Published
Issue
Section
License
Copyright (c) 2026 Satish Chavali (Author)
This work is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License.
