Rapid Web Development With Serverless Architecture

Summary

Serverless computing is a cloud computing model that allows developers to build and run applications without the need to manage or provision servers.

The cloud provider manages the underlying infrastructure in a serverless architecture, including server provisioning, scaling, and maintenance.

Developers can focus on writing code for their application's functionality while the cloud provider handles the operational aspects.

Static site generators (SSGs) are tools or frameworks that generate websites from plain HTML files or template languages like Nunjucks. Pages are generated during a build process to pre-render them before they are deployed on the server and subsequently served to the user.

This approach offers several benefits, including improved performance, security, and simplicity.

Benefits of Using Serverless Over Traditional Dynamic Pages

• Rapid application development

Templates can be created once and deployed across multiple projects with ease. All it takes is to clone a Git repo and customize the application metadata, icons, and visual styles.

• Consistent, Repeatable deployments

You can take the same code and deploy it across different platforms with little change to the configuration, unlike traditional deployments which have to match specific OS and application setups. The infrastructure is abstracted away.

• Split testing

Split testing, or A/B testing, allows marketing teams to compare different versions of a web page and measure conversion rates. You can read more about split testing on the Netlify Docs.

• Scalability

Serverless architecture can scale easily to serve content across a region with low latency and to handle multiple concurrent requests that would otherwise cripple a traditional deployment.

The use of content delivery networks ensures that content is served from a data center located close to the consumer. This has the impact of distributing requests across multiple zones.

The Architecture of a Serverless Website

• Serverless backend

This is the platform itself, such as Aptible, Netlify, or CloudFlare Pages. Although there are variations on how to deploy projects as you move between platforms, the underlying concept remains the same.

• APIs

Application programming interfaces provide a mechanism to connect application logic. They link client-side events to functions that carry out particular functions such as authentication.

• Functions

Functions are code that is run once an event is triggered. In contrast to traditional server deployments where you have idle virtual machines waiting for events, serverless functions are activated on a basis of need. There are stateless and stateful functions. Stateless functions do not track prior execution and keep no record of previous events.

In traditional architecture, a state refers to the contextual data stored on the server to retain information between requests and provide a consistent experience across multiple sessions.

• Database and Storage

There are several serverless databases such as FaunaDB. Simply put, it is a database-as-a-service offering that aligns with the concepts of serverless deployments: little or no server management, scalability, availability, and fault tolerance.

Database storage is entirely optional depending on the use case. For example, you do not need one to deploy a blog site.

Content Management

• GitHub for blog content

GitHub provides a consistent interface regardless of device type to edit markdown files. The markdown content can then be processed into HTML files for publishing.

• Integration with a headless CMS

What is a headless CMS? This is a content management system that is decoupled from the data. The presentation and the management of data are two distinct affairs. Some examples of headless CMS include Contentful and Sanity.

With a headless CMS, you can take your application and integrate a different CMS without affecting the content. A traditional CMS like WordPress makes this difficult since it is tightly coupled with the content.

Impact of Serverless Architecture On User Experience

• Fast page loads

Pages are generated during a build phase before deployment. First-time user interaction may be slow, but with the use of client-side caching, subsequent visits are significantly faster.

• Low latency

Since the application is a server from a CDN near the user’s physical location, the round trip time is reduced.