liveBook · Manning

Client-server architecture

Also called client-server model

Client-server architecture is a distributed computing pattern in which clients request services or resources from servers that provide them.

How 8 Manning books explain it

Building Web APIs with ASP.NET Core

The client-server approach separates client user-interface concerns from server-side data and application concerns.

How it is used
Separates client user-interface concerns from web API data concerns as a REST constraint.
How deep it goes
Defines the separation and applies it to HTTP responses and CORS configuration, without detailing client or server internals.
Examples
Uses controllers, Minimal APIs, and ASP.NET Core CORS policies to show how independent clients reach an API.
What you can do after
Operate/configure client access to an ASP.NET Core API with CORS middleware or endpoint policies while keeping responses client-independent.

Read how Building Web APIs with ASP.NET Core explains client-server architecture →

Acing the CCNA Exam: Volume 2 Advanced Networking and Security

Client-server architecture is a distributed-system pattern that separates clients requesting services from servers providing them.

How it is used
Deploys a reusable pattern for DHCP services, file transfer, and REST APIs.
How deep it goes
Defines roles, request flow, statefulness, and examples, but leaves implementation details to each protocol.
Examples
Uses DHCP DORA exchanges, Cisco IOS DHCP pools, REST requests, and TFTP transfers between PCs and network devices.
What you can do after
Apply it to recognize service roles, trace request flows, and configure basic Cisco IOS DHCP behavior.

Read how Acing the CCNA Exam: Volume 2 Advanced Networking and Security explains client-server architecture →

Grokking Software Architecture

A distributed architecture that separates clients that initiate requests from servers that provide resources or processing.

How it is used
Separates request-initiating clients from servers that provide resources or processing across a network boundary.
How deep it goes
Defines the model and explains its network boundary, scaling rationale, and team specialization without detailing implementation internals.
Examples
Uses a dumb terminal and mainframe, a bartender with amnesia, and a million-user scaling scenario.
What you can do after
Evaluate the tradeoff between network complexity and the scaling and specialization enabled by separating clients and servers.

Read how Grokking Software Architecture explains client-server architecture →

Building User-Friendly DSLs

A software architecture in which clients request services or data from a server that provides them.

How it is used
Deploys centralized synchronization for real-time collaborative editing across multiple devices.
How deep it goes
Explains client updates, server broadcasting, latency conflicts, rollback, and first-arrival resolution, while deferring CRDT-based conflict prevention.
Examples
Uses shared document editing, keystroke-sized changes, rollback, and structured property-update records.
What you can do after
Evaluate/understand centralized synchronization and first-arrival conflict handling in collaborative editing.

Read how Building User-Friendly DSLs explains client-server architecture →

Robotics for Programmers

The client-server model organizes communication so that clients request services and servers provide them.

How it is used
Coordinates sporadic request-response operations between ROS nodes when the client needs confirmation of server activity.
How deep it goes
Explains RPC flow, communication cardinality, blocking behavior, and asynchronous Python implementation, but not middleware internals.
Examples
Uses a ROS 2 SetBool service, Python server and client nodes, command-line invocation, and the RQt Service Caller plugin.
What you can do after
Build it from scratch as a ROS 2 service server or client using typed requests, callbacks, asynchronous calls, and command-line testing.

Read how Robotics for Programmers explains client-server architecture →

Podman in Action: Secure, rootless containers for Kubernetes, microservices, and more

A client-server application is software organized into clients that request services from a separate server process.

How it is used
Contrasts daemon-mediated container execution with direct fork/exec execution to clarify process ownership, complexity, and auditing.
How deep it goes
Traces client, daemon, containerd, OCI runtime, process ancestry, and loginuid effects, but stops short of daemon implementation internals.
Examples
Uses architecture diagrams, container process inspection, loginuid output, and audit records for host-file modification.
What you can do after
Diagnose process ancestry and user attribution by inspecting container PIDs, loginuid values, and audit records.

Read how Podman in Action: Secure, rootless containers for Kubernetes, microservices, and more explains client-server architecture →

Rust Servers, Services, and Apps

The client-server model is a computing architecture in which clients request data or computation from dedicated servers that manage resources.

How it is used
Structures web services and distributed systems by separating resource requests from centralized data and computation management.
How deep it goes
Defines roles, authorization, REST constraints, and request methods, but stops short of implementation internals.
Examples
Uses web browsers, web servers, REST resources, HTTP-style methods, and weather, course, user, and shipment APIs.
What you can do after
Evaluate request flows by identifying client responsibilities, server responsibilities, authorization, resources, and state-changing operations.

Read how Rust Servers, Services, and Apps explains client-server architecture →

Build a Multi-Agent System (from Scratch)

Client-server architecture is a system pattern in which clients request services from servers that provide them.

How it is used
Connects AI applications to external tools or agents through client requests to servers.
How deep it goes
Details MCP tool calls and transports, plus A2A discovery and task exchanges; leaves A2A task logic unspecified.
Examples
Uses MCP tool calls and A2A agent discovery and task dispatch, including a data-preprocessing task.
What you can do after
Apply MCP or A2A to connect an application with remote tools or agents through protocol-defined exchanges.

Read how Build a Multi-Agent System (from Scratch) explains client-server architecture →

Also covered in

What to know first

Related concepts

Questions about client-server architecture

What is client-server architecture?

Client-server architecture is a distributed computing pattern in which clients request services or resources from servers that provide them.

Which Manning books explain client-server architecture?

Building Web APIs with ASP.NET Core, Acing the CCNA Exam: Volume 2 Advanced Networking and Security, Grokking Software Architecture, Building User-Friendly DSLs, Robotics for Programmers, Podman in Action: Secure, rootless containers for Kubernetes, microservices, and more, Rust Servers, Services, and Apps and Build a Multi-Agent System (from Scratch).

What should I know before learning client-server architecture?

Manning books that teach client-server architecture usually introduce HTTP, REST, uri and deletion first.

What kinds of client-server architecture are there?

Kinds of client-server architecture include Docker.

What is client-server architecture a kind of?

Client-server architecture is a kind of distributed system. A distributed system is a computing system whose components run across multiple networked processes or machines and coordinate through communication.

What is client-server architecture also called?

Client-server architecture is also called client-server model.

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.