Article

October 19, 2026

Migration of a service-oriented system to containerized distribution with Docker and Kubernetes

Migration of a Service-Oriented System to Containerized Distribution with Docker and Kubernetes

Roberto Pedroso Pires Filho; Diego Marques de Carvalho

DOI: 10.22167/2675-6528-202601385

Article prepared by the ResumeAI tool, an artificial intelligence solution developed by the Pecege Institute focused on synthesis and writing.

Summary

This study addressed the modernization and migration of a service-oriented system, based on .NET Framework 4.8 with Microsoft SQL Server, aiming to facilitate software distribution, reduce installation errors, and optimize scalability and resilience in heterogeneous infrastructures. The methodology employed containerization of application components (UI, APP) into Windows Server images and the SQL Server database into a Linux image, using Docker and Kubernetes. The “Lift and Shift” strategy was adopted, and challenges with SQL Server compatibility in Docker Windows were overcome by implementing a hybrid Kubernetes cluster, where Windows nodes hosted the application layers and Linux nodes hosted the database. Docker Compose was used for local orchestration and health checks, while Kubernetes managed deployments, StatefulSets, services, and secrets for production environments, ensuring data persistence via Persistent Volume Claims and automatic recovery. The results demonstrated the technical feasibility and strategic benefits of containerization, establishing a modular delivery model that eliminated critical manual configuration variables and increased system resilience. Significantly lower resource consumption was observed compared to virtual machine-based solutions. However, a limitation was identified for single-server clients due to the complexity of coexisting Windows and Linux containers on an un-orchestrated host. It was concluded that the approach is effective for medium to large-scale deployments, providing a solid foundation for future modernizations and advanced scalability.

Keywords: .NET Framework; Hybrid infrastructure; Orchestration; Resilience; SQL Server.

1. Introduction

The contemporary landscape of software engineering is characterized by increasing complexity in managing application dependencies and ensuring their operational consistency across diverse environments. This challenge is particularly pronounced for systems operating in heterogeneous infrastructures, where the variability of configurations and requirements can compromise stability and performance. In this context, containerization has emerged as an indispensable strategy to mitigate these issues, consolidating itself as a fundamental pillar within DevOps methodologies to ensure efficiency, automation, and scalability in continuous software delivery (Gajula, 2025). The ability to package an application and all its dependencies into an isolated and portable unit has revolutionized how systems are developed, deployed, and managed.

The system in question, a service-oriented software based on .NET Framework 4.8 with Microsoft SQL Server, exemplifies the challenges inherent in this complexity. It is widely used by financial institutions and banks, processing a high volume of critical and sensitive data. The diversity of installation environments is vast, ranging from “on-premises” servers with a single machine hosting the entire application and the database, to cloud infrastructures with multiple high-performance virtual machines. This heterogeneity imposes serious difficulties on the software vendor, resulting in little control over environment configuration, frequent installation errors, inadequate resource allocation, and consequent performance and operational issues. Clients with higher processing volumes frequently question the product’s scalability, facing daily bottlenecks. The lack of standardization and the propensity for manual errors make system maintenance and evolution a costly and error-prone process.

Virtualization, in its various forms, has been crucial for the advancement of cloud computing, enabling the abstraction and partitioning of hardware into isolated environments through a hypervisor. However, this approach frequently introduces significant “overhead” due to the additional layer that manages access to the host’s physical resources (Melo et al., 2025). In contrast, containerization, which represents operating system-level virtualization, offers a lighter and more efficient solution. Containers allow for the isolated execution of applications, sharing the same host operating system kernel, which drastically reduces “overhead” and optimizes resource utilization. This feature is particularly advantageous for software that demands high performance and processes large volumes of data. Empirical data corroborate the superiority of containerization in terms of resource efficiency. A survey conducted with companies that adopted both technologies revealed that sixty-seven percent report that their deployments on virtual machines consume two to four times more RAM than their containerized counterparts (Damarapati, 2025). Additionally, it was observed that containerized deployments exhibit, on average, a twenty-eight percent increase in throughput and a thirty-seven percent reduction in latency compared to virtual machine-based solutions (Damarapati, 2025). This optimization of resources and performance is a critical factor for systems dealing with intense workloads and response-time sensitive applications.

