We need to version our APIs effectively. What is the best strategy or tool for API versioning?

A good API versioning strategy is usually not just picking a version format—it is establishing rules for when to version, how clients select versions, how long versions live, and how you migrate users.

For most public REST APIs, a strong default is:

1. Use URL path versioning for major versions
2. Follow semantic versioning internally
3. Prefer backward-compatible changes
4. Automate contract checks and documentation
5. Have a clear deprecation policy

Google Cloud Documentation Google Cloud## Recommended strategy

1. Version only breaking changes

Avoid creating a new API version for every release.

Good:

GET /api/v1/users/123

Later:

GET /api/v2/users/123

when you introduce a breaking change, such as:

• Removing a field
• Renaming a field
• Changing a response structure
• Changing authentication behavior
• Changing required parameters

Non-breaking changes should usually remain in the same major version:

• Adding optional fields
• Adding new endpoints
• Adding optional query parameters
• Performance improvements

Microsoft Learn ASOasis Tech

2. Use URL-based major versions for most REST APIs

Example:

https://api.example.com/v1/orders
https://api.example.com/v2/orders

Advantages:

• Easy to understand
• Visible in logs and debugging
• Works well with gateways, caches, and documentation
• Simple for external developers to test

Alternatives:

Header versioning

GET /orders
Accept: application/vnd.company.v2+json

Useful for highly controlled ecosystems, but less discoverable.

Query versioning

GET /orders?version=2

Generally less preferred because versions can be accidentally omitted or cached incorrectly.

GitDoc Apidoke

3. Maintain separate API contracts

Keep versioned specifications:

/api-specs
   /v1
      openapi.yaml
   /v2
      openapi.yaml

Use OpenAPI as the source of truth for:

• Documentation
• SDK generation
• Contract testing
• Change detection

Google Cloud Documentation Cadence

Useful tools

API specification and documentation

• openapis.org — Define API contracts and generate documentation/tools.
• swagger.io — Interactive API documentation.

Breaking-change detection

• github.com — Detects breaking changes between OpenAPI specs.
• github.com — Enforces API design rules.

API gateways and lifecycle management

• konghq.com — Routing, authentication, rate limiting, version management.
• cloud.google.com — Enterprise API lifecycle management.
• aws.amazon.com — Managed API gateway with version/stage management.

---

A practical lifecycle

Example:

v1 launch

/api/v1/customers

Publish:

• OpenAPI spec
• SDKs
• Documentation
• Support policy

v2 development

Run:

• Compatibility checks
• Migration tests
• Client usage analysis

Deploy both:

/api/v1/customers   ← existing clients
/api/v2/customers   ← new clients

Deprecation

Announce:

• Sunset date
• Migration guide
• Replacement endpoints

Track remaining v1 traffic, then remove it.

---

My default recommendation

For most companies:

This gives you a system that scales without ending up maintaining dozens of API versions forever.

When it comes to API versioning, there is no single "silver bullet," but industry consensus heavily favors URI Path Versioning for its balance of simplicity and transparency, paired with a strict deprecation policy.

Comparison of API Versioning Strategies

• URI Path Versioning (/v1/resources)
  • How it works: The version number is embedded directly in the URL path.
  • Pros: Extremely clear, highly visible, easy to test in a web browser or terminal, and trivial to route at the API gateway level. Caching is straightforward because each URL is unique.
  • Cons: Strictly speaking, it violates pure RESTful hypermedia principles (HATEOAS) because the resource's identifier changes per version.
• Header Versioning (Accept: application/vnd.mycompany.v1+json)
  • How it works: The version is passed via custom request headers (often using media type specification).
  • Pros: Keeps URLs clean and adheres closely to REST/HATEOAS resource identity rules.
  • Cons: Poor discoverability. You cannot simply copy-paste a URL into a browser or an external tool to test it quickly; testing requires setting specific header configurations.
• Query Parameter Versioning (/resources?version=1)
  • How it works: Passed as a standard query string parameter.
  • Pros: Easy to implement and allows for default fallback versions cleanly.
  • Cons: Easily forgotten or messy in logs, and difficult to manage with standard caching mechanisms compared to path-based routing.

The Verdict: Which should you choose?

To help narrow down the exact setup for your stack, tell me:

• Are you building a public developer-facing API or an internal microservices architecture?
• What framework or API Gateway (e.g., Kong, AWS API Gateway, Express, FastAPI) are you using?

