Serverless Architecture & Computing: Pros, Cons, Best Fits, and Solving Challenges

Want to build websites and apps in a way that’s both easier and cheaper? Well, it’s possible even for major organizations and international companies. In this article, let’s take a look at how serverless architecture and computing is changing the game for software developers.

We’ll start at the very beginning and walk through how serverless works, how we got this far, and the pros & cons of this approach.

What is serverless computing? Traditional vs. serverless architecture

Normally, when you create a website or app, you have to set up a special computer called a server to run it. This computer needs to be big and powerful enough to handle all the visitors and users that might come to your site or app.

With serverless architecture, you don't need to worry about setting up and managing your own server. Instead, you can use a special service that takes care of everything for you. This third-party service service will:

• Automatically handle things like making sure your website or app runs smoothly and securely.
• Only charge you for the resources you use.

So, before we get too technical, let’s imagine you wanted to build a lemonade stand. Normally, you would have to build the stand yourself, get all the materials and set it up. But with serverless architecture, you could just rent a pre-built lemonade stand and only pay for the time you use it. This makes it easier and cheaper for you to sell lemonade to your customers.

How serverless architecture works

💻 🌆 Serverless architecture is the name of the computing paradigm that allows users to develop and run software applications without having to manage the underlying technology infrastructure. (A popular model is AWS Lambda.) In this model, third-party services and programmable functions handle activities such as:

• Server provisioning
• Configurations management
• Scalability of data, application and storage systems

These services include BaaS and FaaS.

Backend as a Service (BaaS)

In the backend as a service model, your developers focus on the frontend design and development, while the backend development process and maintenance is outsourced to a third party. The backend service functions include:

• Database management
• Cloud storage and hosting
• Authentication and security settings
• Notifications
• Others

A common serverless foundation is adopted as the backend service. As a serverless design, the frontend application designed with serverless architecture principles can run on the backend service with a simple API integration.

Function as a Service (FaaS)

These are backend functions that allow you to run your software code as ephemeral containers for any backend service — without any administrative input. The function triggers the necessary backend service or responds to an API call from the frontend application components. Each function is loosely coupled and independent.

This sounds similar to the BaaS model but only FaaS allows for efficient implementation of microservices.

FaaS vs BaaS

• FaaS only allows the execution of events.
• BaaS manages the entire backend system.

The evolution of compute & infrastructure management

Ever since the advent of networked computing in the early 1970s, the function of infrastructure operations and management was seen as a cost-center and administrative challenge. This was particularly true for organizations operating on limited financial and HR resources.

Fast enough, the computing requirements for all business organizations increased exponentially. That means that developers and ITOps teams now spent most of their time…

• Keeping the servers running.
• Managing complexities of the large-scale networked computing environments.

These efforts rarely contributed to innovation, product design and development — but they were necessary to keep the business running.

In recent years, amid the explosive growth of automation tools and cloud computing services, the concept of serverless computing has caught the attention of resource-bound IT teams. Previously stuck focusing their efforts on ITOps functions such as data center management, server provisioning and manual configurations, they’ve now come to embrace serverless architecture & computing.

Consider the growth and development of the serverless architecture and computing industry:

• The market reached the $9 billion mark in 2022.
• A ten-fold growth of the serverless architecture market is expected by the year 2032, at a CAGR of 25% reaching $90 billion mark.

Principles of serverless architecture

OK, now that we’ve got the basics and trends down, let’s get into the more technical details. These services are incorporated into software design as part of the following serverless architecture principles:

1. Server abstraction. The hardware resources and backend services are decoupled from the front-end application layer. A user is not concerned with server management and scaling, but uses the resources on-demand on a subscription based pricing model.
2. Independent stateless functions. Every function is defined independently to perform its intended task in isolation from other functions. The tasks performed by these functions are also independent and completely managed by the governing functions.
3. Event-driven design. Events or a significant change in state triggers the function execution. Formally, the notification of an event may trigger the function operation, as most agents must be loosely coupled.
4. Functional front-end design. Backend tasks are reduced such that several similar front-end implementations can universally adopt the standardized backend functions. This allows faster execution of serverless functions and low computing requirements and therefore, low cost of using a BaaS or FaaS offering.
5. Third-party integration. Similarly, existing APIs and services should be reused to reduce the operational cost of serverless functions.

Benefits of serverless architecture

Serverless architecture design has useful applications when it comes to reducing the cost and complexity of ITOps tasks:

• Developers can focus on the front-end design without having to worry about the internal workings of the backend infrastructure.
• The service provider is entirely responsible for optimizing the backend infrastructure for cost, performance and security, in exchange for a usage-based pricing model.

Furthermore, when the application code is decoupled from the backend infrastructure, you can expect higher fault tolerance as the infrastructure service providers can dynamically distribute application workloads to highly available redundant servers in the cloud.

Most vendors offer built-in integrations that further reduce the burden of reconfiguring and redesigning the frontend to meet the specifications of multiple ITOps management solutions.

Challenges with serverless architecture

This flexibility however comes at a cost:

