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.
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.
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.
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.
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
- "Looks Good to Me"
- Contract Testing in Action
- Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform
- PostgreSQL Mistakes and How to Avoid Them
- API Design Patterns
- CSS in Depth, Second Edition
- Crack Any Codebase with AIIn early access (MEAP)
- Grokking Software ArchitectureIn early access (MEAP)
- Rust Servers, Services, and Apps
- Django in Action
- Practical Automation with PowerShell: Effective scripting from the console to the cloud
- gRPC Microservices in Go
What to know first
- contractA contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- attributeAn attribute is a named property or piece of information associated with an entity, object, or structured data item.
- clientA client is a person, organization, device, or software component that receives or uses a product, service, resource, or functionality provided by another party or system.
- GraphQLGraphQL is a query language and execution specification for APIs that lets clients request and manipulate data through a schema.
Related concepts
- backward compatibilitycontrasts with · 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.
- versioningaddressed by · Versioning is the practice of assigning or maintaining identifiable revisions of artifacts over time so their changes, histories, or compatibility can be tracked.
- non-breaking changecontrasts with · A non-breaking change modifies an interface while preserving the behavior or compatibility expected by existing clients and integrations.
- api modificationproduced by · An API modification is a change to an existing application programming interface that can alter its availability, behavior, or compatibility with existing code.
- API versionuses · An identifier that distinguishes a particular revision of an API’s interface, contract, or behavior.
- review processaddressed by · A review process is a structured evaluation of work, performance, artifacts, or proposals against relevant criteria to assess quality, progress, correctness, or suitability.
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.