For most teams, the best strategy is contract-first API versioning with explicit major versions, while avoiding versions for backward-compatible changes.

Microsoft and Google both recommend essentially this model: preserve backward compatibility where possible, and introduce a new version when you genuinely make a breaking change.

Recommended strategy

1. Version only breaking changes

Treat these as non-breaking:

• Adding a new endpoint
• Adding an optional request field
• Adding a response field, assuming clients tolerate unknown fields
• Adding optional query parameters
• Performance/internal implementation changes

These should normally remain in v1.

Treat these as breaking:

• Removing or renaming a field
• Changing a field's type or meaning
• Removing an endpoint
• Making an optional parameter required
• Changing existing behavior in a way that can break clients

Those warrant v2.

2. Put the major version in the URL

For REST APIs, I'd recommend:

GET /api/v1/customers/123
GET /api/v2/customers/123

rather than:

GET /api/customers/123?version=2

Path-based versioning is straightforward, highly visible, easy to route, and well supported by API gateways. Azure API Management and Google Cloud both support/recommend path-based major-version approaches.

I would not put 1.2.3 in the public URL. Use the major version for client selection:

/v1
/v2

while internally you can use semantic versions such as 1.4.2 for releases. Microsoft specifically cautions against making clients select overly granular versions because it creates too many compatibility targets.

3. Use OpenAPI as the contract

Keep an OpenAPI specification in source control:

api/
  openapi-v1.yaml
  openapi-v2.yaml

Then put the API contract through CI/CD.

A particularly good setup is:

OpenAPI spec
     ↓
Breaking-change check
     ↓
Contract tests
     ↓
Generated SDKs / documentation
     ↓
Deployment

This makes versioning a process enforced by tooling, rather than something developers have to remember manually. Microsoft's engineering guidance also recommends keeping generated OpenAPI definitions under version control and using them as contracts.

4. Automate breaking-change detection

This is probably the most important tool decision.

Use an OpenAPI diff/compatibility checker in CI. For example, configure your pipeline so that:

PR changes OpenAPI
        ↓
Compare against production spec
        ↓
Breaking change?
   ↙          ↘
 YES           NO
 ↓             ↓
Require v2     Allow v1

This catches things like removing properties, changing types, changing required fields, etc., before they reach production.

5. Manage versions through an API gateway

If you have many APIs, an API management layer becomes useful.

Good choices include:

• Azure API Management — particularly good if you're already on Azure; it supports multiple versions, version sets, routing, policies, and a developer portal.
• AWS API Gateway — natural choice for AWS-centric environments.
• Google Cloud API Gateway / Apigee — strong choice for Google Cloud and larger API programs.
• Kong — good if you want a more infrastructure/platform-oriented gateway.
• OpenAPI + CI tooling without a gateway — perfectly reasonable for smaller/internal systems.

The gateway isn't what solves versioning, though. Your API contract + compatibility rules + lifecycle policy are the important pieces.

A policy I'd recommend

For a typical organization, I'd establish something like:

Then establish a lifecycle:

v1 → Active → Deprecated → Sunset → Removed
v2 → Active

Don't keep old versions alive indefinitely. Multiple versions increase development, testing, and operational costs, so establish an explicit deprecation period and migration process.

My preferred stack

If I were designing this from scratch today, I'd use:

REST + OpenAPI + /vN major versions + automated OpenAPI breaking-change checks + API gateway + explicit deprecation policy.

For example:

/api/v1/orders
/api/v1/customers
/api/v2/orders

with:

OpenAPI
   ↓
Git
   ↓
CI compatibility check
   ↓
Contract tests
   ↓
API gateway
   ↓
Production

And I'd keep semantic versioning for the implementation/release, but expose only the major API contract version to consumers. This gives you predictable evolution without forcing clients to care about every patch release.

If you tell me whether these are internal microservice APIs, public/customer-facing APIs, or partner APIs, and whether you're on AWS, Azure, GCP, or Kubernetes, I can recommend a concrete versioning architecture and toolchain.

Use an OpenAPI diff/compatibility checker in CI. For example, configure your pipeline so that:

PR changes OpenAPI
        ↓
Compare against production spec
        ↓
Breaking change?
   ↙          ↘
 YES           NO
 ↓             ↓
Require v2     Allow v1

