## 1 Introduction  
In recent years, serverless computing has emerged as a revolutionary technology that abstracts the infrastructure layer, enabling developers and organizations to focus solely on deploying software without the burden of configuring, managing, or allocating the necessary resources to run it [1]. Unlike traditional cloud models, serverless computing shifts the responsibilities of scheduling, scaling, resource provisioning, and infrastructure maintenance entirely to the service provider. Some of the most widely used serverless platforms include Amazon Web Services (AWS, Seattle, WA, USA), Google Cloud Platform (Mountain View, CA, USA), and Microsoft Azure (Redmond, WA, USA). Function as a Service (FaaS) forms the backbone of serverless computing. In this model, functions are hosted and executed only when invoked. These event-driven functions run in stateless containers and are triggered by various events such as HTTP requests, database updates (e.g., DynamoDB streams), file uploads (e.g., S3), or messages from queues (e.g., Kafka, SQS) [2]. In a serverless environment, customers are charged only when a function is executed, meaning the cost is based on actual execution time rather than total uptime, as in traditional cloud platforms. This model not only reduces costs for clients but also enables providers to manage resources more efficiently. Despite its advantages, FaaS introduces unique challenges that developers and organizations must address to fully realize its potential [3; 4]. The key challenges include:  
* **Cold Starts**: When a function is invoked, the provider attempts to find an available container to host it. If no \"warm\" container is available, a new container must be initialized. This initialization process requires a non-negligible amount of time, sometimes up to several seconds [5]. Such latency is significant compared to the typical execution time of serverless functions, which are short-lived and usually complete in just a few milliseconds. Cold starts are, therefore, a major challenge for FaaS providers and represent a key concern addressed by this research [6]. * **Utilization**: Effective resource management is critical in FaaS environments. Due to the unique architecture and execution model of serverless functions [7], utilization remains a challenge that has not been sufficiently studied. One factor that negatively impacts resource utilization is the frequent occurrence of cold starts; repeated container initializations consume resources inefficiently, despite the brief execution time of functions. Another important factor is the scaling decision (both scaling in and scaling out), which is entirely handled by the provider. During traffic spikes, spawning many containers can result in over-provisioning after the peak subsides. Conversely, insufficient container allocation leads to under-provisioning, which causes performance degradation. * **SLA (Service Level Agreement)**: An SLA is a set of predefined metrics--such as response time, availability, reliability, and error rate--that the provider must meet to avoid penalties. However, FaaS environments introduce new obstacles that can increase SLA violations, adversely affecting both customers and providers [8]. The most common causes of these violations include high cold start frequency, delayed autoscaling, and inadequate resource provisioning. Cold starts are a significant contributor to performance degradation in serverless environments. Minimizing cold starts leads directly to more efficient resource management on the provider side and reduces SLA violations on the user side. To achieve this, providers must implement appropriate scheduling strategies and efficient autoscaling mechanisms. Conventional scheduling algorithms, originally designed for traditional virtual machine (VM)-based cloud platforms, are not suitable for serverless environments.