• Security sensitive application components may impose specific requirements on the underlying architecture and resources available to the software. Developers may need to manage and maintain servers internally, which limits the usability of serverless architecture for tightly controlled, security sensitive and strictly regulated industries.
• Developers may not be able to optimize all function call operations for speed, as each call introduces latency and not every request is handled efficiently by the function.
• A legacy application may need to be completely redesigned following the serverless architecture design principles. Refactoring or modifying some parts of the code may not suffice to work with serverless computing services.
• Vendors may impose performance limitations on serverless computing operations. Additionally, they may also introduce policies leading to a vendor lock-in.

Considerations and how to solve common serverless challenges

Let’s understand some common challenges and issues with serverless, so you can get a better sense of when and how to use it.

Cold starts and reducing latency

Serverless systems suffer from Cold Start latency, which refers to a delay in performance of a function at its initial state. This can happen under several circumstances:

• When first invoked from scratch or after an update
• When new resources are allocated or scaled from zero
• After it is terminated due to timeout or expiration conditions

The delay is observed commonly in serverless functions for real-time applications such as chat and streaming, and its duration depends on function size and dependencies, runtime environment and cloud provider optimizations.

Here are a few ways you can reduce the cold start latency in Lambda:

• Reduce function size and eliminate unused dependencies and code script. You can rely on code-splitting techniques and improve package dependency distributions for your initialization workflows.
• Transition to a warm start workflow where possible with concurrent provisioning of active function instances for incoming requests.
• Introduce asynchronous design patterns for functions that are not critical, introduce to reduce the impact of a cold start.
• Store pre-computed results in a cache that is rapidly accessible and reduces the cold-start function invocations.

State management

Functions are stateless by design, meaning they don’t persist variables or in-memory state between calls. So, they can’t ‘remember’ state information between function invocations. This limits complex workflows such as multi-step processes and user sessions.

So how do you manage state across invocations? The following state management techniques can help:

• Use external storage. Services such as AWS DynamoDB and Azure Cosmos can be used to store session state and temporary values. AWS S3 and Azure Blob can be used to store large datasets. AWS RDS and Aurora Serverless can be used to store transactional apps data and reporting information in relational databases. You can also use short-term caching, which can serve as a temporary external storage system.
• Pass function states through events. Specifically, this refers to the event-driven architecture where instead of storing states inside a function (which isn’t possible due to the stateless nature of the system), you encode state information into the event payload itself. This event (message, object, or request that triggers the next function) contains information on the state and context for inputs.
• Use a custom state management layer to aggregate and synchronize states across functions. This can serve as a centralized session service but is more complex and useful in advanced structures such as video game streaming.

Observability and debugging

Debugging in serverless environments is challenging due to the stateless, ephemeral, and dynamically scaling nature of functions. There’s no fixed infrastructure for traditional methods like SSH, as functions are short-lived and scale dynamically, making it difficult to trace individual requests passing through multiple hops. Therefore, traditional logging and monitoring tools fall short.

The solution here is robust observability. For typical observability tasks, you need logs, metrics and traces. This requires instrumentation of the application, which allows tools to collect all relevant information from the systems. For serverless applications, consider monitoring the following metrics:

• Error percentages during invocation
• Cold start incidents and latency
• Memory consumption
• Outliers and averages in function execution
• The four standard metrics: latency, errors, traffic, and saturation (LETS)

Certainly, metrics provide valuable information for troubleshooting incidents, but incident management and application performance management also require context

Logs provide this context. Logs record and describe what happens to system resources during the lifetime of a serverless function. This information can allow you to analyze a variety of key performance traits of your serverless architecture:

• Understand how the performance evolves across the function workflows.
• Identify bottleneck patterns between function calls and dependencies.
• Traffic flows for troubleshooting.
• Long-term performance, cost and application performance.

To achieve this, you need a dedicated toolset that can produce trace pillars and describe serverless transactional logs, like Splunk Observability Cloud. This information is then aggregated and analyzed using a predictive analytics system for real-time, proactive and preventive incident management.

Finding the right fit

One of the overlooked aspects of serverless architecture is its use case suitability. It is prone to latency issues, cost inefficiencies, and architectural complexity. Not every workload is a good fit for serverless functions, so should you invest in one?

Use cases for serverless

The following use cases align naturally with the characteristics of a serverless system — short-lived, scalable, stateless, and event-driven:

• Scheduled jobs that need to run periodically but do not require a full-time server
• REST APIs and microservices that are stateless and easily composable
• Data ingestion pipelines and functions that are triggered by Kafka events, database updates, or new files
• Real-time applications that require lite request-response and are latency-tolerant

Conversely, serverless functions are generally not well-suited for scenarios that struggle with timeout limits and cold starts, or require persistent state storage. These include:

Where to avoid serverless

In other scenarios that struggle with timeout limits and cold starts, and require persistent state storage such as:

• Any long-running process beyond the typical maximum execution time for serverless functions.
• High performance and low-latency APIs that are not invoked frequently.
• Video and game streaming and real-time chats that require persistent connections not supported natively by serverless architecture systems.
• Machine learning training jobs that require long-running GPU intensive batch or containerized workloads.
• Legacy systems that cannot be refactored into modern serverless alternatives without adding risk and complexity.

Summarizing serverless systems

Ultimately, serverless architecture offers a game-changing approach for building applications, promising easier development and reduced costs. However, truly harnessing its power means understanding its unique characteristics, navigating its challenges, and critically determining if it's the right fit for your specific workload. Making an informed decision will ensure you leverage serverless effectively, transforming your development process for the better.