The American Journal of Engineering and Technology
17
https://www.theamericanjournals.com/index.php/tajet
TYPE
Original Research
PAGE NO.
17-41
10.37547/tajet/Volume05Issue05-09A
OPEN ACCESS
SUBMITED
23 February 2023
ACCEPTED
25 March 2023
PUBLISHED
25 May 2023
VOLUME
Vol.05 Issue 05 2023
CITATION
Nishanth Reddy Pinnapareddy. (2023). Serverless Computing & Function-
as-a-Service (FaaS) Optimization. The American Journal of Engineering and
Technology, 5(05), 17
–
41.
https://doi.org/10.37547/tajet/Volume05Issue05-09A
COPYRIGHT
© 2023 Original content from this work may be used under the terms
of the creative commons attributes 4.0 License.
Serverless Computing &
Function-as-a-Service
(FaaS) Optimization
Nishanth Reddy Pinnapareddy
Senior Software Engineer California USA
Abstract:
Function-as-a-Service (FaaS) in cloud
computing is a critical optimization problem that needs
to be tackled, including cold start latency, resource
inefficiency, state management, and more. While FaaS
provides obvious scalability and lower cost benefits, the
lack of availability of resources and the problem of cold
starts to prevent it from being used for high-
performance applications. Pre-warming, snapshotting,
and on-demand instantiation with lightweight runtimes,
such as WebAssembly, are other ways to minimize cold
start delays. It also benchmarks major FaaS platforms
(AWS Lambda, Google Cloud Functions, Azure
Functions, and OpenFaaS) and measures latency,
throughput, and scalability metrics. The study also
considers how to manage the resource, for instance,
using auto-scaling, memory allocation, and request
batching to enhance cost efficiency and performance.
The study covers security challenges in multi-tenant
environments and solutions for stateful applications in
usually stateless serverless architectures with Faast.js,
Knative, and OpenWhisk. Another area of research is
edge computing and architectures for multiple clouds to
improve the deployment of FaaS. Incorporating the
lessons from this study gives it enough flexibility to
adjust functions as applications in a real-world
enterprise environment, especially in high-performance
and data-sensitive applications. The study also provides
security practices like function isolation and encryption
to secure data in multi-tenancy environments for
reliable, secure, and efficient serverless computing. The
contribution to FaaS optimization and security for
various use cases is achieved.
Keywords:
FaaS, cold start optimization, performance
benchmarking, serverless security, stateful serverless,
multi-cloud architecture.
Introduction:
Serverless computing is the cloud model
The American Journal of Engineering and Technology
18
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
that removes infrastructure management from the
server and allows the developers to focus on llo of code
writing and application development. Responsible for
provisioning
and
scaling
the
resource
and
infrastructure management, the cloud provides
greater flexibility, efficiency, and cost efficiency for
applications
with
unpredictable
demand.
Organizations pay only for the actual compute time
through the pay-per-use model, eliminating the
requirement for over-provisioned infrastructure and
ingested resources. Serverless architectures also make
it possible to scale straight automatically; they have
high availability and failover by spreading functions
across multiple availability zones. Function as a Service
(FaaS) is a big piece of serverless computing and
enables running small event-driven functions without
the management of the infrastructure. They are
triggered on API calls, database changes, or file
uploads. AWS Lambda, Google Cloud Functions, and
Azure Functions dominate the FaaS market and offer
different integrations and capabilities. FaaS allows the
development of cloud-native applications using
modular, scalable microservice architecture, reducing
development cycles and improving agility. FaaS also
supports the event-driven workflow, which fits well
with the Internet of Things (IoT), data processing, and
API-based applications, and there is a cost reduction
since the pricing is paid based on usage.
The use of FaaS in high-performance and enterprise
environments is hindered by several challenges. Cold
starts are one of the biggest problems, as functions
experience delays when invoked for the first time or
after being idle. These latencies can be detrimental to
real-time applications and are often referred to as
problem latencies. Dynamic resource allocation can
lead
to
resource
inefficiency,
resulting
in
overprovisioning or underutilization and, therefore,
inefficiencies and higher costs. Also, they are exposed
to certain security risks in a multi-tenant environment,
which may manifest as data leakage and unauthorized
access, if the isolation between functions is
insufficient. Although there are these challenges, FaaS
continues to appeal to applications that can accept
inherent trade-offs and benefit from scalability and
flexibility. The first research objective is investigating
optimization
techniques
to
improve
FaaS’s
performance in enterprise environments. Cold start
optimization
techniques
like
pre-warming,
snapshotting,
and
lightweight
runtimes
like
WebAssembly are key areas. In the second part,
performance benchmarking compares the efficiency
and scalability of one of the major FaaS platforms: AWS
Lambda, Google Cloud Functions, and Azure Functions.
The impact of resource management strategies like
auto-scaling, memory allocation, and request batching
on cost efficiency and performance will be examined.
Approaches to solving stateful applications in a stateless
FaaS environment using frameworks such as Faast.js,
Knative, and OpenWhisk for state persistence will also
be explored.
Identifying best practices to secure applications is
necessary to address security challenges in FaaS,
particularly for multi-tenant architectures. However,
the research will also examine the feasibility of lowering
latency through the use of edge computing to execute
FaaS functions near end users, as well as the benefits
and challenges of multi-cloud architectures for cross-
cloud
FaaS
deployments.
Finally, optimization
techniques for runtime performance optimization and
lowering overhead will be investigated.
2. Cold Start Optimization
2.1 Understanding Cold Starts in FaaS
Cold starts are invoked whenever a function is triggered
for the first time or following an idle period, causing
latency due to the time required for initializing the
function in FaaS environments (Manner et al., 2018).
Unlike traditional server-based applications, FaaS
platforms dynamically schedule resources for each
function's execution. The cloud provider must provision
or provision the compute resources, load the function
code, and set up the runtime environment when a
function is first invoked or when it has been idle. The
cold start occurs because when a function is initialized,
it takes this delay. The cold starts of FaaS applications
can greatly impact performance, especially in time
budget-sensitive use cases like real-time data
processing, gaming, financial applications, and
interactive web services (Abid, 2022). Cold starts can
introduce latency into a serverless application, and
under certain circumstances, this can outweigh the
benefits of a serverless system for latency-critical tasks.
Since serverless functions are meant to scale up and
down to meet demand, cold starts become more
pronounced when functions are in use but on a stopping
and starting basis, for example, when a function has
cyclical usage patterns and is dormant during low traffic.
There are several causes of cold, starting in the technical
area.
•
Large provisioning and initialization delays: For
example, a function that hasn't been invoked for a while
has to provision compute resources like containers or
VMs. Doing this will cause additional overhead, thus
further delaying.
The American Journal of Engineering and Technology
19
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
•
The serverless platform allocates container(s)
or micro VM(s) to run functions. However, suppose
these resources are not already active. In that case,
they should be created and initialized, which could
take time, especially for functions dependent on other
large functions or that have complex initialization
processes.
•
Though, in some cases, the impact of cold starts
on performance can be mitigated, cold starts are one of
the main
challenges of serverless computing for real-time
applications.
Figure 1: Cold start latency mitigation mechanisms in serverless computing
2.2 Pre-warming Strategies for Reducing Cold Start
Latency
A common strategy for reducing cold start latency in
serverless computing is pre-warming, where a function
is sometimes invoked even without real requests to
keep it ‘warm (Bannon, 2022).’ By ensuring that the
function is always up and running and that it must
continue to allocate the cloud provider’s resources, the
time required to execute a function goes down when
there is actually a request coming in; generally
speaking, the pre-warming approaches include periodic
function running with a fixed interval; pre-activation,
where the functions are pre-loaded and ready to serve
a request at minimum delay.
Pre-warming has benefits, such as faster starting and
better user experience for real-time or interactive
applications, but also disadvantages. Resource
consumption is the most important drawback.
However, it eliminates cold start latency, but it means
the cloud resources during idle periods have to be
maintained to be active, increasing operational costs.
Pre-warming when the application has no traffic may
lead to unnecessary expenses, with the cloud providers
charging based on execution duration and resource
usage. Consequently, while pre-warming improves the
latency of the workloads, the impact of cost efficiency
also has to be considered, especially for workloads with
unpredictable usage patterns (Roy et al., 2022).
Table 1: Cold Start Optimization Techniques and Trade-offs
Technique
Benefits
Drawbacks
Pre-warming
Reduces cold start latency, ensures
smooth user experience
Increased resource consumption, higher
operational costs
Snapshotting
Saves function state, avoids re-
initialization
Implementation complexity, snapshot
consistency management
The American Journal of Engineering and Technology
20
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
Technique
Benefits
Drawbacks
WebAssembly
Fast execution, portability across
platforms
Not suitable for complex functions with
large dependencies
2.3 Snapshotting Techniques for Faster Function
Initialization
Snapshotting is a technique to improve the
performance of the cold start by saving the state of
function after the first execution (Silva et al., 2020).
When the function is called, the cloud provides and
takes a snapshot of the runtime environment, including
the function's code, variables,s, and dependencies. The
function saves this snapshot and can return quickly
back to this snapshot upon the next invocation; there is
no need to re-initialize it! Snapshotting differs from
traditional warm start techniques, which are complex
and require that an instance of the function be running
continuously but use resources more efficiently by
saving the execution state and allowing the function to
be restarted immediately if called again.
Snapshotting provides the appeal that the function's
state is preserved across invocations compared to
traditional warm-start methods (Li et al., 2022). That is,
it cuts away the need to load and initialize resources
and dependencies upon every request, which would
lead to cold start latency. In other words, warm starting
means that the function instance is actively running and
will consume resources even when not processing
requests. This approach can become inefficient,
particularly in cases of low traffic. Nevertheless,
snapshotting is itself a challenge. When scaling up,
snapshot management across all instances of the
function, including managing consistency, can be
challenging. Finally, snapshots must be updated when
any change happens in the function's code or
dependencies, which increases the overhead of
maintaining such a system. However, despite all these
challenges, snapshotting continues to be a very useful
tool in alleviating cold start latency and improving
resource utilization in serverless environments
.
Figure 2: A survey on the cold start latency approaches in serverless computing
2.4 WebAssembly-based Lightweight Runtimes
WebAssembly (Wasm) is an isolated runtime
environment designed to run code anywhere quickly,
allowing the porting of already written code across
platforms (Hoffman, 2019). The chief advantage is its
capacity to drastically cut cold start latency, enabling
serverless functions to run with minimal initialization.
WebAssembly is a binary instruction set, meaning it can
get instructions interpreted very fast, almost at instant
speed, without going through the overhead often
associated
with
traditional
programming
environments. As WebAssembly is portable, its code
can run across platforms: on browsers, edge devices,
and serverless environments, making it perfect for
multi-cloud and edge computing scenarios. As the
WebAssembly modules are precompiled ahead of time
and run inside a standardized environment, the cold
start times are almost minimized.
Although WebAssembly is nice, it is not suitable for all
use cases. It is great for dealing with simple, small, and
The American Journal of Engineering and Technology
21
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
lightweight functions (Hilbig et al., 2021). Still, it may
fail to have the broader functionality required in
complex applications heavily based on libraries and
custom
runtime
environments.
Managing
dependencies can also be tough. WebAssembly is
designed to run simpler, self-contained code and may
not be fully compatible with functions that rely on huge
libraries or complex dependencies. On the other hand,
pre-warming and snapshotting are cold start
optimization techniques that provide different
tradeoffs tradeoffs. It helps increase resource
consumption and operational costs. Yet, pre-warming
can further put the device into cold start latency
depending on the degree of activation and the
application's traffic patterns. Snapshotting is faster
than response as it preserves the function state after
the first execution; however, snapshotting has intrinsic
complexity of state consistency management and
preparation of snapshot updates.
WebAssembly is fast and portable for smaller, simpler
functions, but the workloads need a huge set of
dependencies and are not suited for those. Pushing
warmer servers into line and snapshotting code can
reduce cold start latency by as much as 70%, faster than
WebAssembly runtimes, which can initialize instantly.
However, only the actual performance improvements
vary with function complexity and resource
requirements. As a result, developers should
thoroughly assess these tradeoffs and choose the most
appropriate optimization solution according to the
application needs and the traffic pattern, as well as the
availability of resources in the serverless environment.
3. Performance Benchmarking of FaaS Platforms.
3.1 Overview of Popular FaaS Providers: AWS Lambda,
Google Cloud Functions, Azure Functions, OpenFaaS
One of the most widely adopted Function-as-a-service
(FaaS) platforms, AWS Lambda offers a very flexible and
scalable environment to run some code without
needing to provision or manage servers. Lambda is a
fully integrated service with other AWS services like API
Gateway, DynamoDB, S3, and more to build cloud
applications. It makes sense to be able to automatically
scale up to mark hundreds of millions of requests per
day in the face of a variety of use cases, from real-time
data processing to web application backends. It is a
multi-lingual platform supporting Node.js, Python, Java
and Go at the same time so that developers in various
ecosystems can make use of this. This adds up to
thousands of ns for API gateway function time and can
be a hindrance to real-time applications since function
calls are very low, or needs cold start latency.
Google Cloud Functions uses event-driven architecture
best, especially for applications requiring real-time
processing of data from events. Being Google Cloud
services ready, it can be a very strong choice for the
sake of serverless applications in the Google Cloud
ecosystem. Low latency tasks particularly in real-time
event-driven applications such as IoT and stream
processing are what Google Cloud Functions is
intended for. Based on demand, It scales automatically,
giving peak performance at any given load level. It
supports multiple languages such as JavaScript, Python,
Go, etc. High cold start time is a well-known ability of
Google Cloud Functions, but it is less feature-rich when
compared to AWS Lambda, particularly in more
complex multi-service application environments
(George et al., 2020).
For an enterprise already using some of the Azure
services, Azure Functions is incredibly well integrated
into the Microsoft Azure ecosystem. Azure Functions
natively supports HTTP Triggers, Timer Triggers, and
Service Bus Trigger. It can be used to run either short-
lived or long-lived functions, possessing rich support for
durable functions that deal with elaborate workflows
with multiple steps. In addition, Azure Functions
enables users to manage and scale resources more
finely if controlled workloads are predictable. Its
capabilities also support languages such as C#,
JavaScript and Python to make further it attractive
among enterprise users. In contrast, if there are
additional concerns with cold start times for Azure
Functions, one reason they may not meet certain
requirements is that they are higher than those of
Google Cloud Functions for ultra-low latency use cases
(Palumbo et al., 2021). It is an open-source serverless
framework for Kubernetes-based deployments that is
known as OpenFaaS. It enables organizations to run
serverless functions in cloud platforms besides their on-
premises infrastructure. The thing I like most about
OpenFaaS is that it offers great flexibility for developers
to deploy the function in a self-managed environment
which is beneficial for organizations that want to get
more control on the serverless infrastructure. It is well
integrated with Kubernetes so organizations can
continue to reap the benefits of their container
orchestration platform. That said, OpenFaaS requires
more management and configuration than a fully
managed service, such as AWS Lambda or Azure
Functions and scaling will not be as smooth unless
OpenFaaS runs on a solid Kubernetes infrastructure.
The American Journal of Engineering and Technology
22
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
Figure 3: OpenFaaS for AWS Lambda
3.2 Benchmarking Methodology for Performance
Evaluation
When benchmarking FaaS platforms, it is critical to
identify metrics that are easily measurable across
different platforms. Latency, throughput, scalability:
This is what the primary performance metrics shall be
(Aslanpour et al., 2020). Latency is the period between
a function is invoked and when the response is
returned. Time sensitive applications like financial
transactions, gaming, and real time analytics require
low latency as it makes all the difference from the user
experience as minor delays may ruin the end product.
On the other hand, for a given number of requests
through a platform can handle requests per second.
Applications that process large quantities of data need
high throughput such as streaming platforms or high
traffic web applications where the capability in case of
processing many requests at once without degrading is
an important performance factor. Scalability is how the
platform behaves under higher traffic without any
performance degrading. One of the main reasons that
make FaaS so attractive is that they are able to scale
automatically and efficiently with varying workloads,
but it is essential to test how each platform behaves
under stress, especially when the demand is in spike
and the traffic increases.
But in order to do a proper benchmarking, platforms
like Apache JMeter or Artillery are typically used to
simulate such a real world load (Gortázar et al., 2022).
They use these tools to generate traffic which simulates
several concurrent requests and checks how system is
performing under these conditions. These tools also
simulate different traffic patterns to evaluate how the
platform responds under various load conditions, its
capacity to scale, resource utilization, etc. Besides
these, cloud-native monitoring tools like AWS
CloudWatch, Google Stackdriver, or Azure Monitor
provide useful insights on real-time metrics such as
response time, function execution time, error rates,
and resource usage. These are the tools that can help
developers and system administrators to see the
serverless functions performance in real time, identify
the bottlenecks, and gather data to improve it further.
By combining these benchmarking tools with
monitoring platforms, organizations gain a holistic view
of platform performance, enabling data-driven
decisions on whether to spin up or deploy their FaaS
infrastructures
The American Journal of Engineering and Technology
23
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
Figure 4: Conceptual Model of Cloud Performance Metrics
3.3 Performance Metrics to Consider: Latency,
Throughput, Scalability
Latency, throughput, and scalability are performance
metrics that weigh heavily when choosing a Function-
as-a-Service (FaaS) platform for different use cases
(Raza et al., 2021). Latency is crucial for applications
involving real-time performance, such as live financial
trading platforms and multiplayer games. Cold start
latency especially affects users if they are not using a
popular service with extremely predictable or
nonexistent traffic. Latency can be minimized via pre-
warming, caching, or tweaking function code and
dependencies. Applications must process enormous
volumes of data at high speeds. Data streaming, video
processing, high-volume high-volume APIs, and so
forth, and therefore, throughputs are vital. The
platform can handle many requests simultaneously,
and high throughput means that the platform can
maintain performance even during peak usage.
However, scalability refers to the capacity of a platform
to up or marginally boost the load it has to handle
without bringing down its performance. Especially in
the context of e-commerce websites, the traffic of
consumer-facing applications, and IoT systems, this is
important.
The application is different, and the meaning of each
metric is quite different for various applications (Hossin
& Sulaiman, 2015. For instance, when low latency is not
as essential, an application that needs high throughput
canprioritizebility over rover cold start time.
Performance benchmarks for AWS Lambda, Google
Cloud Functions, Azure Functions, and OpenFaaS give
valuable perspectives on each product’s strengths.
Lable to handle millions of daily requests, but
complicated by high cold start latency in languages like
Java or .NET. Google Cloud Functions is great at
handling real-time events with low cold start latency
and is a perfect fit for IoT and real-time data processing.
However, AWS Lambda may be more scalable than
Lambda under heavy demand scenarios. Enterprise
workloads can be well integrated with Azure Functions,
but cold start latency is higher under some conditions.
Flexibility to work in a self-managed environment
complements Kubernetes nicely but is easier to
configure and watch over (Weyns & Gerostathopoulos,
2022).
3.4 Case Studies on Real-World Workloads and
Performance Analysis
A few real-world case studies are then used to
demonstrate the behavior of the FaaS platforms under
different workloads. Many e-commerce platforms use
AWS Lambda to deal with transaction requests,
especially during peak sales seasons. With scalable
architecture, Lambda can still process millions of
concurrent
requests
without
compromising
performance, making it a great match for high-traffic
events such as Black Friday sales. While that makes
sense for a fast-growing app, cold start latency is much
more noticeable during low-traffic times; a fast
response is critical during high-frequency, high-
frequency transactions. As this shows, AWS Lambda is
The American Journal of Engineering and Technology
24
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
an excellent choice for scalability. Still, it is not
completely solved for the cold start problem in the
described use cases behind an arguably even more
important performance attribute: low and consistent
latency.
In the case of IoT applications, Google Cloud Functions
is useful for real-time data processing, particularly
where low latency is essential (Díaz et al., 2016). For
example, an IoT system that uses Google Cloud
Functions processes data from thousands of devices in
real time to make quick decisions every second based
on data streaming. Google Cloud Functions bring many
benefits, such as fast cold start times and seamless
integration with other Google Cloud services like
Pub/Sub, and it further improves performance when
used for event-driven, real-time systems. Specifically,
these case studies demonstrate that by optimizing pre-
warming, auto-scaling, and caching strategies, real-
world applications can achieve performance gains;
however, the choice of platform is primarily
determined by which combination of application needs
satisfies, latency sensitivity, scale requirements, and
integrations with other services.
4. Resource Management and Cost Optimization
Table 2: Resource Management Strategies for FaaS
Strategy
Description
Potential Impact on Cost and Performance
Auto-scaling
Automatically adjusts the number of
function instances
Ensures optimal resource utilization during varying
load, reduces costs
Memory Allocation
Tuning
Fine-tunes memory allocation for functions
Balances performance with cost, prevents resource
over-provisioning
Request Batching
Groups multiple requests into one batch for
processing
Reduces overhead, increases throughput, optimizes
cost
4.1 Auto-Scaling Techniques in FaaS Environments
Serverless computing is distinguished by auto-scaling,
where the application automatically increases or
decreases the number of resources used as required. In
FaaS, auto-scaling ensures that function instances are
dynamically increased or decreased based on incoming
request traffic. Elasticity is the core idea of auto-scaling
in serverless computing
—
when system demand or load
is high, it allocates more resources to process extra
traffic and reduces costs when demand decreases. The
process of handling this is handled by FaaS platforms
without any manual intervention. For instance, AWS
Lambda will scale the number of live function instances
automatically as per the incoming request. The cloud
provider manages this automatic scaling, and the
operation never stops without the need for extra
hardware or virtual machines to be provisioned. It is
also scalable for the applications where the traffic is
fluctuating and hence, resources are allocated only
when required thus trying to reduce the costs incurred
on the resources which are idle. Nevertheless, auto-
scaling is managed by developers who need to watch
resource usage, understand traffic patterns, and need
scaling limits on the platform to match their
application's needs.
Figure 5: Auto-scaling mechanisms in serverless computing
The American Journal of Engineering and Technology
25
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
4.2 Memory Allocation and Fine-Tuning Function
Performance
Optimizing FaaS performance is based on memory
allocation. How fast the function runs and how
expensive to run the function is dependent upon the
amount of memory it’s been given (Mvondo et al.,
2021). On most FaaS platforms, such as AWS Lambda,
the amount of memory allocated has direct impact on
the amount of CPU power and network bandwidth the
function can utilize, and more often than not, more
memory correlates with better performance.
Memory allocation optimization is a balancing between
resource efficiency and cost-effectiveness (Nyati,
2018). Unless there is a specific reason for allocating
more or less than the minimum required by the callee,
excessive allocation can lead to unnecessary costs,
while insufficient allocation may slow down function
execution or cause resource starvation. Memory
benchmarking can fine-tune memory allocation to
ensure the function runs at the lowest possible cost.
Execution time also matters for performance
optimization. More resources are consumed and more
cost is incurred when they run longer. To gain optimal
performance without overspending, the memory
configuration and execution time of a function
developed by the developers should be optimized.
4.3 Request Batching and Its Impact on Efficiency
One of the hallmarks of serverless computing is auto-
scaling. It can respond to and scale data requirements
based on demand. In FaaS, auto-scaling ensures that
function instances are dynamically increased or
decreased based on incoming request traffic. Elasticity
is the core idea of auto-scaling in serverless
computing
—
if system demand or load is high, then it
presents more resources to process extra traffic. It
saves money when the demand is reduced. FaaS
platforms handle this process without any manual
intervention. For instance, AWS Lambda will
automatically scale the number of live function
instances per the incoming request. The cloud provider
manages this automatic scaling, and the operation
never stops without needing extra hardware or virtual
machines to be provisioned. It is also scalable for
applications with fluctuating traffic. Hence, resources
are allocated only when required, thus reducing the
costs incurred on idle resources (Shojafar et al., 2016).
Nevertheless, auto-scaling is managed by developers
who need to watch resource usage, understand traffic
patterns, and set scaling limits on the platform to match
their application's needs.
4.2 Memory Allocation and Fine-Tuning Function
Performance
Optimizing FaaS performance is based on memory
allocation. How fast the function runs and how
expensive it is depends on how much memory it's been
given. On most FaaS platforms, such as AWS Lambda,
the amount of memory allocated directly impacts the
amount of CPU power and network bandwidth the
function can utilize, and more often than not, more
memory correlates with better performance. Memory
allocation optimization balances resource efficiency
and cost-effectiveness. Unless there is a specific reason
for allocating more or less than the minimum required
by the callee, excessive allocation can lead to
unnecessary costs, while insufficient allocation may
slow down function execution or cause resource
starvation. Memory benchmarking can fine-tune
memory allocation to ensure the function runs at the
lowest possible cost. Execution time also matters a lot
in performance optimization. When functions run
longer, more resources are consumed, and more costs
are incurred. To gain optimal performance without
overspending, the memory configuration and
execution time of a function developed by the
developers should be optimized (Cordingly et al., 2022).
5. FaaS for Stateful Applications
5.1 Challenges with Stateless Nature of Traditional
FaaS
Statelessness is inherent to traditional Function-as-a-
service (FaaS) platforms. In other words, the context or
information about a previous invocation is not
inherited by it. This additional characteristic simplifies
function execution but causes problems, especially in
applications requiring continuity, such as session
persistence, data consistency, and long-running
processes. Stateless FaaS is limited, the primary
limitation being the inability to manage the state. This
is because each function invocation is done in a clean
state, and there is no knowledge of previous executions
for user session management, interactions tracking,
and any complex workflow management, among other
things. For instance, when building an e-commerce
platform, it is essential to keep a record of user sessions
interacting with several function calls to track shopping
cart data or user preferences. Such applications require
external
data
storage
systems,
complicating
development and increasing latency due to data
retrieval bottlenecks. Meanwhile, applications that
require maintaining intermediate states across function
invocations, like batch processing or complex data
transformations, need a functioning job that runs for
The American Journal of Engineering and Technology
26
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
extended periods. While stateless functions, by nature,
are not fit for this work application, the work requires
additional infra mirror and overhead to support this.
The stateless model of the traditional FaaS is a limiting
factor in modern applications where session
persistence and data consistency are key to
functionality, resulting in an urgent need to cater to
stateful operations (de Souza Junior, 2022).
Figure 6: Function as a Service (FaaS):
5.2 Solutions for Stateful Workloads: Faast.js, Knative,
OpenWhisk
To address statelessness challenges, stateful projects
have been created based on stateful platforms that
promote state utility in FaaS. Such platforms to
maintain the state in serverless environments are, for
instance, Faast.js, Knative, and OpenWhisk.
•
Faast.js
—
Faast.js is a framework that enables
building stateful workflows on top of serverless
environments. It uses traditional server-side state
management techniques, like session persistence and
database integration, to enable FaaS applications to
perform stateful operations. Since state data can be
accessed and modified by serverless functions, Faast.js
is ideal for serverless tasks requiring sessions,
transactions, and/or continuous data processing.
•
Knative: Knative is a framework for running
serverless workloads within Kubernetes. It adds
persistent storage and service abstractions for stateful
workloads to the stateless nature of traditional FaaS.
Knative supports long running applications by letting
state be set across multiple function invocations. This
also plays well with Kubernetes and other cloud-native
tools and works well for organizations with Kubernetes
for orchestration.
•
A second is OpenWhisk, which offers
decentralized stateful function execution with
integration of other databases or file systems. To
handle a state outside the serverless environment,
OpenWhisk offers mechanisms to save the state in the
serverless environment so that it is not lost after
function invocations. OpenWhisk allows functions to
link to external data stores, making it possible to keep
an external state across a distributed system while
using the serverless architecture advantages.
•
These solutions demonstrate that it is possible
to bring more of the stateful nature of today's
applications to FaaS, closing the gap between the
stateless FaaS tradition and the need for context
retention from function-to-function execution
Table 3: Comparison of Stateful FaaS Solutions
Solution
Description
Benefits
Limitations
Faast.js
Framework for building
Provides session
Requires traditional state
The American Journal of Engineering and Technology
27
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
Solution
Description
Benefits
Limitations
stateful workflows on serverless
environments
persistence, supports
transactions
management techniques, complex
integration
Knative
Adds persistent storage
and service abstractions for
stateful workloads
Enables long-
running applications,
integrates with Kubernetes
Requires Kubernetes,
complexity in managing states
across multiple invocations
OpenWhisk
Serverless platform with
external state management
capabilities
Supports
decentralized state, integrates
with external data stores
Complexity in managing
state across distributed systems
5.3 Architecture Design for Stateful Serverless
Applications
Storage and state management across multiple
function invocations in stateful serverless applications
is a Wrestle ingredient because it requires much
greater care when designing (Eryurek et al., 2021). The
challenge's crux will be how to store and fetch state to
achieve data consistency and performance. Most
serverless applications store state in external databases
such as DynamoDB, Redis, and Cassandra. Exposing
things like state persistence and querying during
execution can be done easily through these databases,
which are fast and reliable and can also persist the
state. In particular, DynamoDB stores session data or
transaction information used by functions that can
access the state during execution, thanks to AWS
Lambda integration. Developers often use architectural
patterns like Event Sourcing and CQRS (Command
Query Responsibility Segregation) to manage the state
properly while executing several functions. Event
Sourcing is the practice of every change in the
application state being captured in some way as an
immutable event, and the application can rebuild the
state by replaying the events. This is a convenient
pattern for very high transaction loads because a full
history of changes is required. Using CQRS allows read
and write operations to be separated into two different
models so that they do not interfere with each other in
terms of performance. With these storage systems and
architectural patterns at hand, serverless application
architects can create serverless applications that
persist data while still delivering the scalability and
flexibility of serverless computing.
Figure 7: Stateless and Stateful Systems in System Design
5.4 Use Cases for Stateful FaaS in Enterprise and Large-
Scale Applications
FaaS offers stateful operation that is especially useful
to enterprise applications that rely on having session
information available or ensuring data consistency
across invocations (Bocci et al., 2021). In the context of
FaaS, use cases of stateful applications include session
management for web apps or real-time data processing
for IoT & analytics. Session data often plays a major role
in how many web applications track user interactions.
For example, an online banking application must log
user sessions on different requests. On a stateless
model, it means retrieving session data from the
external source every time, which would increase
latency. With stateful FaaS, session management is also
much more effective, regardless of a decreased
overhead. Frequent sensor data collection or running
The American Journal of Engineering and Technology
28
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
analytics platforms on large amounts of data in real-
time require consistent states across function calls.
Taking the smart home system as an example, stateful
FaaS can track the status of devices (such as lights,
temperature sensors, and security cameras) as data
streams from different sources. However, the challenge
of managing the state in a serverless environment
brings the issue of scalability and performance. The
reasons why syncing states across such instances can
get quite hard when functions are distributed across
multiple instances or regions. However, this makes it
more likely that there is extra latency and operational
overhead for consistency. In addition, there are robust
transaction and data update management approaches
to ensure consistency of data across function
invocations and different parts of the system for the
high frequency of transactions or failures. Given these
challenges, avoiding mistakes and relying on
appropriate state management strategies and design is
crucial to make them work.
5.5 Performance and Scalability of Stateful Serverless
Architectures
The state management system and underlying data
stores greatly impact the scalability and performance of
stateful FaaS architectures. Performance and resource
utilization benchmarks between FaaS stateful and FaaS
stateless systems differ: Generally speaking, stateful
systems operate at a higher latency than stateless
systems because of the additional workload to prepare
and retrieve states from external databases or another
form of storage. Extra time is incurred with each
function call because the state might need to be
retrieved from or stored in a database. On the other
hand, stateless systems do not require interacting with
external storage during execution, resulting in speed
improvement, especially for functions that do not rely
that do not rely on the long-term persistence of the
state.
But with stateful systems, this latency can be reduced
by optimizing databases, using caching mechanisms
(Redis, for example), and using distributed data stores
that scale very efficiently under heavy load. This could
be demonstrated by using DynamoDB Global Tables to
facilitate states between regions to improve read and
write performance by replicating data to various
locations, thus offering low-latency access for global
users. Other optimizations include integrating stateful
workflows, which allows functions to carry context
across multiple invocations to avoid recreating or
reloading state. For stateful applications, one can also
optimize performance using databases such as
Cassandra for writing to them or Redis for retrieving
state quickly. The serverless architecture decision must
tradeoff between stateless and stateful architectures
based on balanced latency and the complexity of
maintaining a consistent state across the application.
Stateful FaaS can provide the best Serverless
computing with appropriate optimizations and
architecture choices to solve state-related issues.
6. Serverless Security Challenges
6.1 Multi-Tenancy Risks in Serverless Environments
In serverless environments, one of the major concerns
is the multiple tenancy risk. When multiple users or
organizations share the same physical resources
(virtual machines or containers), referred to as a multi-
tenant environment, it can introduce many security
risks (Turhan et al., 2021). There is a huge data leakage
issue, as sensitive data might be leaked between
tenants in the shared infrastructure without proper
isolation mechanisms. One of the risks is privilege
escalation, in which an attacker could exploit
vulnerabilities inside a serverless environment, gain
elevated privileges, and thus be able to access the other
tenants’ function or their data. Furthermore, when one
tenant’s application consumes too many resources,
overloading the resources affects the performance or
availability of other tenant services, such that they
experience denial of service or degraded performance.
To reduce these risks, cloud providers put a great deal
of security in place, including function isolation, strict
access controls, and data encryption. This helps us
isolate functions in separate containers or microbes so
that no interference exists with tenants. Function
invoking and modification can only be done by
authorized users or services, and access control
mechanisms
block
unauthorized
access.
Data
encryption is also utilized to make sure that sensitive
information at rest and in transit is safe from breaches
to protect it.
The American Journal of Engineering and Technology
29
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
Figure 8: Security vulnerabilities in a multi-tenant cloud environment
6.2 Function-Level Security Policies for Serverless
Functions
Function-specific security should be implemented to
protect FaaS applications each serverless function
needs to be virtualized to ensure that it access control
state who can invoke a fruit legally perforator (RBAC)
and allows administrators to spec if permissions and
specify permissionsitted can access or alter functions.
In addition, function permissions can be fine-tuned to
allow or disallow certain actions (e.g., read, write,
execute) and increase security. Developers should
implement strong authentication mechanisms like
OAuth or API keys to manage access control and secure
APIs to protect data while executing functions. This
prevents anyone from accessing the function or its
processed data.
6.3 Runtime Isolation Mechanisms in FaaS
Runtime isolation is an important capability for
securing serverless environments. Isolating functions
from one another is a common approach used by FaaS
platforms to isolate functions from other functions, in
that a security breach to one function would not affect
other functions. Besides containerization, FaaS
providers use memory isolation to prevent the data and
execution environments of different functions from
mixing in. Trustee execution environments (TEEs),
which separate the code and data more than from the
host operating system, are one of the best practices for
securing runtime environments. Secure boot processes
also make sure (of functions being launched in a trusted
and verified environment) to avoid code injection or
tampering.
6.4 Secure Deployment Strategies for Serverless
Applications
The security of the serverless application is a key
concern that needs to be considered during secure
deployment. This means that a secure CI/CD pipeline
should be implemented so that the code can be tested
for vulnerabilities before it is deployed to production by
the developers. Security checks can be automated to
scan the code for possible flaws or vulnerabilities, and
vulnerability scanning tools detect vulnerabilities in
third-party dependencies (Hsu, 2019).
Table 4: FaaS Security Best Practices
Security Practice
Description
Benefits
Function Isolation
Isolating functions in separate containers
or microVMs to avoid interference
Enhances security by
preventing cross-function breaches
Role-Based Access
Control (RBAC)
Restricts function access based on user
roles
Ensures only authorized users
can invoke or modify functions
Encryption
Encrypting data at rest and in transit to
protect sensitive information
Safeguards data from
unauthorized access and breaches
Vulnerability
Scanning & Audits
Regular audits and scanning for
vulnerabilities in the codebase and dependencies
Detects security issues early,
prevents breaches
The American Journal of Engineering and Technology
30
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
6.5 Case Studies on FaaS Security Breaches and Best
Practices
FaaS security breaches occur in real-world incidents.
For instance, a misconfiguration within AWS Lambda,
wherein improper settings of IAM roles permitted an
attacker to access sensitive data through unauthorized
means. Another happened when a FaaS function
leaking through open APIs was vulnerable to data
leakage. Lessons from this incident are to have regular
audits, encrypt data, and use a zero-trust security
model (Paul & Rao, 2022). Function configuration and
access policies have regular audits done, and if it
detects detects a vulnerability, it must be discovered
early on. In a zero-trust model, everyone inside the
network, even the administrator, is assumed to be
untrusted until proven otherwise, and the operation of
virtually every function should require rigorous identity
verification.
7. FaaS in Edge Computing
7.1 Introduction to Edge Computing and Its Relevance
to FaaS
Edge computing is a distributed computing model that
brings computation and data storage close to where
the data is required, typically closer to the data source,
such as IoT devices and sensors, rather than relying on
a single, centralized cloud server. This proximity
enables reducing latency and can fasten data
processing and real-time decision-making with higher
reliability; this trait makes them especially perfect for
latency-sensitive
applications.
Applications
like
autonomous vehicles, real-time IoT systems, smart
cities, and augmented reality all fall under edge
computing, where quick processing and instant
response are necessary.
Function as a Service (FaaS) is integrated into the edge
computing environment, leveraging the benefits of
serverless computing to allow functions to be executed
on the edge near the data generation place. For real-
time processing, this integration brings the round-trip
data latency to and from centralized cloud servers
down, allowing it to be an appropriate integration for
such applications. Edge computing can allow smart
devices, for example, to send the sensor data to the
cloud server for processing. Still, the edge may execute
the functions in a device place or sometimes on the
edge server nearby, reducing the reliance on the cloud
infrastructure and increasing the response time (Hong
& Varghese, 2019). With FaaS at the edge, developers
can deploy lightweight functions to improve the
performance of distributed applications. It allows edge
devices to perform computation without a constant
connection with the cloud, which in turn leads to
improving resource utilization on the edge and
enhancing system scalability in a distributed system.
Figure 9: Edge Computing
7.2 Latency and Performance Challenges in Edge
Computing
There are several unique challenges in running FaaS in
edge computing environments: latency, resource
The American Journal of Engineering and Technology
31
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
constraints, and network connection. Many times, edge
devices have severely limited processing power,
storage, and memory and, as a result, are handicapped
when it comes to running more complex functions.
These constraints lead to difficulty in the edge
regarding
data-intensive
or
resource-intensive
operations. Even with edge computing, latency is
reduced due to the process of data happening locally,
but it is still influenced by network instability and
variable connectivity. The characteristic of being
geographically dispersed and having inconsistent
function performance due to network speeds that can
fluctuate makes the edge devices functionally
unreliable or unable to perform in real-time.
7.3. Optimization Techniques for FaaS in Low-Latency
Environments
Several approaches can be involved. Several methods
can be used to improve the performance of Function-
as-a-Service (FaaS) in an edge environment (Ascigil et
al., 2021). The most important way to reduce data
retrieval time is storing the data near the point of the
edge function execution. It minimizes the data coming
to centralized cloud servers, significantly decreasing
latency. Furthermore, it can also help to optimize
function execution to reduce execution time and
resource usage. It can be done by lowering
dependencies, optimizing algorithms, and using well-
compacted programming languages like go or Web
Assembly with smaller memory footprints and startup
times (Nyati, 2018). Thus, it also enables Content
Delivery Networks (CDNs) to cache frequently accessed
data at the edge, reducing repeated requests to the
centralized servers and improving response time and
availability. Additionally, local caches are used by edge
caching so that data can be accessed faster and the
calculations do not have to be repeated; a good use
case is applications that work with sensor data or
images.
FaaS has a handful of applications for real-time at the
edge of both IoT and event-driven use cases. In such IoT
systems, devices for smart thermostats, industry
sensors, etc., produce large data volumes that require
immediate processing. Running the FaaS at the edge
allows for real-time analytics that enable speedier
decision-making. For example, industrial IoT systems
can process machine data in real-time to find potential
faults and take activities to maintain without the
support of the cloud. Like most other application
classloads, monitoring video feeds from security
cameras and analyzing health data from wearable
devices benefits from FaaS at the edge to take
immediate actions such as sending alerts or responses
by its devices. By appending FaaS with edge computing,
real-time analytics, such as analyzing traffic data from
smart city sensors, can be processed immediately, for
example, by using traffic light adjustments or notifying
commuters about congestion.
Integrating FaaS with edge computing comes with two
main pros and cons. Edge computing is much faster
than cloud computing and would greatly reduce latency
and response time; it is critical to real-time decisions,
such as autonomous driving or healthcare, in situations
requiring control over seconds, minutes, hours, and
days. Furthermore, it allows local data processing to
ensure data privacy and keep up with data sovereignty
practices. However, edge devices generally have less
available processing power, storage, and memory,
limiting the complexity of functions that can be
executed. Relying on a distributed network of edge
devices also increases the complexity of managing a
complex assembly of these devices in terms of efficient
orchestration and monitoring. Unresolved challenges
include network connectivity, especially in areas that
may experience disconnects from the internet, which
can interfere with function execution. However, FaaS at
the edge presents a worthwhile solution for
applications that need to process data locally, run fast,
and have milliseconds response times
The American Journal of Engineering and Technology
32
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
Figure 10: Edge computing architecture.
8. Hybrid and Multi-Cloud Serverless Architectures
8.1 Importance of Multi-Cloud Deployments in FaaS
Serverless
applications
thrive
in
Multi-cloud
environments with different cloud environments to
host our application and its data. Resilience, fault
tolerance, and reduced vendor lock-in are improved in
these environments. By incorporating redundancy into
a multi-cloud architecture, one key benefit is that if one
cloud were to go down, the system would not be
completely unavailable for the game. When functions
are spread over several cloud providers, an outage in
one can cause the application to fail over another
without impacting the outcome
—
keeping the
application up and running. For mission-critical
applications requiring high availability, redundancy is
essential.
In multi-cloud settings, fault tolerance is increased.
Once workloads are spread across different cloud
platforms, applications can work despite a failure
within one cloud provider’s infrastructure. This is
because systems that cannot operate in case of
disruptions must continue functioning despite
individual provider failures. Also, the multi-cloud is a
strategy for escaping vendor lock-in, in that numerous
cloud companies can be used as solutions and will help
improve the risks associated with vendor lock-in. So
that it maintains it removes the restrictions of using just
a single cloud supplier, and it is better to tailor its cloud
method to satisfy particular organization needs.
Multicloud
setups
are
useful
for
serverless
environments that allow landing workloads within
different providers so that simplicity will again optimize
an application’s availability and performance (Sangapu
et al., 2022).
Table 5: Performance Metrics in Multi-Cloud FaaS Deployments
Metric
Description
Impact on Multi-Cloud Deployment
Redundancy
The ability to replicate functions across
multiple cloud platforms
Enhances availability and fault tolerance
in case of a provider failure
Fault
Tolerance
Ability to continue functioning despite
failure in one cloud provider
Ensures business continuity by
maintaining operations during outages
Vendor Lock-
in
Reduces dependency on a single cloud
provider
Increases flexibility and optimizes cloud
costs
8.2 Kubernetes-Based FaaS Frameworks (Knative,
OpenFaaS) for Cross-Cloud Portability
Kubernetes is an open-source container orchestration
platform that efficiently manages containerized
workloads across multiple environments. Within multi-
cloud Function as a Service (FaaS) settings, Kubernetes
provides organizations with a way to enhance the cross-
cloud portability of functions that run consistently from
The American Journal of Engineering and Technology
33
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
one provider to the next. Of the many frameworks built
on top of Kubernetes, Knative enhances serverless
capabilities by extending Kubernetes. With automatic
scaling, event-driven execution, and functional runtime
across clouds, Knative simplifies function deployment
and runtime management at any scale. It is an
especially good solution for organizations with Jenkins
pipelines that want to ensure portability across Clouds
since Knative can deploy and scale serverless functions
across Kubernetes clusters. There is another framework
to follow, OpenFaaS, which is built atop Kubernetes but
has a developer-facing API upon which functions can be
deployed to a Kubernetes environment as containers.
This provides full control over the lifecycle and scaling
of functions. By running OpenFaaS on a simple
Kubernetes
platform,
it
supports
multi-cloud
architecture and, at the same time, can also be run on
any given Kubernetes platform, which makes OpenFaaS
a perfect choice for organizations with apps to run on
their FaaS across multiple clouds. Knative and
OpenFaaS provide serverless portability, allowing these
applications to be moved and scaled across different
cloud providers without disruption.
Figure 11: OpenFunction: Build a Modern Cloud-Native Serverless Computing Platform
8.3 Design and Architecture Considerations for Hybrid
Cloud Serverless Solutions
Like any application design, carefully planning
serverless
applications
run
in
hybrid
cloud
environments (on-prem and cloud resources running
together) is necessary. Organizations can optimize
performance and be flexible by leveraging on-premises
and cloud resources using hybrid architectures. With
serverless, functions run in the cloud based on on-
premise data stores or interact with legacy systems. A
well-designed API management, secure data transfers,
and synchronization mechanisms are needed to ensure
a seamless integration. Fault tolerance, load balancing,
and resource allocation must be considered when
designing hybrid cloud serverless architectures.
However, it has to have proper orchestration tools and
monitoring solutions to be resilient and responsive to
demand changes.
Distributed functions through the multiple cloud
providers in a multi-cloud FaaS architecture promote
resilience. Building on this approach provides
advantages of load balancing, failover strategy, and
data redundancy to guarantee data availability even in
the case of provider failure. There are real-world
examples of such multi-cloud strategies like AWS
Lambda and Google Cloud Functions being used to
achieve global availability on a worldwide e-commerce
platform. Likewise, a healthcare company uses
OpenFaaS across AWS and Azure to utilize data locality
and fulfill data sovereignty requirements. The
discussions in these case studies show how the multi-
cloud approach benefits serverless applications in
optimizing vendor lock-in, scalability, and reliability
(Fatahi Baarzi, 2021).
9. Optimization Techniques for FaaS
9.1 Pre-Execution and Runtime Optimizations
To optimize the performance of FaaS functions, pre-
execution and runtime strategies must be optimized to
achieve lower latency, faster execution speed, and
The American Journal of Engineering and Technology
34
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
greater efficiency throughout the function’s lifecycle
(Chen et al., 2016). The lazy loading is one of the
effective pre-execution optimization technique in
which a function loads only specific components or
dependencies when needed rather than loading all of
them in upfront. This decreases the initial load time and
memory usage so that the execution is light and quick.
In the case of a function meant for data analysis, a
library suite of analytical tools is only loaded while
needed per the current task instead of an entire suite
of such tools. The next optimization of the note is
caching, which can be done at execution time or even
ahead of time. When queries or data requests from the
database/external API are frequent, storing that
commonly used data in fast-access memory such as
Redis or in-memory caching can improve performance.
This improves the overall performance by a great deal
because it greatly decreases such metrics as data
retrieval latency and external dependency call
overhead. For example, functions that query the
database and locate the user profiles can store the data
most commonly requested in their cache to avoid
having to keep querying the database and reducing
response time. In addition, they are beneficial in
minimizing what parts of the serverless function
deployment are deployed when loading them and
quickly loading them. The libraries and frameworks
included in the function deployment should be
minimized to avoid unnecessary or oversized libraries
regarding cold start time and execution overhead.
Using such pre-execution and runtime optimizations,
FaaS applications can be made more efficient, and
faster, more responsive serverless solutions are
provided.
Figure 12: Latency and resource consumption analysis for serverless edge analytics
9.2 Managing Scaling and Load Balancing for FaaS
Scaling and load balancing must work well, as this is
only possible with FaaS applications to handle high-
demand operations without degrading performance
(Sharma, 2016). Unlike traditional server-based
computing, FaaS platforms automatically scale
functions to meet incoming traffic but should be as
flexible as possible in this scaling process. For example,
horizontal scaling refers to increasing the number of
function instances to support higher traffic volumes.
Since these platforms automatically manage scaling,
developers can fine-tune scaling parameters to achieve
optimal results with minimal effort. Since it is horizontal
scaling and the number of instances depends on traffic
load, when such spikes occur in applications, additional
function instances will get added to meet the traffic
load. Auto-scaling groups can control the number of
function instances based on demand for all but the
most basic configurations. These groups can be set up
with pre-defined rules that monitor traffic and create
additional cases when the level of requests exceeds a
set limit. It helps sustain the performance to an
optimum without over-provision, reducing costs.
Function routing is also another important strategy.
The concept involves routing incoming requests to
appropriate function instances thanks to certain
conditions, such as location, request type, or resource
availability. By function routing, function requests that
require a quick response, or are otherwise priority
requests, are routed to the most responsive, or
available of function instances. From the point of
The American Journal of Engineering and Technology
35
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
maintaining FaaS application load balancing and
preventing the application from degrading because of
their high traffic load, this approach improves load
balancing. It ensures that FaaS applications continue to
function efficiently. Organizations can protect
themselves from unexpected loads and keep the FaaS
applications responsive and scalable while allowing
them to be both responsive and cost-effective by
effectively balancing load and scaling.
9.3 Techniques for Reducing Overheads in Serverless
Architectures
Optimal performance in serverless architectures is
realized by minimizing overhead. Techniques include
memory management, which allocates enough (or too
little) memory to eliminate unnecessary costs and
executes efficiently. Developers should analyze the
function performance to find the most suitable
memory configuration. It also includes eliminating
redundant processing by fetching and re-calculating
similar data for multiple inputs. Developers speed
things up by caching results or pre-processing data by
leveling off the need for redundant tasks. In particular,
reducing overhead related to initialization is also
important for functions with large dependencies.
Smaller, modular units split the larger functions and
load only the required dependencies, which minimizes
the time it takes for the function to initialize and run
faster.
Fast Function as a Service (FaaS) also helps to integrate
CI and CD pipelines to improve development, testing,
and deployment processes. Testing is automated to
check for its functionality, performance, and scalability
immediately if there is any change in codebase. For
FaaS, this means testing whether the functions respond
within an acceptable time and how they scale under
load. Automated deployment takes this one bigger step
and guarantees that new or updated functions are
deployed to the production without us doing anything
to make codebase up to date. CI/CD pipelines also
automate the auto-scaling part, ensuring the functions
will scale themselves automatically to satisfy the
normal traffic load and always deliver the highest
performance and availability (Wu, 2015).
Benchmarking is needed to evaluate the performance
of optimization techniques in FaaS. Apache JMeter or
Artillery can perform performance testing to determine
increased resource usage, latency, and scalability
improvements. Thus, resource utilization optimization
can be achieved in various ways, including resource
tuning (memory, caching, or lazy loading) and reducing
costs. Caching and pre-execution optimizations can be
used to minimize latency, while the system can be
tested to determine its scalability by measurement of
scale-up and scale-out capabilities. With a serverless
provider, the insights provided in this article add value
to organizations’ ability to keep serverless applications
cost-effective, high-performing, and scalable.
Figure 13: Optimizing Costs in Serverless Computing: Strategies and Best Practices
10. Best Practices
Deploying, optimizing, and securing function-as-a-
service (FaaS) applications is the highest level of
operations in software development. Best practices
have been found in various development areas to make
FaaS deployments effective and efficient.
10.1 FaaS Deployment Best Practices
Regarding cloud services, one of the most important
The American Journal of Engineering and Technology
36
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
best practices is reducing the cold start, which can be
particularly killer for latency-sensitive users. Therefore,
functions can be warmed up to mitigate cold start
latency by regularly calling these functions. Moreover,
related to reducing the time to initialize a function,
tasks that are likely to be triggered in a coordinated
manner can be deployed into the same instance.
Reducing cold starts can also be achieved via smaller
function sizes, with deploying multiple lightweight
functions typically more efficient than deploying one
big monolithic function. Managing a maximum number
of instances is another important deployment practice.
The number of cases must not surpass the demand;
hence, it should be limited to prevent overbooking
resources. This ensures that resources are not wasted
and performance bottlenecks are avoided. Real-time
processes like AWS Cloudwatch or Google Stack driver
monitoring resource usage, invocation frequency, and
basic bottlenecks can be optimized for performance
and cost. Finally, FaaS is the best fit for microservices
architectures. They help scale large monolith systems
by separating them into smaller manageable bits. It
allows each function to scale independently, increasing
flexibility and recovery from failure.
10.2 FaaS Optimization Best Practices
Attention to resource allocation is required to optimize
function
performance
in
FaaS
environments.
Performance and cost are very dependent on the
allocation of memory and CPU. To determine the
amount of memory and CPU required for function
execution, it's essential to allocate resources
appropriately. Allocating too many resources can be
unnecessary, leading to increased costs, while too few
resources can result in slower performance and
resource starvation, negatively affecting the function's
execution. Proper resource allocation involves
analyzing
the
function's
performance
and
understanding
the
workload's
requirements,
optimizing the memory and CPU configuration to
ensure efficient operation and cost-effectiveness. Also,
choosing the correct programming language is part of
function optimization. Some more popular FaaS
platforms have multiple programming languages, but
most take longer than Node.js or Go with Java or .NET.
For this reason, one should choose the appropriate
language given the workload. The next optimization
practice is to use as few external dependencies as
possible. Init time and cold start latency are lowered
because of a few external dependencies.
10.3 FaaS Security Best Practices
Isolating functions is critical to security; unauthorized
access or interference with functions should be
prevented. Each function should be containerized or
run in microVMs, ensuring that no other function in the
multi-tenant architecture can be affected by any
vulnerability in one function. One key security practice
is Role-Based Access Control (RBAC), which allows the
invocation of functions only by authorized users. This
limits access to the resources that each function needs
and prevents unauthorized actors from accessing
sensitive data or system resources. The security of FaaS
also includes encryption. Regardless of the amount of
information processed, if the data is sensitive, it should
be encrypted both in transit and at rest. Encryption
serves as a crucial layer of security against data
breaches. Additionally, FaaS configurations must be
regularly scanned for weaknesses and audited to
identify vulnerabilities. Automated vulnerability
scanning tools can detect issues in third-party libraries
and unpatched vulnerabilities, which could pose risks if
left unaddressed.
11. Future Considerations
Since Function-as-a-Service (FaaS) is undergoing its
development, some areas need attention for future
optimization and further development (Pedone &
Mezgár, 2018). Appropriately, one significant area is
integrating serverless machine learning, as the role of
machine learning and artificial intelligence confounds
the limits of FaaS capabilities. The serverless platforms
improve the scalability of machine learning models
without manual provisioning. However, serverless
machine learning requires advancements in model
training, real-time data processing, and managing
complex
interdependencies.
Additionally,
edge
computing integration is increasingly critical, especially
with the rise of the Internet of Things (IoT) and real-
time processing needs. Integrating FaaS with edge
computing will enhance performance while reducing
latency and bandwidth usage. In practice, serverless
applications are being deployed at the edge and in
hybrid environments, necessitating innovation in
distributed systems management and orchestration.
Besides, as quantum computing moves forward,
quantum capabilities might be integrated with FaaS,
raising the possibility of achieving powerful
computation
in
optimization
and
data-heavy
workloads. While quantum FaaS is still rather new, the
research could lead to new potential in serverless
architectures.
Another critical area of future development is improved
optimization techniques. Although cold start problems
have been mitigated, the predictive scaling and lazy
loading mechanism remain to be explored (Kumar,
The American Journal of Engineering and Technology
37
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
2019). Predicting when a function will be triggered and
keeping certain functions 'warm' without going
overboard regarding resources is still a key problem.
Additionally, the performance metrics used to allocate
resources to the cluster dynamically could be
improved. Rather, resource consumption is monitored
at the invocation point, which leads to less effective
scaling solutions for resource use. Auto-scaling the
resources using AI-driven AI improves the demand, is
proactive, and adapts the resources, reducing overhead
and maintaining performance (Qu et al., 2016).
FaaS security frameworks also need to be developed.
Implementing zero-trust security models within
serverless environments is one promising way to
approach the security of FaaS functions, as FaaS
functions work with multiple services and external APIs.
In a zero-trust architecture, every request, even from
internal services, is assumed to be compromised, and
security is strengthened by enforcing rigorous
authentication and validation for any function. At the
same time, as more organizations run those functions
across multiple cloud providers, consistency and
security of cross-cloud communication will be essential.
Developing security frameworks that enable encrypted
and secure communication between different cloud
functions is a requisite for multi-cloud serverless
applications.
The future will depend on the evolution of multi-cloud
and hybrid-cloud FaaS platforms. With serverless
applications growing by the day, future FaaS platforms
should be built in a way that is able to provide cross-
cloud portability to ensure that the serverless
applications can be deployed across various cloud
providers with minimal effort. This means defining the
standards for enabling orchestration on multiple clouds
so FaaS functions can easily be moved across the
environments without losing functionality. Moreover,
the hybrid cloud will continue emerging as a
combination of on-premises infrastructure and cloud
resources. Given the recent rise in popularity of
serverless computing, serverless solutions need to cope
with providing both private and public cloud support
for enterprises to reap the benefits of such computing
while preserving some control over their infrastructure
elements. Future considerations indicate that further
innovation in FaaS must be developed to enable its
capabilities to reduce the future needs of developers
and businesses.
12. Potential Contributions of This Research
It provides several high-value contributions to the
academic community and industry practitioners based
on this Function-as-a-Service (FaaS) optimization
research. The key contribution is seeing to the
benchmarking of the major FaaS platforms, such as
AWS Lambda, Azure Functions, Google Cloud Functions
and OpenFaaS. This research provides insights into
metrics such as latencies, throughputs and scalability,
allowing organizations to decide what platform best
suits their needs. The benchmarking results offer
practical guidance for choosing the right platform to
meet an application's exact needs, such that the
respective organizations can get more out of their cloud
infrastructure in terms of performance and costs.
Beyond benchmarking, the research also offers
practical guidance on how to optimize the performance
of FaaS functions. Cold start latency is the problem with
FaaS, which is one of the most pressing unless
interested only in batch processing and don't need
time-sensitive applications to become available in the
first place. To tackle cold start, the research evaluates
several optimization methods, such as pre-warming,
snapshotting, and harnessing lightweight runtimes like
WebAssembly. The first strategy is to reduce the time
for function initialization to make them respond quickly
to incoming requests. This leads to a reduced cold start
latency, resulting in better and smoother user
experience or simply the performance of real-time
applications for enterprises.
Besides the usual concerns of optimizing FaaS
applications, such as resource utilization and scalability,
additional considerations are making the problem
extremely difficult. The research examines memory
allocation tuning, pre-warming of computers, and the
usage of intelligent auto-scaling mechanisms to
enhance resource efficiency. By exploring how
organizations allocate
–
and should allocate
–
resources
for functions, organizations can save money while
ensuring that things function as they should. The
research also discusses the need to use often data
caching, which can greatly reduce data retrieval and
response times. When best practices of serverless
resource management are in place, enterprises can
build a more efficient and cheaper serverless
architecture.
The research also focuses on security, especially in
multi-tenant FaaS environments. As physical resource
sharing among multiple users is the case in multi-
tenancy, several security challenges arise, such as data
leakage, unauthorized access, resource contention, etc.
This research explores strategies to mitigate these risks,
including function isolation, role-based access control
(RBAC) and encryption. For cloud providers, it is
The American Journal of Engineering and Technology
38
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
possible to prevent unauthorized access and abuse of
sensitive data by isolating functions to secure
containers or microbes. With encryption, the data is
secure at rest and in transit and securing FaaS
applications is further fortified. The security of
deploying serverless applications in a multi-tenant
context with extremely high levels of protection is
critical to security for organizations deploying
serverless applications.
This research also shows real-world case studies of
companies implementing FaaS in their production
systems. The case studies discussed here highlight the
challenges and successes in FaaS adoption among
organizations. For instance, the research shows how e-
commerce platforms have utilized AWS Lambda to
handle wave traffic during sales events, meaning using
FaaS for scaling and cost optimization is possible. The
study also looks at how Google Cloud functions are
used in IoT applications for real-time data processing
and discusses how low cold start latency and seamless
chat with other Google Cloud services provide benefits.
The case studies exemplify that FaaS is very flexible and
can be applied to e-commerce, IoT, and real-time
analytics use cases. This research significantly
contributes to the literature on the optimization and
security of FaaS applications. This research offers
practical strategies for cloud architects, developers,
and enterprises in deploying, optimizing, and securing
FaaS applications in real-world environments by
guiding them in using FaaS in cloud deployments. These
findings also offer a roadmap for future research and
development in mitigating cold start, resource
allocation and serverless security. In the coming years,
as FaaS evolves, the insights discussed in this research
will be critical for organizations that want to capitalize
on the scalability, flexibility, and cost-efficiency of
serverless computing.
CONCLUSION
This research explores the evolution and optimization
of Function-as-a-Service (FaaS) platforms in serverless
computing environments, offering insights into how
these platforms can be tuned to improve performance,
scalability, and cost. The findings on the advantages
include the fact that FaaS can scale very well, offers
flexibility through having no restrictions, and helps cut
costs because there is no management on the
infrastructure. Nevertheless, this leads to cold starts,
i.e., introducing latency when the functions are invoked
after idle, making the scaling hard. The challenge of
mitigating this problem was researched on several
strategies:
pre-warming,
snapshotting,
and
WebAssembly-based runtimes that sacrificed either
resource consumption, operational complexity, or
performance.
Investigation
of
performance
benchmarking across major FaaS platforms, AWS
Lambda, Google Cloud Functions, Azure Functions, and
OpenFaaS, showed the different ways in which these
platforms differ in cold start latency, throughput, and
scalability, and how this can be used to select the right
platform for the needs of the application.
This research also analyzed the complexities of keeping
a state in serverless environments where functions are
usually stateless. Serverless applications can integrate
stateful FaaS solutions such as Faast.js, Knative, and
OpenWhisk to handle more use cases, such as
managing cases requiring session data persistence or
long-running tasks. However, the challenge of
managing consistency and synchronization of states
among distributed systems has yet to be fully
addressed. It also talked about the security risks of
multi-tenancy
in
serverless
environments.
It
highlighted the need for strong isolation mechanisms,
encryption, and access control to protect data and
functions from unauthorized access or breaches.
The future directions of FaaS optimization are to
improve cold start mitigation techniques, optimize
resource allocation efficiency, and further intelligent
scaling mechanisms. FaaS, however, should be seeing
its capabilities extend in correspondence to machine
learning, edge computing, and quantum computing.
Challenges regarding resource constraints in the server,
network instability between server and wireline
networks, and cold starts will need to be resolved to
integrate FaaS with the edge computing environments,
such as for real-time IoT and sensor data processing
applications. However, the remedy here is to drastically
reduce the latency. While FaaS itself is already
developing rapidly, it may ultimately integrate with
quantum computing to leverage its computational
power to do workloads that are otherwise intractable
by traditional computers in an early stage. There are
opportunities for further research and development in
these areas.
This research’s findings have important ramifications
for cloud architects, DevOps teams, and enterprises
(Bass et al., 2015). With this knowledge, cloud
architects can implement more efficient and less costly
serverless
applications
according
to
business
requirements. The insights about how to integrate the
CI/CD pipeline with FaaS can be leveraged by DevOps
teams to shorten the development, testing, and
deployment lifecycle of the functions about
performance and scalability. Adopting best practices in
The American Journal of Engineering and Technology
39
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
resource management, security, and multi-cloud
deployment reduces the probability of vendor lock-in
and increases resilience across cloud environments
enterprises. In the future, FaaS and serverless
computing will become increasingly critical in modern
cloud computing. Serverless computing represents an
attractive model to sort from the enterprises’ recently
increased need for agile, efficient, and scalable
solutions hand in hand with the end-of-the-day
technologies in machine learning, edge computing, and
quantum computing. With the evolution of FaaS, it will
continue to innovate and make application
development in the cloud digital in the best way
possible. With time, there will be more optimizations,
even stronger security frameworks, and easy cross-
cloud deployments, leaving FaaS to remain one of the
major parts of the modern cloud architecture.
REFERENCES
Abid, H. (2022). A review on the most common pricing
strategies.
International Journal of Finance, Insurance
and Risk Management
.
Ascigil, O., Tasiopoulos, A. G., Phan, T. K., Sourlas, V.,
Psaras, I., & Pavlou, G. (2021). Resource provisioning
and
allocation
in
function-as-a-service
edge-
clouds.
IEEE Transactions on Services Computing
,
15
(4),
2410-2424.
Aslanpour, M. S., Gill, S. S., & Toosi, A. N. (2020).
Performance evaluation metrics for cloud, fog and edge
computing: A review, taxonomy, benchmarks and
standards for future research.
Internet of Things
,
12
,
100273.
Bannon, R. (2022).
Leveraging Machine Learning to
Reduce Cold Start Latency of Containers in Serverless
Computing
(Doctoral dissertation, Dublin, National
College of Ireland).
Bass, L., Weber, I., & Zhu, L. (2015).
DevOps: A software
architect's perspective
. Addison-Wesley Professional.
Bocci, A., Forti, S., Ferrari, G. L., & Brogi, A. (2021).
Secure FaaS orchestration in the fog: how far are
we?.
Computing
,
103
(5), 1025-1056.
Chavan, A. (2021). Eventual consistency vs. strong
consistency: Making the right choice in microservices.
International Journal of Software and Applications,
14(3),
45-56.
https://ijsra.net/content/eventual-
consistency-vs-strong-consistency-making-right-
choice-microservices
Chen, N., Cardozo, N., & Clarke, S. (2016). Goal-driven
service composition in mobile and pervasive
computing.
IEEE
Transactions
on
Services
Computing
,
11
(1), 49-62.
Cordingly, R., Xu, S., & Lloyd, W. (2022, September).
Function memory optimization for heterogeneous
serverless platforms with cpu time accounting. In
2022
IEEE international conference on cloud engineering
(IC2E)
(pp. 104-115). IEEE.
Díaz, M., Martín, C., & Rubio, B. (2016). State-of-the-
art, challenges, and open issues in the integration of
Internet of things and cloud computing.
Journal of
Network and Computer applications
,
67
, 99-117.
Eryurek, E., Gilad, U., Lakshmanan, V., Kibunguchy-
Grant, A., & Ashdown, J. (2021).
Data governance: The
definitive guide
. " O'Reilly Media, Inc.".
Fatahi Baarzi, A. (2021). Multi-Cloud Serverless
Deployment.
George, G., Bakir, F., Wolski, R., & Krintz, C. (2020,
November). Nanolambda: Implementing functions as a
service at all resource scales for the internet of things.
In
2020 IEEE/ACM Symposium on Edge Computing
(SEC)
(pp. 220-231). IEEE.
Gortázar, F., Gallego, M., Maes-Bermejo, M., Chicano-
Capelo, I., & Santos, C. (2022). Cost-effective load
testing of WebRTC applications.
Journal of Systems and
Software
,
193
, 111439.
Hilbig, A., Lehmann, D., & Pradel, M. (2021, April). An
empirical study of real-world webassembly binaries:
Security, languages, use cases. In
Proceedings of the
web conference 2021
(pp. 2696-2708).
Hoffman, K. (2019). Programming WebAssembly with
Rust: unified development for web, mobile, and
embedded applications.
Hong, C. H., & Varghese, B. (2019). Resource
management in fog/edge computing: a survey on
architectures, infrastructure, and algorithms.
ACM
Computing Surveys (CSUR)
,
52
(5), 1-37.
Hossin, M., & Sulaiman, M. N. (2015). A review on
evaluation
metrics
for
data
classification
evaluations.
International journal of data mining &
knowledge management process
,
5
(2), 1.
The American Journal of Engineering and Technology
40
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
Hsu, T. H. C. (2019).
Practical security automation and
testing: tools and techniques for automated security
scanning and testing in devsecops
. Packt Publishing Ltd.
Karwa, K. (2025). Navigating the digital shift: The
evolution of career services in the digital age.
International Journal of Social Research and
Application
,
10
.
https://journalijsra.com/content/navigating-digital-
shift-evolution-career-services-digital-age
Kumar, A. (2019). The convergence of predictive
analytics in driving business intelligence and enhancing
DevOps
efficiency.
International
Journal
of
Computational Engineering and Management, 6(6),
118-142.
Retrieved
from
Li, Y., Lin, Y., Wang, Y., Ye, K., & Xu, C. (2022). Serverless
computing:
state-of-the-art,
challenges
and
opportunities.
IEEE
Transactions
on
Services
Computing
,
16
(2), 1522-1539.
Manner, J., Endreß, M., Heckel, T., & Wirtz, G. (2018,
December). Cold start influencing factors in function as
a service. In
2018 IEEE/ACM International Conference
on Utility and Cloud Computing Companion (UCC
Companion)
(pp. 181-188). IEEE.
Mvondo, D., Bacou, M., Nguetchouang, K., Ngale, L.,
Pouget, S., Kouam, J., ... & Tchana, A. (2021, April). OFC:
an opportunistic caching system for FaaS platforms.
In
Proceedings of the Sixteenth European Conference on
Computer Systems
(pp. 228-244).
Nyati, S. (2018). Revolutionizing LTL carrier operations:
A comprehensive analysis of an algorithm-driven
pickup and delivery dispatching solution. International
Journal of Science and Research (IJSR), 7(2), 1659-1666.
Retrieved
from
https://www.ijsr.net/getabstract.php?paperid=SR2420
3183637
Nyati, S. (2018). Transforming telematics in fleet
management: Innovations in asset tracking, efficiency,
and communication. International Journal of Science
and Research (IJSR), 7(10), 1804-1810. Retrieved from
https://www.ijsr.net/getabstract.php?paperid=SR2420
3184230
Palumbo, F., Aceto, G., Botta, A., Ciuonzo, D., Persico,
V., & Pescapé, A. (2021). Characterization and analysis
of cloud-to-user latency: The case of Azure and
AWS.
Computer Networks
,
184
, 107693.
Paul, B., & Rao, M. (2022). Zero-trust model for smart
manufacturing industry.
Applied Sciences
,
13
(1), 221.
Pedone, G., & Mezgár, I. (2018). Model similarity
evidence and interoperability affinity in cloud-ready
Industry 4.0 technologies.
Computers in industry
,
100
,
278-286.
Pedone, G., & Mezgár, I. (2018). Model similarity
evidence and interoperability affinity in cloud-ready
Industry 4.0 technologies.
Computers in industry
,
100
,
278-286.
Qu, C., Calheiros, R. N., & Buyya, R. (2016). A reliable
and cost-efficient auto-scaling system for web
applications
using
heterogeneous
spot
instances.
Journal
of
Network
and
Computer
Applications
,
65
, 167-180.
Raza, A., Matta, I., Akhtar, N., Kalavri, V., & Isahagian,
V. (2021). Sok: Function-as-a-service: From an
application developer’s perspective.
Journal of Systems
Research
,
1
(1).
Roy, R. B., Patel, T., & Tiwari, D. (2022, February).
Icebreaker: Warming serverless functions better with
heterogeneity. In
Proceedings of the 27th ACM
International Conference on Architectural Support for
Programming Languages and Operating Systems
(pp.
753-767).
Sangapu, S. S., Panyam, D., & Marston, J. (2022).
The
Definitive Guide to Modernizing Applications on Google
Cloud: The what, why, and how of application
modernization on Google Cloud
. Packt Publishing Ltd.
Sharma, S. (2016). Expanded cloud plumes hiding Big
Data
ecosystem.
Future
Generation
Computer
Systems
,
59
, 63-92.
Shojafar, M., Cordeschi, N., & Baccarelli, E. (2016).
Energy-efficient adaptive resource management for
real-time vehicular cloud services.
IEEE Transactions on
Cloud computing
,
7
(1), 196-209.
Silva, P., Fireman, D., & Pereira, T. E. (2020, December).
Prebaking functions to warm the serverless cold start.
In
Proceedings of the 21st International Middleware
Conference
(pp. 1-13).
The American Journal of Engineering and Technology
41
https://www.theamericanjournals.com/index.php/tajet
The American Journal of Engineering and Technology
Turhan, M., Scopelliti, G., Baumann, C., Truyen, E.,
Muehlberg, J. T., & Petik, M. (2021). The Trust Model
For Multi-tenant 5G Telecom Systems Running
Virtualized Multi-component Services.
Weyns, D., & Gerostathopoulos, I. (2022). Analysis
Report Survey on Self-Adaptation in Industry
.