In this scenario, Docker positions itself as the central platform for packaging applications into portable containers, ensuring consistency and simplification throughout the software lifecycle, from development to production (Gajula, 2025). It facilitates the creation of immutable images that encapsulate the application and all its dependencies, eliminating environment conflicts and ensuring reproducibility. However, to manage the complexity of distributed applications and ensure scalability, high availability, and resilience at scale, a robust orchestration tool is necessary. Kubernetes (K8s) emerges as the dominant container orchestrator, providing a framework to automate the deployment, scaling, and management of containerized applications. It allows for declarative definition of the desired infrastructure state, automatically managing resource allocation, load balancing, data persistence, and fault recovery. One of its most relevant capabilities for this study is its support for hybrid clusters, which allow the coexistence of nodes from different operating systems, such as Windows and Linux, in the same orchestrated environment. This functionality is essential for modernizing legacy systems that have specific platform dependencies, such as .NET Framework 4.8 which requires Windows hosts, while benefiting from the efficiency and support of official SQL Server images on Linux.

Given the challenges of distribution, installation, and scalability imposed by the legacy architecture and the heterogeneity of client environments, containerization emerges as a strategic solution to standardize the software delivery and operation model. The adoption of Docker and Kubernetes offers the ability to eliminate critical manual configuration variables, reduce deployment errors, and increase system resilience, while optimizing resource consumption. This study therefore aims to modernize and migrate a service-oriented system, based on .NET Framework 4.8 with Microsoft SQL Server, to a containerized infrastructure, using Docker and Kubernetes, with the goal of facilitating software distribution, reducing installation errors, and optimizing scalability and resilience in heterogeneous infrastructures.

2. Material and Methods

This study employed a software engineering approach, characterized as applied research and a case study. The central objective was the modernization and migration of a legacy system to a containerized infrastructure, using Docker and Kubernetes. The research focused on the practical implementation and evaluation of the technical feasibility of containerization to solve challenges of distribution, installation, and scalability in heterogeneous environments. The nature of the work involved the application of existing technologies to solve a real engineering problem, with a focus on solving a specific business problem.

The study’s context was a service-oriented system, based on .NET Framework 4.8 with Microsoft SQL Server, widely used by financial institutions and banks for reconciling critical and sensitive data. This system faced challenges in dependency management, operational consistency, and scalability across heterogeneous infrastructures, ranging from “on-premises” servers to cloud environments. The unit of analysis was the legacy system itself, named “System”, and its components (user interface, application, and database). The research was conducted without a specific declared period, focusing on technical implementation.

The population and sample of this study consisted of the specific legacy system, referred to as “System”, in its current state of development and operation. There was no selection of external participants or documents, as the research was configured as a single case study, focused on the transformation of an existing application. The selection criteria were intrinsic to the nature of the system, which required the migration of .NET Framework 4.8 components (Windows-dependent) and Microsoft SQL Server to a containerized environment, aiming to improve its distribution and scalability.

The instruments used for containerization and orchestration included Docker for application packaging and Kubernetes for large-scale container management. For code development and editing, Microsoft VS Code was employed. The construction of Docker images was performed from specific Dockerfiles for each system component. Local orchestration was defined through declarative YAML manifests for Docker Compose, while cloud orchestration used YAML manifests for Kubernetes, managing Deployments, StatefulSets, and Services.

The research execution began with the analysis of the legacy system and the choice of the “Lift and Shift” strategy for migration, keeping the application “as-is” in containers. Subsequently, three alternatives for SQL Server containerization were evaluated, culminating in the decision to use a hybrid Kubernetes cluster. Later, the system was decomposed into three main components: User Interface (UI), Application (APP), and Database (DB), each containerized individually.

The containerization step involved creating Docker images for the UI and APP components, based on Windows Server due to the dependency on .NET Framework 4.8. For the DB component, an official SQL Server 2022 image on Linux was used, with a custom startup script for backup restoration and user creation. This approach allowed for service decoupling, respecting the operating system needs of each layer.