This catches things like removing properties, changing types, changing required fields, etc., before they reach production.

5. Manage versions through an API gateway

If you have many APIs, an API management layer becomes useful.

Good choices include:

The best and most widely adopted strategy for API versioning is URI Path Versioning (e.g., /v1/resource ), combined with semantic major versioning to clearly signal breaking changes.

Strategies for API Versioning

• URI Path Versioning : Embeds the major version directly in the URL path (e.g., /api/v1/users ). It is the most transparent, easiest to test in a browser or logs, and universally supported by API gateways.
• Request Header Versioning : Passes a custom header like X-API-Version: 1 or Accept: application/vnd.myapi.v1+json . It keeps URLs clean, but is harder to test quickly and less visible to casual users.
• Query Parameter Versioning : Appends a version flag to the request (e.g., /api/users?version=1 ). This is simple to implement but goes against standard RESTful design practices.

Top Tools for Managing API Versions

Best Practices

• Only use major versions : Increment your public version (like v1 to v2 ) only when introducing breaking changes (e.g., removing a field or changing data types). Use non-breaking additions freely without bumping the version.
• Plan for deprecation : Clearly document deprecation timelines and notify consumers well before retiring an old version.

If you tell me whether your API is public or internal and which gateway or framework you use, I can recommend a specific configuration setup.

Choosing the "best" API versioning strategy depends on how you balance developer experience, cacheability , and maintenance overhead . There is no single silver bullet, but industry standards lean heavily toward specific approaches.

Top API Versioning Strategies

• URI Path Versioning : Embedding the version directly in the URL path (e.g., /api/v1/resources).
  • Pros : Highly visible, extremely easy to test in a browser or logs, and simple to route at the load balancer or API gateway level.
  • Cons : Technically violates strict RESTful design principles because the URL should identify a resource, not a representation or version of it.
• Request Header Versioning : Using a custom header (e.g., X-API-Version: 1 or Accept: application/vnd.company.v1+json).
  • Pros : Keeps the URL clean and adheres more strictly to REST principles regarding content negotiation.
  • Cons : Harder to test quickly in a standard browser, requires clients to explicitly configure headers, and can complicate caching layers if not handled carefully.
• Query Parameter Versioning : Passing the version as a parameter in the query string (e.g., /api/resources?version=1).
  • Pros : Easy to implement and allows for default fallback values easily.
  • Cons : Messy URLs, problematic for caching (many CDNs ignore or mishandle query parameters for caching static responses), and generally discouraged for public-facing enterprise APIs.

Which is Best?

For 90% of use cases, URI Path Versioning is considered the most practical and widely adopted strategy. It offers the lowest friction for consumers, the easiest debugging, and seamless integration with modern API gateways. Use Header Versioning only if your architecture relies heavily on strict REST semantic purity and sophisticated API management infrastructure.

Essential Best Practices

1. Date-Based Versioning Alternative : Consider using calendar-based versioning (e.g., 2026-06-01 ) instead of semantic versioning (v1, v2 ) if you make frequent, incremental updates rather than breaking overhauls. Major companies like Stripe use this approach effectively.
2. Never Break Backward Compatibility : Treat breaking changes as a last resort. Prefer additive changes (adding new optional fields, new endpoints) so older clients don't break.
3. Establish a Clear Deprecation Policy : Communicate deprecation timelines clearly (e.g., 6 to 12 months notice) and include a Deprecation response header to warn consumers programmatically.
4. Leverage API Gateways : Use an API gateway (like Kong, AWS API Gateway, or Apigee) to handle routing, transformation, and deprecation warnings rather than hardcoding complex version logic into your core microservices.

If you'd like, tell me:

• What is your current tech stack or API architecture (REST, GraphQL, gRPC)?
• Are these APIs public-facing or internal to your organization?

I can help you design a specific deprecation workflow or gateway routing rule for your setup.

A good API versioning strategy is less about picking a version number format and more about defining how you evolve contracts without breaking consumers. A practical approach for most teams is:

1. Version only on breaking changes
2. Use a clear major-versioning scheme
3. Maintain old versions during migration
4. Automate compatibility checks

Recommended default strategy: URI major versioning + OpenAPI contracts

For most REST APIs, use a URL structure like:

GET /api/v1/customers
GET /api/v2/customers

Keep only the major version in the URL. Avoid:

