Client-server architecture
Client-server architecture is a distributed computing pattern in which clients request services or resources from servers that provide them.
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.
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.
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
- Fast Python: High performance techniques for large datasets
- The Cloud at Your Service: The when, how, and why of enterprise cloud computing
- The Design of Web APIs, Second Edition
- Grokking Concurrency
- Context EngineeringIn early access (MEAP)
- Grokking Web Application Security
- Build AI-Enhanced Web Apps
- The Well-Grounded Python Developer: How the pros use Python and Flask
What to know first
- HTTPHTTP is an application-layer protocol that defines request-and-response communication for transferring resource representations and related metadata between networked systems.
- RESTREST is an architectural style for distributed systems that organizes interactions around identifiable resources and their representations, using a uniform interface and constraints such as statelessness and cacheability.
- uriA URI (Uniform Resource Identifier) is a standardized sequence of characters that identifies an abstract or physical resource.
- deletionDeletion is an operation or request that removes an item, data, or resource from a collection or system.
Related concepts
- RESTused by · REST is an architectural style for distributed systems that organizes interactions around identifiable resources and their representations, using a uniform interface and constraints such as statelessness and cacheability.
- MCPused by · The Model Context Protocol is an open standard that defines how AI applications connect with external tools, data sources, and other contextual resources.
- dhcpused by · The Dynamic Host Configuration Protocol (DHCP) is a network protocol that automatically assigns devices IP addresses and related configuration information.
- A2Aused by · A2A is an open interoperability protocol that enables software agents to discover, communicate, and coordinate with one another across systems.
- distributed systemkind of · A distributed system is a computing system whose components run across multiple networked processes or machines and coordinate through communication.
- Dockerincludes · Docker is a platform and toolset for building, distributing, and running applications in containers.
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.







