Serverless Architecture Explained: Easier, Cheaper, FaaS vs BaaS & Evolving Compute Needs

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.

TLDR: 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.

What is Splunk?

This posting does not necessarily represent Splunk's position, strategies or opinion.