The API Advocacy Pattern #1

Your Vendor's API Is Not Your Friend

Vendors design APIs for their own architecture, not for developers. The structural problem behind every integration nightmare.

#api #cross-platform #developer-experience #cad #aec
Dmytro Yemelianov - Author
Dmytro Yemelianov
Autodesk Expert Elite • APS Developer

TL;DR: The API you are integrating with was not designed for you. It was designed for the vendor’s internal architecture, then exposed with minimal adaptation. This is not a bug — it is a structural pattern that repeats across every major platform. Understanding this is the first step toward building something that actually works.


The Scene

You are building an integration. The documentation says to POST a JSON body to an endpoint. You do exactly that. You get a 401. No message, no hint, no breadcrumb. You check the token — it is valid. You check the scopes — they match. You check the headers — correct. You spend two hours before discovering that the endpoint requires a different auth flow than the one documented, because the docs were written for a previous version of the platform that no longer exists.

This is not a skill issue. This is a design issue.

You are working against an API that was built to serve the vendor’s operational needs, then exposed to you as an afterthought. The documentation, the error messages, the auth flows, the rate limits — none of it was designed with your workflow in mind.


The Structural Problem

Vendor-Centric vs Developer-Centric API Design

VENDOR-CENTRIC

  • —Auth complexity serves vendor security models
  • —Per-request architecture, no bulk operations
  • —Error codes leak internal system names
  • —Rate limits protect vendor infrastructure
  • —Feedback forums are decorative

DEVELOPER-CENTRIC

  • —Auth is one command, one flow
  • —Bulk endpoints for real workflows
  • —Errors explain what to do next
  • —Rate limits are documented and predictable
  • —Feedback ships as features

This is not about incompetent engineering teams. The people building these APIs are often excellent engineers solving hard problems. The issue is incentive alignment. When a vendor exposes an internal service as a public API, the priorities are clear:

  1. Security — the vendor’s, not yours
  2. Stability — of the vendor’s infrastructure, not your integration
  3. Scalability — of the vendor’s platform, not your use case

Your developer experience ranks somewhere below “updating the changelog.”

Auth complexity exists because the vendor needs it

Autodesk APS has two-legged and three-legged OAuth flows with different scope requirements, different token lifetimes, and different refresh behaviors. PTC Onshape requires URL-encoding client secrets that contain trailing = characters — an undocumented trap that burns hours. Dassault 3DEXPERIENCE requires separate authentication for each of its internal services, leading to developers logging in five times in one hour. Siemens Teamcenter SSO configuration demands understanding six or more parameters including proxy URLs, discriminators, and protocol settings.

None of this complexity exists because developers need flexible security. It exists because the vendor’s internal identity systems are complex, and that complexity was exposed rather than abstracted.

Bulk operations do not exist because the vendor’s architecture is per-request

You need to add a user to 50 projects. The API gives you an endpoint that adds a user to one project. You write a loop. The loop hits rate limits. You add backoff logic. Some requests fail silently. You add retry logic. You add error classification. You have now written an orchestration layer that the vendor should have provided.

This is not an edge case. This is the most-voted feature request on Autodesk Construction Cloud’s feedback forum — 344 votes, six years and counting, status: “Future Consideration.”

Errors are opaque because internal system names leak through

When a vendor API returns {"code": "BIM360_ERROR_0x42F1", "message": "Operation failed"}, you are looking at an internal error code that was never translated into something meaningful for an external consumer. The vendor’s support team might know what 0x42F1 means. You do not. The documentation does not. The forum post from 2019 where someone else hit the same error has no response.

Feedback requests die in public forums

THE FEEDBACK BLACK HOLE
4,295
feature requests submitted to ACC’s forum
96.6%
permanently stuck in “Gathering Support”
Read the full analysis

Vendors maintain feedback forums to create the appearance of listening. The data tells a different story. When 96.6% of requests never move past intake, the forum is not a feedback mechanism — it is a pressure valve.


Cross-Vendor Evidence

This is not an Autodesk problem. This is a vendor API problem. The same patterns repeat across every major platform in the CAD, AEC, and PLM space — and beyond.

AUTODESK APS

Archived the community-built forge-cli with no replacement. Laid off 7% of staff in 2024, gutting developer support. Forced a BIM 360 to ACC migration with zero migration tooling for API consumers. Developers discovered breaking changes through runtime errors.

PTC ONSHAPE