Local orchestration was implemented with Docker Compose, defining the UI and APP services in a YAML manifest, including healthchecks to monitor the health of critical dependencies. For large-scale orchestration, Kubernetes was adopted, configuring a “Mixed-OS Cluster” with distinct “Node Pools”: Windows nodes for UI and APP, and Linux nodes for the DB. YAML manifests were created for Deployments, StatefulSets, and Services, ensuring the desired state, high availability, and network abstraction.

The cluster initialization was automated through an Infrastructure as Code (IaC) pipeline, using automation scripts. This process included downloading legacy artifacts (database backup and source code), building cross-platform images in Azure Container Registry (ACR) with the `–platform windows` directive, and sequencing the deployment. The deployment followed a hierarchical order, starting with the data layer (SQL Server), with pod health checks before proceeding to the application and interface layers.

The final stage of execution consisted of service provisioning and external network monitoring. The automation script ensured that the user interface service (system-ui-service) was exposed via a public LoadBalancer on Azure, and that the public IP address was assigned correctly. This flow ensured an integral transition from the development environment to the production environment, with state validation at all stages, minimizing manual interventions.

The data analysis consisted of operational verification and assessment of resource consumption of the containerized system. For local orchestration with Docker Compose, the `docker stats` command was used to monitor the CPU and memory utilization of the UI and APP containers. In the Kubernetes environment, the verification of the hybrid architecture and node status was performed with `kubectl get nodes`. The listing of created services and their entry points was checked with `kubectl get svc`.

The conformity with the “desired state” of the deployments, including the quantity of pods for the APP and UI layers, was confirmed with `kubectl get deployments` and `kubectl get pods`. For a detailed analysis of the resource consumption of each pod in the Kubernetes cluster, the command `kubectl top pod` was used. These procedures allowed the validation of the system’s functionality, resource allocation, and the resilience of the containerized solution, confirming the technical viability of the adopted strategy.

Ethical and security considerations were integrated into the containerization process, especially due to the handling of critical and sensitive data. Security best practices were applied, such as the “zero-trust” policy, limiting image size, executing containers with the least possible privilege, and implementing isolation techniques. The management of sensitive credentials, such as database users and passwords, was carried out through Secret objects in Kubernetes, decoupling this information from the source code and mitigating exposure risks.

A methodological limitation identified was the inability to serve clients operating the system on a single “on-premises” server with a database, due to the complexity of coexistence of Windows and Linux containers on the same unorchestrated host. Additionally, the “Lift and Shift” strategy implied not performing refactorings on the application, keeping it “as-is”. The definition of resource limits (CPU and RAM) in Kubernetes requires individual evaluation for each new installation, given the heterogeneity of client environments.

3. Results and Discussion

The analysis of the results obtained in the modernization and migration of the “System” system to a containerized infrastructure revealed crucial insights into the technical feasibility and practical implications of the adopted strategy. Initially, the containerization approach using only Docker, as planned for clients with more modest infrastructures, presented a significant limitation. The need for coexistence of Windows and Linux containers on the same un-orchestrated host imposed a technical bottleneck, making a fully containerized distribution strategy unfeasible for clients operating the system on a single “on-premises” server with a database. This finding corroborates the inherent complexity of migrating legacy systems with heterogeneous dependencies, especially when seeking a universal solution without deep source code refactoring, as was the case with the “Lift and Shift” strategy employed. The dependency on .NET Framework 4.8 on Windows Server for the application components (UI and APP) and Microsoft’s discontinuation of support for SQL Server Docker images on Windows forced the adoption of a Linux image for the database, creating an orchestration challenge in simplified environments.

Despite this initial limitation for single-server scenarios, the containerization of UI and APP components in Docker, pointing to a host-based SQL Server installation, demonstrated the ability to package the application autonomously. The verification of resource consumption of these containers, as presented in Figure 1, revealed remarkable efficiency.

Source: Original research results

