liveBook · Manning

Serverless computing

Also called function as a service, FaaS, serverless compute, serverless approach

Serverless computing is a cloud execution model in which a provider manages the underlying infrastructure and allocates resources for workloads, typically on demand.

How 11 Manning books explain it

Fast by Default

A serverless environment runs application code on managed infrastructure while abstracting server provisioning and capacity management from the application team.

How it is used
Guides case-by-case architecture choices between serverless components, microservices, and monoliths under scaling and cost constraints.
How deep it goes
Explains serverless through a detailed scaling-and-cost case study, without describing function implementation internals.
Examples
Uses a video-quality analysis service built with Step Functions, Lambda, and S3, then consolidated into a single process.
What you can do after
Evaluate/understand whether a workload’s coordination, scaling, and cost constraints favor serverless components or consolidation.

Read how Fast by Default explains serverless computing →

Server-Side WebAssembly

Serverless computing is a cloud model in which the provider manages infrastructure and server operations while applications run in response to events or requests.

How it is used
Positions Wasm as a runtime choice for scale-to-zero serverless workloads where cold starts recur.
How deep it goes
Explains performance rationale and adoption trade-offs, but does not provide a serverless implementation or deployment procedure.
Examples
Uses inactive workloads that scale to zero and comparative response-time measurements for Wasm and traditional serverless applications.
What you can do after
Evaluate/understand when Wasm’s startup, memory, portability, and ecosystem trade-offs suit a serverless workload.

Read how Server-Side WebAssembly explains serverless computing →

Shipping Go: Develop, deliver, discuss, design, and go again

Function as a Service is a cloud service model that executes individual functions on demand while hiding server and runtime management from the developer.

How it is used
Deploys a small API quickly for customer feedback without first operating dedicated servers.
How deep it goes
Works through a Go function entry point, test-gated deployment, public access, and endpoint verification; does not detail platform internals.
Examples
Uses a Go translation endpoint, GitHub Actions deployment YAML, a French translation test, and a public browser request.
What you can do after
Apply it via Google Cloud Functions and GitHub Actions to deploy and check a tested Go HTTP function.

Read how Shipping Go: Develop, deliver, discuss, design, and go again explains serverless computing →

Google Anthos in Action

A serverless workload is an application workload whose infrastructure provisioning and capacity management are handled by a platform rather than directly by its operator.

How it is used
Deploys containerized, event-driven workloads while shifting infrastructure provisioning, scaling, and serving concerns to a platform.
How deep it goes
Explains platform features, Kubernetes abstractions, tuning controls, deployment commands, and Cloud Run trade-offs without detailing Knative internals.
Examples
Uses Knative Service YAML, kubectl inspection, generated URLs, curl verification, Cloud Run, Anthos, and GPU-backed workloads.
What you can do after
Operate/configure a container-based Knative service, inspect its revisions and routes, verify its endpoint, and choose between Cloud Run and Anthos.

Read how Google Anthos in Action explains serverless computing →

Grokking Software Architecture

A cloud execution model in which the provider manages server infrastructure and allocates resources on demand.

How it is used
Positions serverless as a convenient deployment option for event-driven, bursty workloads without managing servers.
How deep it goes
Explains function lifecycle, statelessness, execution limits, cold starts, use cases, and portability tradeoffs, with a small handler listing.
Examples
Uses an AWS Lambda handler, a spiky API, welcome emails, nightly database cleanup, and shared tax calculation.
What you can do after
Evaluate deployment choices against traffic patterns, execution limits, operational convenience, and portability.

Read how Grokking Software Architecture explains serverless computing →

Microsoft Azure in Action

Serverless computing is a cloud execution model in which the provider manages server infrastructure while applications run code in response to events or requests.

How it is used
Positions serverless computing as a way to run focused application work and connect services without managing the underlying servers.
How deep it goes
Defines the model, compares hosting trade-offs, and sketches Azure workflows without detailing server infrastructure or a complete Cosmos DB trigger setup.
Examples
Uses photo resizing, workflow integration, and an Azure Function responding to Cosmos DB order changes as examples.
What you can do after
Apply it via Azure Functions and Logic Apps to assign focused tasks and workflows, while weighing Consumption-plan costs against other hosting options.

