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.
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.
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.
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.
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.
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
- Digital Twins in Action
- Amazon Web Services in Action, Third Edition: An in-depth guide to AWS
- Kafka for Architects
- 100 SQL Server Mistakes and How to Avoid Them
- DuckDB in Action
- Snowflake Data Engineering
- MongoDB 8.0 in Action, Third Edition
- Think Like a CTO
- Learn Docker in a Month of Lunches, Second Edition
- C# Concurrency: Asynchronous and multithreaded programming
- Enterprise RAGIn early access (MEAP)
- Logs and Telemetry
What to know first
- containerA software container is an isolated execution environment that packages an application and its dependencies, typically sharing the host operating-system kernel.
- contractA contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- microservice architectureMicroservice architecture is a software architectural style that structures an application as independently deployable services, typically organized around focused capabilities and communicating through defined interfaces.
- scalabilityScalability is the ability of a system or process to accommodate growth in workload, size, or demand while maintaining acceptable operation.
Related concepts
- AWS Lambdaincludes · AWS Lambda is Amazon Web Services’ managed serverless computing service for running code in response to events or requests without managing servers.
- cloud computinguses · Cloud computing is a model for on-demand network access to shared computing resources and services that can be provisioned and scaled as needed.
- containeruses · A software container is an isolated execution environment that packages an application and its dependencies, typically sharing the host operating-system kernel.
- Knativeincludes · Knative is an open-source, Kubernetes-based platform for deploying and operating serverless and event-driven workloads.
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.