Figure 1. Application container resource consumption

It was observed that the `system-ui-1` and `system-app-1` containers consumed 586.7MiB and 328.2MiB of memory, respectively, totaling less than 1GB of RAM. This result is particularly significant when compared to the resource consumption of traditional virtual machines. Damarapati (2025) highlights that deployments in VMs can occupy two to four times more memory than their containerized equivalents, in addition to exhibiting lower throughput and higher latency. The low RAM utilization observed in this study aligns directly with the advantages of operating-system-level containerization, which, by sharing the host kernel, reduces computational “overhead” compared to full virtualization (Melo et al., 2025). The practical implication of this finding is that, even in resource-constrained environments, containerizing application components can offer a substantially smaller memory footprint, freeing up resources for other operations or allowing more services to run on the same hardware, which translates into cost optimization and higher application density per server.

The transition to the Kubernetes (K8s) orchestration scenario represented the central point of the strategy to deal with the complexity and heterogeneity of the legacy system. The implementation of a “Mixed-OS Cluster” with distinct “Node Pools” – Linux nodes for the “Control Plane” and the SQL Server database, and Windows nodes for the application components (UI and APP) – was a technical success. The ability to observe this hybrid architecture in action, using the `kubectl get nodes` command, confirmed the correct allocation of nodes and readiness for workload execution.

Source: Original research results

Figure 2. Listing of nodes in the hybrid cluster

Figure 2 clearly illustrates the presence of two types of nodes: `aks-linux-37825697-vmss000000` and `akswin000000`, both with “Ready” status and compatible Kubernetes versions. This result validates the choice of the hybrid cluster alternative, which was the only technically sustainable solution among the evaluated options, especially considering Microsoft’s discontinuation of support for SQL Server in Windows containers. The use of `nodeSelector` in Kubernetes manifests was fundamental to directing workloads to the appropriate nodes, ensuring the compatibility of .NET Framework 4.8 with the Windows environment and the optimized execution of SQL Server on Linux. This approach not only resolved the technical challenge of operating system heterogeneity but also demonstrated Kubernetes’ flexibility in managing complex environments, a benefit widely discussed by Gajula (2025) regarding scalability and resilience. The practical implications are vast, allowing the software provider company to offer a robust and scalable solution for clients with diverse infrastructures, from more robust “on-premises” servers to cloud environments, with greater control over resource allocation and minimization of installation errors.

The desired state management of the application in the Kubernetes environment was confirmed by verifying the configured deployments. The `kubectl get deployments` command allowed validation that the system was configured to always maintain two instances (pods) of the APP layer and one instance of the UI layer.

Source: Original research results

Figure 3. Verification of configured deployments

Figure 3 shows that both `system-app` and `system-ui` had the desired number of replicas (“READY” and “UP-TO-DATE”), indicating that the Kubernetes “Control Plane” was operating as expected. This finding reinforces Kubernetes’ ability to ensure system high availability and resilience. In case of a pod failure, the orchestrator is responsible for automatically starting a new identical instance, a self-healing mechanism that is a pillar of cloud-native architecture. Literature, such as Jani (2021), emphasizes the importance of isolation and resilience mechanisms in containerized environments to mitigate the impact of failures. The implementation of `Liveness Probes` and `Readiness Probes` in the YAML manifests, as described in the methodology, ensures that pods are healthy and ready to receive traffic before being integrated into the service, minimizing disruptions and ensuring a consistent user experience. This functionality is crucial for mission-critical applications, such as “System”, which handles sensitive financial data, where operational continuity is imperative. The ability to declare the desired state and rely on the orchestrator to maintain it significantly reduces the manual workload of infrastructure management, allowing teams to focus on development and innovation.