Read how Microsoft Azure in Action explains serverless computing →

Delivering Machine Learning Projects: From design to deployment

Serverless computing is a cloud execution model in which a provider manages infrastructure and servers while workloads run on demand.

How it is used
Deploys models for flexible, scalable, on-demand processing of bursty workloads.
How deep it goes
Compares workload fit, startup latency, pricing risk, and alternatives without detailing provider-specific implementation.
Examples
Uses AWS Lambda, Azure Serverless, GCP Cloud Functions, Lambda, Cloud Functions, Azure Functions, and Cloud Run.
What you can do after
Operate/configure a serverless model deployment by assessing latency, burstiness, pricing exposure, and migration options.

Read how Delivering Machine Learning Projects: From design to deployment explains serverless computing →

Effective Platform Engineering

Serverless is a cloud computing model in which a provider manages the underlying infrastructure and runs customer-supplied functions or workloads on demand.

How it is used
Deploys lightweight cloud functions quickly when standard vendor-managed orchestration is acceptable.
How deep it goes
Contrasts deployment speed and orchestration abstraction with Kubernetes extensibility, but does not detail serverless internals.
Examples
Uses JavaScript, Golang, Python, and Java functions alongside secret injection, code signing, traffic routing, and identity verification requirements.
What you can do after
Evaluate whether rapid function deployment outweighs the need for extensible governance and custom security controls.

Read how Effective Platform Engineering explains serverless computing →

Platform Engineering on Kubernetes

Serverless computing is an execution model in which the provider manages server infrastructure and applications run with capacity allocated on demand.

How it is used
Provides platform teams with on-demand containers, functions, autoscaling, and traffic controls for developer workloads.
How deep it goes
Explains Knative Services, autoscaling, scale-to-zero, resource generation, and traffic management, while deferring component internals.
Examples
Demonstrates a notification service manifest, kubectl inspection, generated URLs, and curl-based endpoint interaction.
What you can do after
Operate/configure a Knative Service, inspect its generated URL, and expose an application that scales with demand.

Read how Platform Engineering on Kubernetes explains serverless computing →

Quarkus in Action

A serverless platform is a cloud execution platform that automatically provisions, starts, scales, and stops application instances in response to requests.

How it is used
Deploys small Quarkus applications that automatically scale with requests and can avoid paying for idle capacity.
How deep it goes
Explains scaling, scale-to-zero, cold starts, native images, and Funqy basics, while deferring deeper Quarkus serverless integrations.
Examples
Uses Quarkus Funqy functions, including an annotated method that returns processed input.
What you can do after
Build it from scratch with Quarkus and Funqy, then target different FaaS providers through one function API.

Read how Quarkus in Action explains serverless computing →

Cloud Observability in Action

A serverless environment is an execution environment in which the provider manages the underlying servers and infrastructure for application code.

How it is used
Shifts infrastructure operations toward provider APIs and dashboards while outsourcing server maintenance.
How deep it goes
Explains access, patching, autoscaling, and observability boundaries, but stops short of implementation configuration.
Examples
Uses AWS Lambda monitoring in a provider console as its concrete serverless example.
What you can do after
Evaluate serverless suitability against operational effort, observability control, low-level requirements, and regulatory constraints.

Read how Cloud Observability in Action explains serverless computing →

Also covered in

What to know first

Related concepts

Questions about serverless computing

What is serverless computing?

Serverless computing is a cloud execution model in which a provider manages the underlying infrastructure and allocates resources for workloads, typically on demand.

Which Manning books explain serverless computing?

Fast by Default, Server-Side WebAssembly, Shipping Go: Develop, deliver, discuss, design, and go again, Google Anthos in Action, Grokking Software Architecture, Microsoft Azure in Action, Delivering Machine Learning Projects: From design to deployment, Effective Platform Engineering and 3 more.

What should I know before learning serverless computing?

Manning books that teach serverless computing usually introduce container, contract, microservice architecture and scalability first.

What kinds of serverless computing are there?

Kinds of serverless computing include AWS Lambda, Knative and OpenFaaS.

What are the parts of serverless computing?

Serverless computing includes scale to zero.

What is serverless computing also called?

Serverless computing is also called function as a service, FaaS, serverless compute or serverless approach.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.