liveBook · Manning

Shared-nothing architecture

A shared-nothing architecture is a system design in which processing units have independent resources and do not share mutable state, communicating through explicit interfaces.

How 3 Manning books explain it

Server-Side WebAssembly

Shared-nothing is an architecture in which interacting execution units do not share memory or other mutable state and communicate through explicit interfaces.

How it is used
Uses explicit imports and exports to connect isolated Wasm components, hosts, and runtimes without shared memory.
How deep it goes
Explains memory copies and opaque resource handles, while deferring deeper resource-table treatment to a later hands-on example.
Examples
Demonstrates a secret-store get call and a SmartCMS guest using a key-value-store interface.
What you can do after
Evaluate/understand how interface-only component boundaries contain access and permit targeted replacement of patched components.

Read how Server-Side WebAssembly explains shared-nothing architecture →

PostgreSQL Mistakes and How to Avoid Them

A shared-nothing architecture gives each node independent storage and processing resources rather than sharing them directly with other nodes.

How it is used
Frames PostgreSQL replication and high availability around independently operated database nodes.
How deep it goes
Explains node independence, replication origins, feedback loops, key collisions, and schema-divergence failures.
Examples
Uses publications, subscriptions, replicated tickets, duplicate identity keys, and a renamed column to expose failure modes.
What you can do after
Evaluate multi-master designs by tracing replication origins, conflicts, feedback loops, and schema compatibility.

Read how PostgreSQL Mistakes and How to Avoid Them explains shared-nothing architecture →

The Cloud at Your Service: The when, how, and why of enterprise cloud computing

A shared-nothing architecture is a distributed system design in which components have independent resources and communicate without sharing state.

How it is used
Frames independent components as a way to scale database workloads and web applications across cloud instances.
How deep it goes
Defines independence and illustrates database partitioning, but leaves implementation mechanics largely unspecified.
Examples
Uses odd/even user-ID shards and Ruby on Rails application instances as concrete examples.
What you can do after
Evaluate whether independent shards or application instances fit workloads needing higher throughput or cloud resource expansion.

Read how The Cloud at Your Service: The when, how, and why of enterprise cloud computing explains shared-nothing architecture →

Also covered in

Related concepts

Questions about shared-nothing architecture

What is shared-nothing architecture?

A shared-nothing architecture is a system design in which processing units have independent resources and do not share mutable state, communicating through explicit interfaces.

Which Manning books explain shared-nothing architecture?

Server-Side WebAssembly, PostgreSQL Mistakes and How to Avoid Them and The Cloud at Your Service: The when, how, and why of enterprise cloud computing.

What kinds of shared-nothing architecture are there?

Kinds of shared-nothing architecture include PostgreSQL replication.

What is shared-nothing architecture a kind of?

Shared-nothing architecture is a kind of master/slave deployment. A master/slave deployment is a broker arrangement in which a primary broker is active and one or more standby brokers can take over if it fails.

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.