Network abstraction and service discovery in Kubernetes were also positive outcomes of the implementation. Although Figure 2 (Service listing) was not included due to the figure limit and duplicate numbering in the original material, the methodology details that the `system-ui-service` was exposed via a public `LoadBalancer` on Azure, while the `sql-service` and `system-app-service` were configured as `ClusterIP`, keeping them restricted to the cluster’s internal network. This security approach, which prevents direct access to the application and database layers, is a pillar of the “zero-trust” policy mentioned by Jani (2021), which advocates for granting only the strictly necessary access between containers. The volatility of internal pod IP addresses, an inherent characteristic of containerized environments, is effectively managed by `Service` objects, which provide a stable and consistent access point. For the “System” system, which handles critical and sensitive data from financial institutions, network security is of paramount importance. The implementation of `Secrets` for managing sensitive credentials, such as database usernames and passwords, decoupling them from the source code and injecting them dynamically at container initialization, is a robust security practice that mitigates exposure risks and facilitates password rotation. This strategy is in full compliance with DevSecOps guidelines, ensuring that critical information does not travel in source code repositories.

The automation of the cluster startup process, through an Infrastructure as Code (IaC) pipeline using automation scripts, demonstrated repeatability and agility in infrastructure provisioning. The scripts `resources-deployment.sh` and `deploy.sh` (Appendix I) orchestrated the collection of legacy artifacts, the building of cross-platform images in the Azure Container Registry (ACR) with the `–platform windows` directive, and the deployment sequencing. The hierarchical deployment order, starting with the data layer (SQL Server) and proceeding to the application and interface layers only after health checks of the database pod, was crucial to ensure transactional integrity and system functionality. This sequencing, which includes a pod health check loop to monitor the success of the database restoration process, is an innovation that goes beyond the orchestrator’s native checks, ensuring that the internal business logic is ready for transactions before dependent layers are activated. State validation at all stages of the pipeline minimizes manual interventions and significantly reduces the probability of installation errors, one of the central objectives of the work, as Gajula (2025) points out the importance of CI/CD pipelines in fast and reliable delivery.

The “Lift and Shift” strategy, while allowing the migration of the application “as-is” without refactoring, brought with it the limitation of not being able to serve clients who operate the system on a single “on-premises” server with a database. This restriction is fundamental and must be clearly communicated to clients. The complexity of coexistence of Windows and Linux containers on the same un-orchestrated host, due to the native incompatibility of distinct kernels, makes the containerized installation less attractive for this client profile than the traditional model. This is a point of divergence from the initial expectation of universalizing distribution, but it points to the need for future refactoring of the source code for more current versions of .NET that can run on Linux, making the application “cross-platform”. Such modernization, as suggested in future perspectives, would allow the consolidation of the entire technological stack in Linux containers, drastically reducing resource consumption and expanding the customer base served.

Ethical and security considerations, integrated into the containerization process, were validated through the implementation of best practices. The “zero-trust” policy, limiting image size, running containers with the least privilege possible, and isolation techniques, as recommended by Jani (2021), were applied to protect critical and sensitive data. The management of sensitive credentials via `Secrets` in Kubernetes is a practical example of this approach, ensuring that confidential information is not exposed in the source code or easily accessible environment variables. This security layer is indispensable for a system used by financial institutions, where compliance and data protection are non-negotiable requirements.

In summary, the results demonstrate that the containerization of the “System” system is technically feasible and offers substantial benefits in terms of resource efficiency and resilience, especially in environments orchestrated with Kubernetes. The ability to create a hybrid cluster to accommodate legacy dependencies of .NET Framework 4.8 on Windows and SQL Server on Linux is a significant advancement. The automation of deployment and state management ensure deterministic behavior and high availability. Although the limitation for single-server scenarios persists, the foundations established by this study pave the way for future optimizations, such as refactoring for cross-platform .NET and the implementation of an internal reverse proxy, which promise to further expand the applicability and performance of the containerized solution. The resource density and operational flexibility achieved overcome the initial challenges, positioning the system for continuous evolution within the cloud-native paradigm.

4. Conclusion

