This study focuses on improving the performance and scalability of web applications by leveraging modern architectural solutions and optimization techniques. The research explores key aspects such as the Model-View-Controller (MVC) pattern, process clustering, and database performance under high loads. The researchers conducted experimental tests to evaluate system efficiency and analyzed load -balancing algorithms to improve scalability. The study resulted in developing a web application that supports MVC, clustering, and Cross-Origin Resource Sharing (CORS), demonstrating its practical applicability in educational platforms, e-commerce, and CRM systems. The implemented solution performed efficiently under high-load conditions, significantly improving response times and handling multiple simultaneous requests. The findings emphasize the importance of modern optimization techniques in ensuring high performance, improving user experience, and increasing conversion rates.
1. Introduction
One key indicator of a website's performance is its loading speed, which depends on various factors.
In this study, the authors hypothesize that using modern technologies—such as Node.js [
To test the hypothesis, the authors will use research methods including field observation, testing, and case studies. First, we will conduct experimental testing of the web application with different technology stacks and architectural solutions. The authors will compare the test results to determine whether they confirm the hypothesis and to assess improvements in response time and request processing. The study will record specific data, such as response time in milliseconds and the number of simultaneous requests, for performance analysis.
In order to store static website resources closer to users and cut down on page load times by doing
away with the need to send requests to a central server, a content delivery network (CDN) is a
globally distributed network of servers. A CDN's distributed architecture offers several advantages,
including faster content delivery, reduced server load, and better protection against
denial-ofservice (DDoS) attacks. Optimizing images is one of the easiest and most efficient methods for
making web pages smaller. File sizes can be decreased without sacrificing quality with the use of
programs like TinyPNG [
Web development trends of the present day include:
The rise of single-page applications (SPAs);
Frameworks such as React, Angular, and Vue.js enable the creation of dynamic single-page
applications that offer a more engaging user experience. For commercial projects that require
fast performance and visibility, Server-Side Rendering (SSR) is especially useful as it boosts page
load speed and enhances search engine optimization (SEO). Microservice architecture enhances
scalability and flexibility by allowing the independent development of application components
[
To demonstrate how productivity issues can arise, it is necessary to first illustrate these challenges before proposing methods to increase productivity (Figure 1).
due to clustering (using application the Node.js cluster architecture. module) and cloud solutions (such as MongoDB Atlas).
Performance is high Not applicable Not applicable Not applicable due to asynchronous (client-side (client-side (client-side request processing and framework). framework). framework).
MongoDB, which enables fast data operations.
Supported via Server- SSR is supported SSR is supported SSR is supported Side Rendering (SSR) via Next.js. via Angular via Nuxt.js. using libraries (e.g., Universal.
Next.js).
Efficiency is high due to It depends on It depends on It depends on clustering and PM2 for the server-side the server-side the server-side process management. architecture. architecture. architecture.
High due to modular High due to Moderate due to High due to architecture and component- full-fledged lightweight support for various based framework architecture. databases (MongoDB, architecture. structure.
PostgreSQL).
Performance is high It requires It requires It requires due to WebSockets and additional additional additional asynchronous event libraries, such as libraries, such as libraries, such as handling. Socket.IO. Socket.IO. Socket.IO.
It offers easy It allows easy It allows easy It allows easy integration with integration with integration with integration with Express.js, MongoDB, any server-side any server-side any server-side PM2, and other server- stack. stack. stack.
side tools.
Typically, this request is completed in less than 20 milliseconds [
The delay function simulates the worst possible blocking behavior by halting the event loop for
several seconds. In real-world applications, response times should typically stay below 100 or 200
milliseconds. Research has examined how users perceive response times in web and application
contexts. As early as 1968, researchers established that users perceive a response as instantaneous
only if it occurs within 100 milliseconds [
3.1. Running multiple Node processes
In Node.js, multiple Node processes can run simultaneously, allowing them to share workloads in a
way similar to a team working together toward a common goal. When operating servers, the system
divides workloads into requests sent to the server. Rather than processing all incoming requests on
a single Node process, the system can distribute the requests across multiple Node processes, each
handling server procedures independently. These processes execute the same server code in
parallel, functioning side by side. For example, a second Node process may handle the second
request, while a third Node process handles a third request. Furthermore, each process is capable
can manage multiple requests simultaneously, even if the number of incoming requests exceeds the
number of server processes. The critical advantage of this approach is the even distribution of
workloads among the processes [
3.2. Node cluster module
The initial approach to improving node performance involves using the built-in node cluster
module [
This configuration contains three nodes, as the worker function runs twice. These include the master process (started by the running server). The fork function and JavaScript created two worker processes. These workers handle incoming requests in a round-robin fashion: the first worker receives the first request, the second worker receives the second, and so on. One of the simplest and most equitable ways to divide the workload among employees is still the round-robin method, even though request processing times can differ. Nevertheless, on Windows, because of how the operating system handles processes, Node. JS leaves task distribution up to the system and does not ensure a rigorous round-robin method. Nevertheless, Windows still supports round-robin for load distribution.
3.3. Clustering in action
Node.js, by default, runs on a single thread, which limits its ability to fully utilize multi-core processors. This can lead to utilize multi-core processors fully: Inefficient CPU Utilization: Only one CPU core is active, leaving the others idle; Bottlenecks in High-Load Scenarios. Long-running tasks can block the event loop, delaying the processing of other requests; Limited Scalability. A single process cannot handle a large number of simultaneous requests efficiently.
To address these issues, the Node.js cluster module creates multiple worker processes, allowing the application to: Distribute incoming requests across multiple CPU cores; Improve response times by parallelizing request processing; Scale horizontally by adding more worker processes as needed.
The built-in cluster module was imported and assigned to a constant; A primary process was created to manage worker processes [15].
Forking Worker Processes: The cluster.fork() method creates worker processes; Each worker process runs the same server code (server.js) and listens on the same port (e.g., port 3000).
Load Distribution: Incoming HTTP requests were distributed among worker processes using a round-robin approach; The master process coordinated the creation and management of worker processes [16–17].
The application's response time under high load decreased from 6.5 seconds to 4 seconds; The application could handle eight simultaneous requests without performance degradation; The system utilized all available CPU cores, maximizing server performance.
Figure 5 illustrates the initialization of clustering and the creation of worker processes.
When testing server clustering, it is necessary to turn off the cache to ensure that Chrome executes requests without relying on cached data. The cache should be turned off in both tabs to achieve accurate results. Two requests are made in one tab to the timer endpoint, followed by a quick refresh of both the first and second tabs.
As shown in Figure 6, the first tab indicates that the connection is waiting. After nine seconds, the system returns a successful 200 response. Simultaneously, the second tab also receives the response, with both requests taking nine seconds to complete [18]. These requests ran in parallel on the computer, thanks to the presence of two processor cores, which allowed the processing to occur in two separate processes.
In Figure 7, the system sends a request to the timer endpoint in one tab and to the root directory in another. The request to the root directory returned almost immediately, within 27 milliseconds. This demonstrates that the route and endpoint are not required to wait for the timer to complete execution in the first tab. This behavior matches the intended functionality exactly. 3.4. Maximizing cluster performance
While clustering improves performance, it has limitations: The system limits the number of worker processes to the number of CPU cores; Long-running tasks can still block worker processes, reducing overall efficiency.
Dynamic Worker Creation: The number of worker processes was dynamically set based on the number of logical CPU cores available; This approach ensured efficient utilization of each CPU core.
Requests were distributed evenly among worker processes using a round-robin strategy.
We used the PM2 [19] tool to monitor and manage worker processes, ensuring high availability and automatic restarts in case of failures.
The number of worker processes was equal to the number of logical cores (e.g., eight workers for eight logical cores).
Handling High-Load Scenarios: Multiple requests were simulated to test the cluster's performance; The browser cache was turned off to ensure accurate measurement of response times. Testing Parallel Processing: We sent requests to the /timer endpoint simultaneously across multiple browser tabs; Response times were measured to evaluate the cluster's ability to handle parallel requests.
The cluster successfully processed eight simultaneous requests in 9 seconds, demonstrating efficient utilization of all CPU cores. Requests to the /timer endpoint returned consistent response times, even under high load. When the number of requests exceeded the number of worker processes, response times increased (e.g., from 9 seconds to 16 seconds for the fourth request).
Each section begins with a concise definition of the problem it addresses. Quantitative metrics (e.g., response times, CPU utilization) highlight the issue. Structured Solution Proposal: The authors describe the proposed solution in a logically and technically manner. The authors clearly outline the implementation steps.
Measurable Results: The authors provide quantitative results (e.g., response times, number of simultaneous requests) to demonstrate the solution's effectiveness of the solution. The authors discuss the implications of the results.
Visual Aids: The discussion references figures (e.g., Figure 5, Figure 9) to support key points. Adding diagrams or tables could enhance the presentation of the results.
Metric ClBuesfteorrieng CluAsftteerring Improvement Response Time (High Load) 6.5 seconds 4 seconds 47.8% reduction Simultaneous Requests 2 8 4x increase
CPU Utilization 25% (1 core) 100% (4 cores) 4x improvement 3.5. Load balancing Round robin is one of the strategies used for load-balancing, a critical topic in backend development. Load-balancing refers to the distribution of tasks across a set of resources, such as dividing incoming requests among different processes. In cases where a server operates with a cluster of worker processes, a load balancer determines how to distribute requests among these processes. Figure 10 demonstrates that a load balancer receives requests from users and distributes them in a manner that evenly allocates the responsibility for handling those requests across multiple processes or potentially different applications or servers [21]. For instance, two servers running on separate machines, each hosting a set of processes capable of handling requests, can be an example of load-balancing. Requests are balanced across multiple servers and among the processes within those servers. Load-balancing is particularly effective when multiple servers or processes operate in parallel, each handling the same type of request.
As shown in the example, load-balancing is often discussed in the context of horizontal scaling. Horizontal scaling involves increasing an application's capacity by adding more servers or processes, while vertical scaling enhances a single-node process (e.g., upgrading the CPU for higher speed). Horizontal scaling does not require a server to be exceptionally fast or large; instead, it focuses on increasing the system's ability to handle more requests by adding additional servers or node processes, such as in a cluster [22].
Horizontal scaling and load-balancing are fundamental strategies for distributing requests in such systems. In scenarios where no prior information exists about the execution time of requests– common when handling diverse types of requests with varying execution times–two primary approaches to load-balancing are employed. One is the round-robin method, which randomly assigns incoming requests to available processes [23].
This approach, based on simple algorithms to determine which process handles a request, proves effective when precise information about execution time is unavailable.
To summarize, the cluster module in Node.js enables load-balancing for requests directed to Node's file transfer protocol (FTP) servers. This module uses a round-robin strategy to determine which process will handle incoming requests. To summarize, in Node.js, we can use the cluster module to load balance requests to our Node.js file transfer protocol (FTP) servers.
The chosen technology stack, which includes Node.js, MongoDB, and a clustering method, achieved an impressive 20 milliseconds of web application loading speed. Testing of multi-threaded site loading showed that simultaneous loading of two sites takes only 9 seconds, which is a significant improvement compared to the 55% additional time required for sequential loading. The clustering method allows for efficient use of users' device computing power, eliminating the need to rent servers for campaigns.
During the preparation of this work, the authors used Grammarly in order to: Grammar and spelling check. After using this tool, the authors reviewed and edited the content as needed and take full responsibility for the publication’s content. [15] Why Node.js clustering is key for optimized applications, 2024. URL: https://kinsta.com/blog/node-js-clustering/. [16] Clustering, 2024. URL: https://betterstack.com/community/guides/scaling-nodejs/nodeclustering/. [17] Node.js Cluster Process Module, 2017. URL: https://www.w3schools.com/nodejs/ref_cluster.asp [18] S. Buna, Efficient Node.js: A Beyond-the-Basics Guide, O'Reilly Media; 1st edition, 2025 [19] PM2 Tool, 2024 [Electronic resource] – Access mode: https://pm2.keymetrics.io/docs/usage/quick-start/. [20] Node.js cluster Module: Node.js Clustering for Horizontal Scaling, 2024. URL: https://devcrud.com/node-js-cluster-module-node-js-clustering-for-horizontal-scaling/. [21] Load balancing (computing), 2024. URL: https://www.geeksforgeeks.org/load-balancingalgorithms/. [22] G. Chrsterfield, Node.js for Backend Development: Learn to Build High-Performance, Scalable
Web Applications, Kindle Edition, 2024. [23] Maximize Node.js Performance with Load Balancing and Clustering Techniques, 2024. URL: https://codezup.com/node-js-load-balancing-clustering/.