/api/v1.2.3/customers

Minor and patch releases should usually be handled internally because exposing them creates unnecessary client fragmentation.

Example policy

---

Tooling stack I would recommend

1. OpenAPI as the source of truth

Maintain one contract per major version:

openapi/
  v1/openapi.yaml
  v2/openapi.yaml

Use these for:

• API documentation
• client SDK generation
• contract testing
• breaking-change detection

Common tools:

• Swagger / Swagger UI — API documentation and exploration
• Postman — API collections, testing, collaboration
• Stoplight — API design governance and OpenAPI workflows
• Redocly — OpenAPI documentation tooling

2. Add automated breaking-change detection

Run checks in CI whenever an API spec changes:

Examples:

• oasdiff
• openapi-diff
• Spectral rules for OpenAPI linting

Your pipeline should fail if someone accidentally removes a field or changes a contract.

Example workflow:

Pull Request
      |
      v
Compare OpenAPI specs
      |
      +--> Breaking change detected?
              |
              +--> Require v2 decision

---

3. Have a deprecation process

Do not immediately delete /v1 when /v2 ships.

A typical lifecycle:

v1 released
   |
   | 12+ months supported
   |
v2 released
   |
   | Monitor v1 usage
   |
v1 sunset

Useful practices:

• publish migration guides
• announce sunset dates
• track traffic by API version
• return deprecation metadata/headers where appropriate

---

When to use alternatives

Header-based versioning

Example:

GET /customers
X-API-Version: 2

Good for:

• internal APIs
• controlled clients
• APIs with sophisticated gateways

Less ideal for public APIs because the version is less visible when debugging.

Date-based versioning

Example:

2026-08-19 API version

Used by large API platforms because clients can pin behavior for long periods. It is powerful but increases operational complexity because you may need to support many versions simultaneously.

---

A mature API versioning setup

A strong production setup usually looks like:

                Git repository
                      |
              OpenAPI specifications
                      |
          +-----------+-----------+
          |                       |
     CI validation          Documentation
          |
   Breaking-change checks
          |
      Deployment
          |
   API Gateway routing
          |
   /api/v1/*  --> v1 service
   /api/v2/*  --> v2 service

---

My recommendation by API type

For most organizations, the winning combination is:

OpenAPI + /v{major} URL versioning + CI contract checks + a clear deprecation policy. This gives consumers predictability without creating dozens of nearly identical API versions.

For most REST APIs, I’d recommend a “version only for breaking changes” strategy, with major versions selected explicitly by clients.

Recommended approach

1. Keep non-breaking changes unversioned

• Add optional fields/endpoints.
• Add optional request parameters.
• Fix bugs without changing documented behavior.
• Avoid removing/renaming existing fields.

Microsoft similarly recommends making changes backward-compatible whenever possible and introducing a new version when a breaking change is unavoidable.

2. Use major versions in the URL

GET /api/v1/customers/123
GET /api/v2/customers/123

I'd choose this over header-based versioning for most teams because it's immediately visible in logs, browser requests, documentation, monitoring, and debugging. Both URI- and header-based approaches are established patterns.

3. Don't expose every SemVer number to clients

Internally you can use:

1.4.2
1.5.0
2.0.0

But clients generally select:

v1
v2

rather than having to pin themselves to v1.4.2. Microsoft specifically recommends avoiding overly granular client-selectable versions because it creates too many versions to support.

4. Treat OpenAPI as the contract

Maintain a separate OpenAPI specification for each major API version:

openapi/
  v1.yaml
  v2.yaml

Then use OpenAPI tooling to generate documentation, clients, contract tests, and compatibility checks. OpenAPI supports a contract-first approach and can generate client libraries/documentation.

What tool should you use?

It depends on your architecture:

For example, Kong can route different API versions and manage multiple published versions, while Azure API Management supports publishing multiple API versions side-by-side.

A particularly good model for public APIs

If you're building a large external/public API, I'd consider Stripe's approach rather than simply /v1, /v2, /v3.

Stripe pins customers to a specific API version and allows individual requests to explicitly select another version. Its newer model uses dated releases, with backward-compatible monthly releases and less frequent breaking releases.

That gives you:

Client A → 2026-02-25
Client B → 2026-08-15
Client C → 2027-01-xx

without forcing every customer to upgrade simultaneously.

My default recommendation

For a typical company API, I'd implement:

                    ┌── /api/v1 ── existing clients
Client ── Gateway ──┤
                    └── /api/v2 ── migrated clients
                           │
                    OpenAPI v2 contract

with these policies:

• Breaking change → new major version
• Non-breaking change → same version
• URL versioning → /v1, /v2
• OpenAPI → source of truth for the contract
• Gateway → route versions
• Deprecation period → clearly documented
• Telemetry → identify which clients still use old versions
• Sunset old versions → don't support them indefinitely

The last part is important: multiple versions create real testing and operational cost, so establish a deprecation policy rather than accumulating v1, v2, v3, v4 forever.

If you tell me whether you're using REST, GraphQL, or gRPC, and your stack (e.g. .NET, Java/Spring, Node, Python), I can recommend a concrete versioning architecture and tooling.

Effective API versioning depends heavily on your architectural style, but there is a clear consensus on the best strategies and how they compare.

Top API Versioning Strategies

• URI Path Versioning : Embedding the version directly in the URL path (e.g., /v1/users or /api/v1/users).
  • Pros : Highly visible, easy to test in a browser or logs, simple to route at the load balancer/gateway level, and caching is straightforward per URL.
  • Cons : Technically violates pure RESTful URI design principles because the resource representation shouldn't dictate the endpoint location.
• Request Header Versioning : Passing a custom header (e.g., X-Version: 1 or using an accept header like Accept: application/vnd.mycompany.v1+json).
  • Pros : Keeps the URL clean and strictly adheres to REST principles by treating the version as metadata/representation of the resource.
  • Cons : Harder to test quickly in a browser, requires custom client configuration, and can complicate caching layers.
• Query Parameter Versioning : Passing the version as a parameter in the query string (e.g., /users?version=1).
  • Pros : Easy to implement and test.
  • Cons : Easily forgotten or messed up by caching mechanisms, and generally considered messy for clean API design.

Which Strategy is Best?

• URI Path Versioning is widely considered the best overall strategy for the vast majority of teams. The massive developer experience benefits (visibility, ease of debugging, clear documentation) outweigh the academic purity violation of REST.

Best Practices for Implementation

1. Use Semantic Versioning (MAJOR.$MINOR.$PATCH) : Increment the major version only when making breaking changes. Minor/patch updates should be backward-compatible.
2. Avoid Over-Versioning : Don't bump the version for every minor tweak. Use additive changes (like adding a new optional field) instead of breaking contracts.
3. Establish a Deprecation Policy : Clearly communicate a timeline (e.g., 6 to 12 months) before sunsetting an old version, and return a Sunset HTTP header or deprecation warning in the response headers.

If you'd like, let me know:

• What framework or gateway you are using (e.g., Spring Boot, FastAPI, AWS API Gateway, NGINX)
• Whether you lean toward REST or GraphQL

I can give you a concrete code example or routing setup for your stack.

For most teams, I’d recommend contract-first API versioning with OpenAPI, plus a strict backward-compatibility policy—rather than creating a new v2 for every change.

Recommended strategy

1. Only version for breaking changes.

Keep the same API version when you can make backward-compatible changes:

• ✅ Add a new endpoint
• ✅ Add an optional request field
• ✅ Add a new response field
• ✅ Add a new enum value if clients tolerate unknown values
• ❌ Rename/remove a field
• ❌ Change a field's type
• ❌ Change the meaning of an existing field
• ❌ Make an optional request field required

This keeps migrations manageable. Stripe uses a particularly good model: incremental versions, with compatibility changes separated from genuinely breaking releases.

2. Use explicit versioning for breaking releases.

For a conventional REST API, I'd favor:

/api/v1/customers
/api/v1/orders

/api/v2/customers
/api/v2/orders

Path versioning is easy to understand, debug, document, and route through gateways. Header-based versioning can be elegant, but it is less visible and tends to complicate caching, debugging, and client tooling.

For APIs with many independent consumers, you can instead consider a date-based or header-based version, similar to Stripe:

API-Version: 2026-08-12

That can be excellent when you expect frequent, incremental evolution rather than occasional v1 → v2 rewrites.

The toolchain I'd use

OpenAPI itself doesn't prescribe your API-versioning strategy; it gives you the machine-readable contract from which you can generate documentation, clients, tests, and compatibility checks.

The important part: automate compatibility checks

I'd put this in CI:

Pull Request
     │
     ▼
OpenAPI spec changed
     │
     ▼
Compare against production spec
     │
     ├── Non-breaking → ✅ merge
     │
     └── Breaking → ❌ fail
                         │
                         ▼
                  Require API version
                  + migration plan

This is more valuable than the particular versioning syntax. Your developers shouldn't have to manually decide whether changing a schema is breaking.

Also establish a lifecycle

I'd define something like:

v1 → Current
v2 → Preview
v1 → Deprecated
v1 → Sunset

When introducing v2:

1. Publish the new OpenAPI contract.
2. Run both versions.
3. Document migration differences.
4. Monitor which clients still use v1.
5. Notify those consumers.
6. Give a defined sunset date.
7. Remove v1 only after the agreed support window.

Microsoft similarly recommends that clients explicitly specify the API version rather than silently inheriting behavior that might change.

My preferred architecture

If you're starting from scratch, I'd choose:

REST + /v1 path versioning + OpenAPI + automated breaking-change detection + explicit deprecation/sunset policy.

Then adopt a rule:

Don't create a new API version unless the existing contract cannot remain backward compatible.

If you're building a large public API with lots of external customers, I'd go one step further and consider date-based versions with per-client version pinning, à la Stripe. That scales better than accumulating v1, v2, v3, etc. Stripe specifically designed its system around making upgrades incremental and keeping the cost of old versions contained.

If you tell me your stack (e.g. Java/Spring, .NET, Node, Python, AWS/Azure/Kubernetes) and whether these are internal or public APIs, I can recommend a concrete versioning architecture and tooling setup.

Choosing the best API versioning strategy depends heavily on your architectural style, client ecosystem, and how strictly you want to enforce backward compatibility. There is no single "silver bullet," but rather industry-standard patterns that trade off cacheability, developer experience, and implementation complexity.

Core API Versioning Strategies

• URI Path Versioning : Embedding the version directly in the URL path (e.g., /api/v1/resource).
  • Pros : Highly visible, easy to test in a browser or logs, and straightforward to route at the load balancer/gateway level.
  • Cons : Violates pure REST URI principles (since the URI is supposed to identify a resource, not its representation/version).
• Request Header Versioning : Passing the version via a custom header (e.g., X-API-Version: 1 or using vendor media types in the Accept header like application/vnd.mycompany.v1+json).
  • Pros : Keeps URLs clean and adheres strictly to REST semantic principles regarding content negotiation.
  • Cons : Harder to test quickly in a browser, requires clients to explicitly configure headers, and can complicate caching layers if not configured correctly.
• Query Parameter Versioning : Appending the version as a query string parameter (e.g., /api/resource?version=1).
  • Pros : Easy to implement and easy for clients to override or test on the fly.
  • Cons : Poor cacheability (many CDNs and caches ignore or mishandle query parameters for caching static representations), and it clutters the query space.

Industry Recommendation: Which is "Best"?

• For 90% of Web APIs (REST/JSON): URI Path Versioning (/api/v1/... ) is widely considered the most practical and pragmatic choice. The developer experience is superior because it is transparent, easy to debug, and universally supported by API gateways and testing tools.
• For Enterprise/Hypermedia APIs (HATEOAS): Accept Header Versioning is technically superior and respects REST architecture constraints, though it demands more discipline from client developers.

Best Practices for Implementation

1. Avoid Breaking Changes : Whenever possible, make additive changes (adding optional fields, new endpoints) rather than breaking changes, which lets you delay version bumps.
2. Use Semantic Versioning (SemVer) : Follow major.minor.patch (MAJOR. MINOR. PATCH) for your versions. Increment the MAJOR version only when backward-incompatible changes are introduced.
3. Establish a Deprecation Policy : Communicate deprecations well in advance (e.g., 6 to 12 months notice) via response headers like Sunset: Wed, 11 Nov 2026 00:00:00 GMT or Deprecation: true.
4. Leverage API Gateways : Use tools like Kong, Apigee, AWS API Gateway, or Tyk to handle routing, transformation, and deprecation logging rather than hardcoding version logic deep inside your microservices.

If you'd like, let me know:

• What architecture your API uses (REST, GraphQL, gRPC)?
• Who your consumers are (internal frontends, public third-party developers)?

I can give you a more tailored recommendation and architecture pattern.