It is concluded that the objective was achieved, demonstrating the technical feasibility of modernizing and migrating the “System” system to a containerized infrastructure, using Docker and Kubernetes. The strategy facilitated software distribution, reduced installation errors, and optimized scalability and resilience in heterogeneous environments. The implementation of a hybrid cluster, with Windows nodes for .NET Framework 4.8 and Linux nodes for Microsoft SQL Server, proved to be an effective solution. This allowed the application to be packaged autonomously, ensuring consistency and reproducibility. The containerization of application components resulted in remarkable efficiency in resource consumption, with the UI and APP containers using less than 1GB of RAM. Orchestration via Kubernetes ensured high availability, resilience, and automation of the software lifecycle, validating the ability to manage complexities and maintain the desired application state.

However, a crucial limitation was identified for clients operating the system on a single “on-premises” physical server with a database. The need for coexistence of Windows and Linux containers on the same un-orchestrated host imposed a configuration complexity that makes the containerized solution less attractive for this profile. As future studies, it is suggested to modernize the source code to more recent versions of .NET, such as .NET 10 or higher, aiming to make the application “cross-platform”. This would allow the consolidation of the entire technological stack in Linux containers, drastically reducing resource consumption and expanding applicability to single-server scenarios. Additionally, the implementation of an Internal Reverse Proxy (NGINX) at Layer 7 and the exploration of horizontal scaling of pods and nodes with tools like Karpenter are perspectives for further optimizing the system’s performance and resilience.

Bibliographic References

DAMARAPATI, A. 2025. Containers vs. Virtual machines: Understanding the shift to Kubernetes. Disponível em: https://journalwjaets.com/sites/default/files/fulltext_pdf/WJAETS-2025-0305.pdf. Acesso em: 01 nov. 2025.

GAJULA, S. 2025 A Decade of Cloud-Native Technologies:MultiCloud Strategies, Docker, and CI/CD Pipelines. Disponível em: https://www.researchgate.net/profile/Sreenivasulu-Gajula-2/publication/394361057_A_Decade_of_Cloud-Native_TechnologiesMulti-_Cloud_Strategies_Docker_and_CICD_Pipelines/links/6893fd3e37ccad613803c30d/A-Decade-of-Cloud-Native-TechnologiesMulti-Cloud-Strategies-Docker_and_CICD_Pipelines.pdf. Acesso em 15 abr. 2026

JANI, Y. 2021. Security Best Practices for Containerized Applications. Disponível em: https://www.researchgate.net/profile/Yash-Jani-6/publication/384444769_Security_Best_Practices_for_Containerized_Applications/links/66f99d05906bca2ac3d486ed/Security-Best-Practices-for-Containerized-Applications.pdf. Acesso em: 01 nov. 2025.

MELO, P.; SILVA, G.; VANDERLEI, A.; BESERRA, D.; ARAÚJO J. 2025. Performance Evaluation of Containerized Virtualization Platforms. Disponível em https://link.springer.com/article/10.1007/s42979-025-04297-3. Acesso em 15 abr. 2026

Article originating from the Final Course Work of the Specialization in Software Engineering of the MBA USP/Esalq

To learn more about the course, click here and access the MBX Academy platform

You may also like

November 17, 2026

Detection and Diagnosis of Diseases in Corn and Rice in Mozambique with Deep Learning

Mozambican agriculture depends on corn and rice, fundamental crops for food security, but their productivity is strongly affected by phytosanitary diseases, whose early and accurate identification remains a challenge in resource-limited contexts. The study aimed to develop and compare Deep Learning-based models for the automatic detection and diagnosis of diseases in corn and rice leaves in Mozambique. Three approaches were used: a classic Convolutional Neural Network (CNN) developed from scratch, and two transfer learning models, ResNet50 and MobileNetV2. The dataset consisted of images from public databases and collected in the field, which underwent cleaning, balancing, and artificial augmentation steps. The models were trained and evaluated with standard performance metrics, including accuracy, precision, recall, F1-score, Log Loss, and Cohen’s Kappa. The classic CNN presented the best overall performance, with 94% precision, recall, and F1-score, and 93% accuracy and Cohen’s Kappa. MobileNetV2 achieved 91% F1-score and 90% accuracy, standing out for its lower Log Loss (0.30) and training time (6h32min59s). ResNet50 reached 80% F1-score and 79% accuracy. It was concluded that Deep Learning techniques have high potential to support phytopathological diagnosis in real agricultural contexts, contributing to faster and more accurate decisions in the management of corn and rice diseases.

