2026· International Journal of All Research Education & Scientific Methods· Vol 14, pp. 516-521· 0 citations
TL;DR
This research will perform a comparative evaluation of monolithic architecture and microservices architecture with a focus on their performance and cost characteristics to help developers to choose one of the styles considering its performance and cost characteristics.
Abstract
This research will perform a comparative evaluation of monolithic architecture and microservices architecture with a focus on their performance and cost characteristics. Software architecture plays an important role for the scalability and efficiency of contemporary software products. Monolithic architecture implies the use of a single software codebase which makes applications easier to develop but more difficult to manage. In contrast to this, microservices architecture relies on dividing an application into separate autonomous services which helps to make it flexible and scalable. The methodology of the study will include analyzing the results of various experiments and analytical works conducted previously by other researchers. Literature review will cover all key aspects of performance of both architectural styles including response time, throughput and resource usage. Previous research has revealed that the best performance can be expected from monolithic architectures under low-load conditions and in a single machine environment due to lower communication overhead. However, microservices architecture demonstrates better performance in a scaled-up and distributed setting because of the possibility to scale each service independently. Also, it should be mentioned that despite resource optimization possibilities of microservices in cloud environment, microservices typically cost more than monolithic architectures. The main contribution of this work will be providing a systematic comparison of both styles which can help developers to choose one of the styles considering its performance and cost characteristics..
This paper analyzes the two software architectural approaches namely Monolithic Architecture vs Microservices Architecture when considering scalable software development, and puts the following into consideration: empirical trade-offs, scalability consideration, organizational implications, and development complexity.
Theophilus Bamise Ajala, A. Oduroye, I. Ayoade et al.· Asian journal of applied sci...· 0 citations
Microservices architectures are widely adopted for their promised scalability and modularity, yet empirical evidence comparing their runtime performance to monolithic designs remains context-dependent. This paper presents an experimental comparison of a monolithic and a microservices implementation of the same e-commerce application, both backed by a shared PostgreSQL database. Using k6, we subject both systems to identical HTTP workloads at 50 and 100 virtual users (VUs) over 60-second runs, measuring throughput, latency, and error rates. At 50 VUs, both architectures perform similarly with no errors. At 100 VUs, the microservices design achieves 5.4% higher throughput, 25% lower average latency, and 39% lower p95 latency than the monolith, while exhibiting a lower median error rate (0.00% vs 0.69%). The monolith shows consistent order-creation failures under load, whereas microservices failures are transient and confined to the cart service in one run. These results suggest that, in this deployment context, decomposing the system into microservices improves scalability and tail latency under stress, while introducing distinct, service-specific failure modes that must be managed.
Examining how Netflix has evolved its technological infrastructure through the adoption of microservices architecture, which has enhanced its scalability, fault tolerance, and overall performance, provides valuable insights into the broader implications of microservices architecture in modern software development.
C. Henríquez, Jarol Derley, Ramón Valencia et al.· 2 citations
Software architecture selection directly impacts system performance and resource efficiency. This motivates controlled comparisons to make pragmatic deployment decisions. This study compares the implementation of the same backend system, Node.js/Express and MariaDB, in a monolithic and microservices architecture with the same Docker resource allocation, 2 CPUs and 512 MB RAM per architecture, except database containers. The load test was carried out with Apache JMeter 5.6.3 with three levels of concurrency (50, 200, 500 users). Each scenario was performed 20 times within 60 s. The main metrics were response time P90, P95, throughput, error rate, CPU/RAM utilization. The monolithic implementation performed better than the microservices at all load levels. The monolith reached P90 131.35 ms and 429.89 req/s versus microservices P90 171.38 ms and 332.38 req/s at 50 users, and P90 1217.60 ms and 438.25 req/s versus 1534.50 ms and 343.24 req/s at 500 users. Statistical analysis All differences were statistically significant (Mann-Whitney U, p < 0.0001, |δ| = 1.000). For both architectures, the throughput plateaued at load levels. The most operationally significant difference in resource usage was in memory overhead at 500 users, the monolith used 95.31 ± 1.99 MiB compared to 319.43 MiB aggregate for microservices (3.35x higher). CPU utilization was broadly comparable across architectures. The results presented here are specific to this experimental configuration, i.e. a single-machine Docker deployment, two-service decomposition, and synchronous HTTP/REST communication, and should not be generalized to monolithic and microservices architectures in general.
Yoga Ari Tofan· JUTI: Jurnal Ilmiah Teknolog...· 0 citations
The increasing complexity of Internet of Things (IoT) applications has exposed the limitations of monolithic software architectures in addressing scalability, flexibility, and real-time processing requirements. Although microservice architectures offer a promising alternative, identifying optimal service boundaries remains a significant challenge, often resulting in excessive inter-service communication and degraded system performance when poorly defined. This study proposes a quantitative model for refactoring monolithic applications into microservices by integrating Domain-Driven Design (DDD) principles with measurable metrics, including service size, coupling, and scalability. The model systematically identifies optimal service boundaries through a structured evaluation framework. The proposed approach is validated using a case study of an IoT-based irrigation management system. Experimental results show a reduction in inter-service communication overhead and improved modularity and scalability compared to baseline decomposition approaches. The findings demonstrate that combining DDD concepts with quantitative analysis provides an effective and practical solution for guiding microservice migration in complex IoT environments. The average coupling score across the refactored system was recorded at 20.4%, which satisfies the theoretical requirement of remaining below 30% and aligns with empirical observations from successful microservice decompositions.
Munezero Immaculée Josélyne, Ngenzi Alexander, Hitimana Eric et al.· International Journal of Adv...· 0 citations
Context. Microservice architectures are widely adopted for building scalable cloud-native systems, enabling independent deployment, fine-grained service composition, and operational elasticity. Problem. Despite growing interest in sustainable software, research on energy efficiency in microservices spans operational, infrastructural, and architectural perspectives, but these are typically addressed in isolation. Existing studies focus on optimisation techniques or measurement approaches, with limited synthesis of how energy efficiency is considered, measured, and addressed at the architectural level. Goal. This study synthesises research on energy-efficient microservices by examining where energy efficiency is considered, how it is measured, and which architectural solutions have been proposed. Method. We conduct a systematic literature review following Kitchenham's guidelines, screening publications from four major digital libraries through a six-stage process with backward and forward snowballing, resulting in 40 primary studies. Results. Energy efficiency is predominantly addressed at runtime through monitoring, scheduling, and resource management, while design-time integration remains limited. Measurement practices are largely infrastructure-oriented and rely on model-based estimation and coarse-grained monitoring. Conclusion. Energy efficiency in microservices is primarily treated as an operational optimisation problem rather than a lifecycle-spanning architectural concern, highlighting the need for earlier architectural integration and improved measurement practices.
Eoan O'Dea, Roberta Capuano, P. Avgeriou et al.· 0 citations