OAuth client secrets may contain trailing = characters that must be URL-encoded — but the documentation does not mention this. Developers discover it after hours of debugging 401 errors. The API key documentation warns about “gotchas” that are never fully enumerated.

DASSAULT 3DEXPERIENCE

Five separate authentication endpoints across partner platform, commercial platform, support portal, and application layer. 3DPassport session failures cascade into SOLIDWORKS crashes. Developers report losing work when authentication tokens expire mid-operation with no recovery path.

SIEMENS TEAMCENTER

SSO configuration requires understanding proxy URLs, external identity providers, credential managers, discriminators, endpoint configurations, and protocol settings. SoaRuntimeException login failures are so common they have their own dedicated troubleshooting guide.

E-COMMERCE PLATFORMS (SHOPEE, SHOPIFY, AMAZON SP-API)

The pattern extends beyond CAD/AEC. Rate limit rules that differ per endpoint with no published schedule. Webhooks that silently stop firing. Error codes that resolve to “contact support.” Token refresh flows that race against request flows. The same vendor-centric design, different industry.

The details vary. The pattern does not.


Naming the Pattern

Low-Convenience API

noun — An API that is technically functional but practically hostile. It satisfies the vendor’s contractual obligation to provide programmatic access while minimizing their investment in developer experience. Characterized by: complex auth flows, absent bulk operations, opaque errors, aggressive rate limits, and unresponsive feedback channels.

”The endpoint works. It returns data. It is also completely unusable at scale without a 2,000-line wrapper you have to maintain yourself.”

This is not incompetence. It is vendor-centric design. The API is optimized for the vendor’s operations — their security model, their infrastructure constraints, their internal service boundaries. Your workflow, your deadlines, your error handling needs — these were never part of the requirements.

The result is an API that technically works and practically punishes you for using it.


The Anatomy of a Low-Convenience API

DimensionWhat the Vendor ShipsWhat Developers Need
AuthenticationMultiple flows, undocumented scope requirements, silent token expiryOne flow, clear scopes, automatic refresh
Bulk OperationsSingle-resource endpoints onlyBatch endpoints with partial failure reporting
Error HandlingInternal codes, generic messages, no remediation hintsHuman-readable errors with fix suggestions
Rate LimitsUndocumented, inconsistent across endpoints, 429 with no Retry-AfterPublished limits, consistent headers, backoff guidance
PaginationOffset-based with unstable orderingCursor-based with consistent results
Feedback LoopForum with 96.6% abandonment ratePublic roadmap, versioned changelog, deprecation notices

Every row in that table represents hours of debugging, thousands of lines of workaround code, and developer goodwill burned for no reason.


What Is Actually Needed

The vendor is not going to fix this. Their incentives do not align with your needs. The forum requests will continue gathering dust. The auth flows will remain complex. The error messages will stay opaque.

What you need is a hardened client layer between the vendor’s API and your code. One that:

Absorbs

Auth complexity, token refresh races, scope negotiation, credential storage — handled once, correctly, so you never think about it again.

Orchestrates

Bulk operations from single-resource endpoints, with retry logic, rate limit respect, partial failure handling, and progress reporting.

Classifies

Failures into actionable categories — auth errors vs permission errors vs rate limits vs server errors — with structured exit codes and clear messages.

This layer is not a “nice to have.” It is the difference between a weekend proof-of-concept and a production integration that does not wake you up at 3 AM.

We call this layer an API User Advocate — a system that stands between the developer and the vendor’s API, translating vendor-centric design into developer-centric behavior. It is not a wrapper. It is not an SDK. It is a hardened operational layer that treats the vendor’s API as an unreliable upstream dependency and protects you from its design choices.


The Series Ahead

THE API ADVOCACY PATTERN
1
Your Vendor’s API Is Not Your Friend
You are here
2
The Pattern Repeats: Four CAD/PLM Vendors, Same Problems
Deep evidence from Autodesk, PTC, Dassault, and Siemens
3
Building the Advocacy Layer
Architecture of a hardened client that treats vendor APIs as unreliable upstreams
4
Failure Classification as a First-Class Concept
Why exit codes, structured errors, and retry policies matter more than features

This is post 1 of The API Advocacy Pattern series. We have named the problem. Next, we prove it repeats — with detailed evidence from four major CAD/PLM vendors that share nothing in common except their disregard for the developers building on their platforms.


Related: