You change an API field, your provider tests stay green, and a consumer breaks in an environment you did not test. That gap is what contract testing targets.
This piece compares Pact, a consumer-driven contract testing framework, with the approaches teams usually lean on instead: unit tests, end-to-end tests, schema validation and observability. You get stated criteria, a recommendation for specific situations, and the caveats.
Versions: no Pact version is pinned here. Check the version of the Pact library for your language in the official Pact documentation before you copy any setup. This article contains no code for the same reason: exact API names differ by language and are not reproduced here.
What Pact is, in one paragraph
Pact is a consumer-driven contract testing framework. It verifies the interactions between microservices without running all of the services at the same time.
In practice that means the consumer of an API states what it expects, and the provider is checked against those expectations. Pact offers a mock service and a DSL for the consumer project, plus interaction playback and verification. The "contract" is the agreement both sides must adhere to.
The important word is consumer-driven. Consumers specify the interactions they depend on, instead of the provider team guessing which parts of the API matter. A provider can then see which consumer expectations a change would violate.
The Pact documentation is also clear about limits. Pact does not replace unit tests, end-to-end tests, schema validation or observability. So the real question is not "Pact or the rest". It is which job each approach should do in your pipeline.
The options you are choosing between
These are the approaches teams compare when an API change breaks a consumer.
Unit tests. They check logic inside one service. They say nothing about whether another service still agrees with your request and response shapes.
End-to-end tests. They run a real flow across services. They exercise the whole system, but they need the services to be available together.
Schema validation. You describe messages with a schema and check payloads against it. It catches shape errors. It does not tell you which consumer depends on which field.
Observability. Logs, traces and metrics show what happens in running systems. They tell you after the fact, not before a merge.
Pact (consumer-driven contract tests). Each consumer records the interactions it expects. The provider is verified against them, without a full multi-service environment.
The next section sets out the criteria used to judge them.
Criteria used for the comparison
The criteria below follow from what Pact is documented to do and from how the other approaches work. The ratings are a reasoned judgement for a typical team, not a measurement.
- Needs all services running. Can you get a result without standing up every service?
- Who defines correctness. The provider, a shared schema, or the consumers that actually call the API?
- Moment of feedback. Before merge, in a shared environment, or in production?
- Shows which consumer a change breaks. Does a failure point at a specific dependent?
- Scope. Does it cover logic, interaction, whole flows or runtime behaviour?
A short word on criterion 4: this is the practical payoff of consumer-driven contracts. A schema can say a field is optional. Only the consumer knows it reads that field every time.
How the approaches score
| Criterion | Unit tests | End-to-end tests | Schema validation | Observability | Pact |
|---|---|---|---|---|---|
| Needs all services running | No | Yes | No | Yes (running system) | No |
| Who defines correctness | The service's own author | The flow's author | The schema owner | Whoever sets alerts | The consumers |
| Moment of feedback | Before merge | Shared environment | Before merge or at runtime | After release | Before merge |
| Shows which consumer breaks | No | Sometimes, indirectly | No | After the fact | Yes, by design |
| Scope | Logic in one service | Whole flows | Message shape | Runtime behaviour | Interactions between two services |
Two cells deserve a note. Schema validation can run at different points depending on how you wire it, so "before merge or at runtime" is a general statement. End-to-end tests can sometimes reveal the failing consumer, but you often have to trace it by hand.
The table shows no single winner. Pact fills the gap between unit tests and end-to-end tests: it covers the interaction between two services at a cost closer to a unit test than to a full environment.
How a consumer-driven check flows
The flow has three parts, taken from how Pact describes itself: a mock service and DSL for the consumer, interaction playback, and verification.
- The consumer project describes the interaction it expects, using the Pact DSL.
- The consumer's own tests run against the Pact mock service, so the real provider is not needed.
- The expected interactions form the contract.
- The provider replays those interactions against itself and verifies that its responses match.
The provider result is a pass or fail tied to the consumer expectations. That is why an API change can be stopped before it reaches a shared environment.
Setup commands, DSL method names and CI wiring are not covered in this article, because they differ by language. Use the official Pact documentation for your language.
Where each approach wins
Pact wins when you own many small services with several consumers per provider. A provider team gains a clear answer to "who depends on this field?". Consumer teams gain protection against silent changes.
End-to-end tests win when you need confidence that a business flow works across the whole system. Contract tests check interactions between two services. They do not prove the entire journey.
Schema validation wins when you need a cheap, shared definition of message shape, for example for a public API with consumers you cannot know. It is not consumer-driven, so it cannot tell you what a given consumer actually uses.
Unit tests win when the risk is inside one service. Keep them. Pact is not a replacement.
Observability wins when you need to see real behaviour after release. It complements pre-merge checks and does not stand in for them.
Recommendation by situation
You have several internal services and teams that deploy independently. Add Pact first for the most fragile or most shared provider. Keep your unit tests and a small set of end-to-end tests for critical flows.
You are slowed down by a large shared test environment. Move interaction checks from end-to-end tests into Pact. Pact verifies interactions without running all services, so it removes the need to bring everything up for each change. Keep a few end-to-end tests for the main journeys.
You publish an API to consumers you cannot identify. Lean on schema validation and good versioning. Consumer-driven contracts need consumers who write expectations, so they fit best where you can reach those teams.
You have two services and one team. You may not need Pact yet. Unit tests plus a small end-to-end suite can be enough. Revisit when a consumer is owned by another team.
You already have strong schemas. Keep them and add Pact on top for the consumers that matter most. The two answer different questions: schema validation asks if the message is well formed, Pact asks if this consumer still gets what it needs.
In every case, keep observability. It covers what pre-release tests cannot.
Caveats
- Pact is not a full test strategy. The documentation says it does not replace unit tests, end-to-end tests, schema validation or observability.
- It depends on consumers writing good expectations. A contract only protects what the consumer has described. If a consumer leaves out a field it uses, a provider change can still break it.
- It needs collaboration across teams. Consumers state expectations and providers verify them. Agree who owns that routine, or the contracts go stale.
- Language and tooling vary. Library names, methods and setup differ by language, and no version is pinned in this article. Read the official Pact documentation for yours.
- Topics this article does not cover: how to share contracts between repositories, how to gate deployments in CI, and message-based (non-HTTP) interactions. Check the official Pact documentation for each.
What we compared
- Needs all services running: can you get a result without standing up every service?
- Who defines correctness: the provider, a shared schema, or the consumers that call the API
- Moment of feedback: before merge, in a shared environment, or after release
- Shows which consumer a change breaks
- Scope: logic, interaction between two services, whole flows or runtime behaviour
Recommendation
Use Pact for the interactions between services that different teams own, and keep unit tests, a small set of end-to-end tests for critical flows, schema validation for public message shapes, and observability for running systems. If you have one team and two services, you may not need Pact yet. If consumers cannot be identified, favour schema validation and versioning.
Caveats
- Pact does not replace unit tests, end-to-end tests, schema validation or observability.
- A contract only covers what consumers have written down, so missing expectations leave gaps.
- It requires consumer and provider teams to agree on who maintains and verifies contracts.
- No Pact version is pinned here, and API names differ by language: use the official Pact documentation for your language.
- Contract sharing, CI gating and message-based interactions are not covered in this article.
Frequently asked questions
What is Pact?
Pact is a consumer-driven contract testing framework that verifies the interactions between microservices without running all the services.
Does Pact replace end-to-end tests?
No. Pact does not replace unit tests, end-to-end tests, schema validation or observability. It covers the interactions between two services, and you keep other test types for their own jobs.
What does consumer-driven mean?
Consumers specify the interactions they depend on. The provider is then verified against those expectations, so a provider change that violates a consumer is caught.
What does Pact give a consumer project?
A mock service and a DSL for the consumer project, plus interaction playback and verification.
Which Pact version should I use?
This article pins no version. Check the official Pact documentation for the current library for your language.
From Grokem: https://www.grokem.com/programming/software-architecture/microservices/pact-contract-testing-vs-end-to-end-tests-and-schema-validation-for-microservices









