liveBook · Manning

Breaking change

Also called backward-incompatible change

A breaking change is a modification to an interface, behavior, format, configuration, or contract that can prevent existing consumers from working correctly without changes.

How 7 Manning books explain it

The Design of Web APIs, Second Edition

A non-backward-compatible change is an API change that can cause existing consumers to fail or behave incorrectly.

How it is used
Checks whether API modifications will disrupt existing consumers before deployment.
How deep it goes
Defines breaking changes and works through data, path, and operation-flow failures, including silent failures and migration trade-offs.
Examples
Uses product prices, renamed resource paths, and an added money-transfer validation step to expose different consumer failures.
What you can do after
Evaluate/understand it by identifying affected consumers and weighing backward-compatible alternatives against the value and cost of migration.

Read how The Design of Web APIs, Second Edition explains breaking change →

Microservices Patterns, Second Edition

A modification to an interface or behavior that can invalidate existing consumers or require them to change.

How it is used
Coordinates incompatible API evolution across independently deployed services and consumers.
How deep it goes
Explains side-by-side versions, client migration, dual publishing, compatibility checks, and contract testing.
Examples
Uses versioned REST paths, versioned messaging channels, dual-published events, and an Order-to-Consumer service migration.
What you can do after
Apply it via API versioning, staged client migration, compatibility checks, and temporary support for old contracts.

Read how Microservices Patterns, Second Edition explains breaking change →

Automating API Delivery

A breaking change is an API modification that can cause existing consumers or integrations to stop working.

How it is used
Uses compatibility checks, versioning, and policy to manage API evolution for developers, product owners, and API consumers.
How deep it goes
Defines compatibility, enumerates OpenAPI cases, demonstrates oasdiff commands, and defers organization-specific classifications to published policy.
Examples
Uses endpoint removal, required request changes, schema tightening, enum changes, oasdiff output, and deprecated endpoint sunset.
What you can do after
Apply oasdiff checks to OpenAPI changes, interpret failures, and decide when versioning, coordination, or sunset policy is required.

Read how Automating API Delivery explains breaking change →

Google Anthos in Action

A breaking change is a modification to an interface or behavior that can cause existing dependent clients or services to fail.

How it is used
Uses standard service contracts to identify changes that may affect dependent services during application modernization.
How deep it goes
Frames detection at the contract boundary without detailing compatibility rules or migration procedures.
Examples
Uses authentication, authorization, and logging as capabilities that teams can extract and rewrite incrementally.
What you can do after
Evaluate contract boundaries to identify changes that may affect dependent services during incremental modernization.

Read how Google Anthos in Action explains breaking change →

Go in Action, Second Edition

A breaking change is a modification that can prevent existing consumers from continuing to work without updates.

How it is used
Guides module release decisions and communicates whether consumers can adopt a version without updating their code.
How deep it goes
Defines SemVer impact categories and traces dependent go.mod updates, without detailing how to identify every incompatible API modification.
Examples
Uses domain/v0.0.1, a hypothetical domain/v2.0.0 transition, and independent api/v1.1.0 and worker/v1.1.0 Git tags.
What you can do after
Operate/configure Go module releases by selecting SemVer increments and updating dependent module requirements after incompatible changes.

Read how Go in Action, Second Edition explains breaking change →

Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu

A breaking change is a software change that makes previously valid code, configuration, or interfaces require modification to function correctly.

How it is used
Guides infrastructure teams in deciding when and how to change module interfaces without leaving users unprepared.
How deep it goes
Explains causes, batching, provider cascades, tests, and upgrade notes, but gives no detailed migration procedure beyond documenting interface changes.
Examples
Uses insecure defaults, renamed variables, provider requirements, removed deprecated features, major-release branches, and upgrade notes as examples.
What you can do after
Apply it by grouping compatible breaking changes, documenting migration instructions, branching major-release work, and using tests to detect regressions.

Read how Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu explains breaking change →

Building Web APIs with ASP.NET Core

A breaking change is a modification that can cause existing clients or system integrations to stop working correctly.

How it is used
Explains how API evolution can disrupt existing clients and how versioning can reduce immediate migration pressure.
How deep it goes
Defines common causes, describes parallel API versions, and evaluates complexity, security, and architectural trade-offs.
Examples
Uses regressions, interface modifications, type mismatches, vulnerable legacy endpoints, and simultaneous API versions as examples.
What you can do after
Evaluate whether API versioning adequately contains client disruption without creating unacceptable duplication, security exposure, or architectural constraints.

Read how Building Web APIs with ASP.NET Core explains breaking change →

Also covered in

What to know first

Related concepts

Questions about breaking change

What is breaking change?

A breaking change is a modification to an interface, behavior, format, configuration, or contract that can prevent existing consumers from working correctly without changes.

Which Manning books explain breaking change?

The Design of Web APIs, Second Edition, Microservices Patterns, Second Edition, Automating API Delivery, Google Anthos in Action, Go in Action, Second Edition, Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu and Building Web APIs with ASP.NET Core.

What should I know before learning breaking change?

Manning books that teach breaking change usually introduce contract, attribute, client and GraphQL first.

What is the difference between breaking change and backward compatibility?

A breaking change is a modification to an interface, behavior, format, configuration, or contract that can prevent existing consumers from working correctly without changes. Backward compatibility is the property of a newer or changed system remaining usable by existing clients, code, data, or integrations that depend on earlier interfaces or behavior.

What is breaking change also called?

Breaking change is also called backward-incompatible change.

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.