For Example,

Imagine a website that sells concert tickets.

When a user types the website address into a browser window, the browser sends a request to the backend server, which responds with the website data.

The user will then see the frontend of the website,

which can include content such as text, images, and form fields for the user to fill out.

The user can then interact with one of the form fields on the frontend to search for their favorite musical act. When the user clicks “submit”, this will trigger another request to the backend.

The backend code checks its database to see if a performer by that name exists, and if so, when they are next playing

and how many tickets are available. The backend will then pass that data back to the frontend, and the frontend will display the results in a way that makes sense to the user.

What Types of Backend Services Can Serverless Computing Provide?

Most serverless providers offer database and storage services to their customers. FaaS (Function as a Service) allows developers to execute small pieces of code at the edge of the network.

With FaaS, developers can create a modular architecture, making the codebase more scalable without spending resources on maintaining the underlying backend.

What are the Advantages of Serverless Computing?

• Lower costs – Serverless computing is generally cost-effective, as traditional cloud backend service providers (server allocation) often result in the user paying for unused space or idle CPU time.
• Simplified scalability – Developers using a serverless architecture don’t need to worry about policies for scaling their code. The serverless vendor handles all scaling on demand.
• Simplified backend code – With FaaS, developers can create simple functions that independently perform a single purpose, such as making an API call.
• Faster time to market – Serverless architecture can significantly cut time to market. Instead of needing a complex deployment process to roll out bug fixes and new features, developers can add and modify code on a piecemeal basis.

How Does Serverless Compare to Other Cloud Backend Models?

There are two technologies often combined with serverless computing: Backend-as-a-Service and Platform-as-a-Service. While they share similarities, these models do not necessarily fulfill serverless requirements.

Backend-as-a-Service (BaaS) is a service model where a cloud provider offers backend services such as data storage, so developers can focus on writing frontend code.

However, while serverless applications are event-driven and run at the edge, BaaS applications may not fulfill either of these requirements.

Also:

Platform as a Service (PaaS) is a model where developers essentially rent all the tools needed to develop and deploy applications from a cloud provider, including things like operating systems and middleware.

However, PaaS applications are not as easily scalable as serverless applications.

PaaS doesn’t necessarily run at the edge and often has a notable startup latency that is absent in serverless applications.

Infrastructure as a Service (IaaS) is an umbrella term for cloud vendors that host infrastructure on behalf of their customers. IaaS providers may offer serverless functionality, but the terms are not synonymous.

What is the Next Step for Serverless?

Serverless computing continues to evolve as serverless service providers come up with solutions to overcome some of its drawbacks. One such barrier is cold starts.

Typically when a particular serverless function hasn’t been called for a period of time, the provider shuts down the function to save energy and avoid over-provisioning.

The next time a user runs an application that calls this function, the serverless provider will have to start it up again and begin hosting the function once more.

This startup time adds significant latency, which is known as a “cold start.”

Also:

Once the function is running, it will be served much more quickly on subsequent requests (warm starts),

but if the function isn’t requested again for a period of time, it will go dormant once more.

This means the next user who requests this function will experience a cold start.

Until fairly recently, cold starts were considered a necessary trade-off of using serverless functions.

Additionally:

During a TLS handshake. Since worker functions spin up at the edge in a very short period of time,

even shorter than the time needed to complete the handshake, the result is a FaaS system with no cold starts.

As more and more drawbacks of using servers are addressed and edge computing grows in popularity, we can expect to see widespread adoption of serverless architecture.