Keywords: Deep learning; Rice; Plant diseases; Corn; Computer vision.

November 17, 2026

Artificial intelligence in accounting operational routines and financial efficiency

The incorporation of Artificial Intelligence (AI) and automation tools has reconfigured the routines of Brazilian accounting offices, impacting productivity, error mitigation, and financial efficiency. These impacts were analyzed in a small accounting firm, specialized in serving service providers in the medical field in São Caetano do Sul, São Paulo. The research adopted a qualitative approach, with a single case study design and incorporated units of analysis. Data were collected through a structured questionnaire, applied via Google Forms between January and February 2026, to five professionals in the operational structure of the firm in a census survey. The treatment followed content analysis with a priori and emergent categories. All respondents declared the use of automated tools or tools with AI resources. The perception of reduced execution time, decreased operational errors, rework, and better use of the team’s time converged in 80% of affirmative responses and 20% partial responses. The most benefited activities were bank reconciliation, import of fiscal documents, and tax assessment, with visible gains on typing errors, duplicate entries, and incorrect classification. Human intervention remained indispensable in tax planning, scenario analysis, and verification of ancillary obligations. The overall evaluation of AI’s contribution was predominantly favorable, with moderation linked to the complexity of fiscal regulations.

Keywords: Content analysis; Process automation; Accounting 4.0; Small business; Digital transformation.

November 17, 2026

Factors influencing schedule management in sewage treatment plant “retrofit” projects

Projects involving “retrofit” in Sewage Treatment Plants (STP) are characterized by high complexity, operational restrictions, and multiple technical interfaces. The study analyzed the perception of the professionals involved regarding the management and adherence to deadlines in “retrofit” projects for sewage treatment plants, considering technical, operational, and organizational factors. The research was characterized as an applied study, with a quali-quantitative approach, designed as a field survey. Data analysis was performed using descriptive statistics and qualitative categorization, employing SWOT, risk matrix (Probability x Impact), and 5W2H action plan tools. The results indicated a high perception of clarity (77.8%) and realism of deadlines (100% agreement), evidencing consistent initial planning. However, 77.7% of respondents pointed out that rework and scope changes directly impacted deadline adherence. The integration between engineering, manufacturing, and Production Planning and Control (PPC) showed an intermediate evaluation (77.7% partial/total agreement), indicating fragility in interfunctional coordination. The risk matrix highlighted as critical: scope changes, operational limitations of the STP, and technical complexity, all with a high level. As a central improvement, the standardization of scope change control, analysis, and approval was proposed, aiming to reduce rework and increase schedule predictability.

Keywords: Performance; Integration; Planning; Rework; Risk.

November 17, 2026

B2C Acquisition in diagnostic medicine: strategic partnerships with specialized medical offices

The diagnostic medicine sector in Brazil operates with high dependence on health plan providers, which limits the financial autonomy of service providers. This study proposed and analyzed a direct patient acquisition model (B2C) for a highly complex diagnostic medicine institution, structured through partnerships with Oncology and Cardiology practices and operationalized by a personalized customer service called concierge. The investigation adopted a mixed-methods approach in three phases: a field survey with a structured questionnaire applied to 87 patients, mapping of the operational flow using “Service Blueprint”, and analysis of the conversion rate from 312 medical referrals registered in the pilot project. The results indicated that trust in medical referral achieved 92.0% agreement, establishing itself as the main factor for adherence. The convenience of performing the exam on the same day reached 78.2%, and the willingness to pay directly was 55.2%, with polarization associated with the predominance of health plan users. The “Service Blueprint” identified three critical points in the transitions between stages of the patient journey. The overall conversion rate was 51.0%, with superior performance in Oncology (58.2%) compared to Cardiology (45.0%), and the greatest loss was concentrated in the acceptance and scheduling stage (28.3%). It was concluded that the model demonstrated possible operational viability and indications of patient acceptance, conditioned by price transparency and a reduction in the interval between consultation and approach by the concierge.

