backend development

This study addresses the lack of systematic guidance for enterprise software teams in choosing between monolithic and microservices architectures. The work proposes a decision-making framework that integrates technical and organizational factors, evaluating the trade-offs of each architecture across dimensions such as scalability, reliability, deployment efficiency, and organizational complexity. The assessment is grounded in system scale, business requirements, operational maturity, and long-term maintainability. Through architectural pattern analysis, a structured evaluation model, and multiple case studies, the authors develop a practical selection methodology tailored to real-world engineering contexts. This approach offers enterprises clear architectural evolution pathways and actionable guidelines aligned with their developmental stages, thereby significantly enhancing the rationality and sustainability of system design decisions.

Microservice system developers lack empirical evidence regarding the types, root causes, and remediation strategies of recurring issues. Method: We adopt a mixed-methods approach—quantitatively analyzing 2,641 open-source issues, qualitatively interviewing 15 practitioners, and conducting a global survey with 150 practitioners. Contribution/Results: We introduce the first comprehensive, domain-specific three-level taxonomy (“Issue–Cause–Solution”) for microservices. We identify five high-frequency issue domains—including technical debt, CI/CD pipeline failures, and exception handling—and three predominant root causes, notably generic programming errors. From our analysis, we distill 177 actionable, context-aware remediation strategies. This work establishes an empirical foundation for microservice fault diagnosis and mitigation, delivers practical guidance for industry practitioners, and pinpoints critical research directions for next-generation microservice engineering.

To address the high risk, substantial cost, and low feasibility associated with migrating legacy monolithic systems, this paper proposes a novel “expose-without-migrating” microservice adoption paradigm: legacy monoliths are directly exposed as REST-compliant microservices without code refactoring, via a two-stage automated approach. In Stage I, a multi-objective genetic algorithm—integrating word embeddings and semantic similarity analysis—is applied to method-level static code analysis to identify semantically and structurally aware service boundaries. In Stage II, a random forest classifier automatically generates RESTful APIs from the identified boundaries. Evaluated on the Spring Boot PetClinic benchmark, our method achieves an F1-score of 0.92 for service boundary identification and 89% accuracy in API generation. By relying solely on static analysis and eliminating the need for manual restructuring, the approach significantly reduces migration risks and engineering overhead.

This work addresses the low development efficiency and high maintenance overhead associated with manual implementation of RESTful microservices. We propose an API-first, LLM-powered automated code generation method that takes OpenAPI specifications as input and produces executable microservices via a novel LLM-driven generation framework. Crucially, we introduce— for the first time—a runtime log analysis and error feedback mechanism, enabling a closed-loop optimization paradigm: “specify → generate → execute → debug → refine.” Compared to conventional development practices, our approach significantly accelerates prototyping and reduces manual iteration cycles. Empirical evaluation with six industry practitioners demonstrates substantial improvements in coding automation and rapid experimentation capabilities. The method establishes a new pathway toward API-driven, intelligent software engineering.

This work addresses the lack of systematic understanding regarding runtime dependability vulnerabilities in microservice architectures. Adopting a State-of-Knowledge (SoK) methodology, we conduct the first unified modeling of faults and attack surfaces grounded in dependability dimensions—integrating fault-mode taxonomy, vulnerability propagation analysis, and synthesis of runtime detection and self-healing mechanisms. Our study yields the first comprehensive dependability threat landscape for microservices: identifying 12 architectural-level fault root causes and distilling 7 canonical runtime resilience patterns. Unlike prior surveys focused on offline prevention, this work centers on runtime detection and adaptive recovery, thereby bridging critical gaps in fault/vulnerability coverage and mechanistic categorization. The resulting framework provides both theoretical foundations and practical guidance for designing and engineering resilient microservice systems. (149 words)

This work addresses the challenge of effectively evaluating the trade-offs between data consistency and coordination overhead among distributed transaction patterns—such as Saga and TCC—in business logic-intensive microservice systems prior to production deployment. The authors propose a lightweight microservice simulator grounded in Domain-Driven Design (DDD), which, for the first time, integrates DDD aggregate root modeling with multiple transaction models to decouple business logic from communication and transactional infrastructure. The framework supports configurable deployment topologies and network constraints, enabling seamless transitions from centralized to fully distributed architectures while providing a deterministic verification environment. Empirical evaluation on complex multi-aggregate systems quantifies the performance, coordination overhead, and resilience of different transaction models, substantially reducing development costs and facilitating left-shifted architectural validation.

The Microservices Architecture (MSA) design pattern has become a staple for modern applications, allowing functionalities to be divided across fine-grained microservices, fostering reusability, distribution, and interoperability. As MSA-based applications are deployed to the Computing Continuum (CC), meeting their Service Level Objectives (SLOs) becomes a challenge. Trading off performance and sustainability SLOs is especially challenging. This challenge can be addressed with intelligent decision systems, able to reconfigure the services during runtime to meet the SLOs. However, developing these agents while adhering to the MSA pattern is complex, especially because CC providers, who have key know-how and information to fulfill these SLOs, must comply with the privacy requirements of application developers. This work presents the Carbon-Aware SLO and Control plAtform (CASCA), an open-source MSA-based platform that allows CC providers to reconfigure services and fulfill their SLOs while maintaining the privacy of developers. CASCA is architected to be highly reusable, distributable, and easy to use, extend, and modify. CASCA has been evaluated in a real CC testbed for a media streaming service, where decision systems implemented in Bash, Rust, and Python successfully reconfigured the service, unaffected by upholding privacy.

This study addresses a critical gap in the literature by shifting focus from structural aspects of microservice architectures to the role of developers in shaping organizational coupling (OC). Through longitudinal mining of GitHub repositories—including commits, issues, and pull requests—the authors identify three key developer roles: Jacks, Mavens, and Connectors. They quantify each role’s contribution to OC and its evolutionary dynamics, revealing for the first time that OC is fundamentally a role-driven phenomenon. Specifically, Connectors significantly intensify global coupling, whereas Jacks and Mavens exert more localized effects. Moreover, the co-occurrence of multiple roles amplifies coupling effects. These findings offer a novel, role-aware perspective for designing organizational structures in microservice ecosystems.

This study addresses the prevalent quality deficiencies—particularly in security, collaboration, and service interaction—observed among students developing microservices, highlighting a disconnect between academic instruction and industrial practice. Through a longitudinal course project, we conducted an empirical analysis of containerized microservice systems developed by 67 teams comprising 216 master’s students, systematically identifying 23 architectural anti-patterns at scale in an educational setting for the first time, with security-related issues being most prominent. Building upon existing anti-pattern taxonomies and integrating containerized deployment, project-based learning, and longitudinal assessment, we propose an educational intervention model that embeds security-by-design principles, API contracts, and CI/CD templates. Our findings demonstrate that reinforcing engineering discipline through this model significantly enhances teaching effectiveness and software quality.