Keywords: Direct payment; Patient journey; Supplementary health; Concierge service; Conversion rate.

November 17, 2026

The role of the school manager in promoting an inclusive culture: leadership and educational policies

The research analyzed the school manager’s performance in promoting an inclusive culture, considering the need to transform legal guidelines and pedagogical foundations into effective institutional practices. It was assumed that school inclusion requires planning, organization, and strategic leadership in the school’s daily operations. A qualitative approach of an applied nature was adopted, developed in three complementary stages: documentary analysis of Brazilian legislation on inclusive education, bibliographic review on school leadership and management, and data systematization using management tools such as SWOT analysis and the PDCA cycle. The results indicated that the school management’s performance directly influenced the consolidation of inclusive environments, especially in the organization of processes, continuous team training, and strengthening of a collaborative institutional culture respectful of diversity. Structural, pedagogical, and relational challenges that demanded planned interventions were also identified. Finally, a Practical Guide for School Managers was developed, with guidelines, protocols, and operational orientations for decision-making and the organization of inclusive processes. It was concluded that the construction of an inclusive culture depended on the management’s ability to articulate public policies, pedagogical practices, and institutional processes, consolidating inclusion as a permanent commitment in the school context.

Keywords: educational accessibility; educational equity; participatory management; strategic planning; institutional processes.

November 17, 2026

An AI artifact based on Design Thinking to support the elicitation of software requirements from user needs

The development of software oriented to user needs frequently faces challenges in requirements elicitation, stemming from ambiguities in natural language and communication failures. Given this, an intelligent artifact integrating Design Thinking and Artificial Intelligence was proposed and validated, focusing on the Empathy and Definition stages, to support the collection, interpretation, and structuring of user needs. The research, of an applied, qualitative, and exploratory nature, conducted a Proof of Concept in a controlled environment, employing hypothetical scenarios. The artifact operated through guided natural language interviews, organizing information into elements such as pain points, context, and impact, and generating traceable problem syntheses. The results indicated that the system organized unstructured reports, reduced ambiguities, and preserved the meaning of the original information in most cases. The ability to reorganize logically in complex scenarios was also observed, although with limitations in separating multiple problems and dependence on instructions. It was concluded that the artifact has potential as a support for requirements elicitation, improving the clarity and structuring of information, but requires supervision and contextual control.

Keywords: Design Thinking; Requirements Elicitation; Requirements Engineering; Artificial Intelligence; Natural Language Processing.

November 17, 2026

The Extinction of the Monophasic Tax System in the Pharmaceutical Industry in Light of the Tax Reform

The consumption Tax Reform, established by Constitutional Amendment No. 132/2023, introduced structural changes to the Brazilian tax system, with the replacement of the Social Integration Program (PIS) and the Social Security Financing Contribution (COFINS) by the Contribution on Goods and Services (CBS), in a dual Value Added Tax (VAT) model. The objective was to analyze the impacts of the extinction of the single-stage system on the pharmaceutical industry, in light of the new regulatory design and its economic and legal effects. A qualitative, exploratory research was conducted through a case study and documentary analysis of legislation and specialized doctrine. It was examined whether the end of the single-stage system would imply a relevant increase in the tax burden for the sector. The results indicated that, although the formal overcoming of the single-stage system has occurred, the material exemption of medicines has been preserved, mainly due to the application of reduced rates of 60% and, in certain cases, a zero rate of the Tax on Goods and Services (IBS) and CBS. The change in model may cause occasional variations in revenue collection, without characterizing a structural increase in the tax burden, tending towards neutrality over time. It was preliminarily concluded that the Tax Reform reorganized the taxation technique in the pharmaceutical industry, replacing a concentrated regime with more transparent exemption mechanisms. This approach proved compatible with the principles of neutrality, full non-cumulativeness, and fiscality, maintaining tax protection for essential medicines and aligning fiscal policy with the fundamental right to health.

Keywords: CBS; COFINS; IBS; Dual VAT; PIS.