Keeps this page in sync as the body changes. Pause it any time for a quieter view.
Path /people/trimble-glue-layer
Last refresh never
Work · Trimble Navigation Limited · Jan 2007 – Oct 2009 · Software Engineer
At Trimble Navigation, built the glue layer sitting on both the client and the server edge — the load-bearing piece that let the two sides evolve on independent cadences, with multiple client calls and multiple API versions combined into one wire-optimal exchange. Server and client teams could ship on their own rhythm without coordinating each release; the glue absorbed the version differences and the round-trip optimisation. Neither team had to think about wire shape.
Why the glue layer mattered
Without it, every API change from the server team meant a synchronised release with the client team. With it, the client team kept shipping for whatever wire version they already understood, the server team kept shipping for whatever wire version they already understood, and the glue layer translated between them. The architecture decoupled cadence from contract. Two teams could each move at the speed they could move at, instead of at the speed of the slower one.
The architectural choice that let the layer absorb its workload: the glue ran twice, once on the client edge and once on the server edge, with a shared codebase describing how each side translated. From either team's perspective the glue was a library they linked against; from the wire's perspective it was a contract that always framed calls in the optimal shape regardless of which version either team was currently authoring against.
What 'wire-optimal' actually meant
A naive client makes N independent API calls and pays N network round-trips. The glue layer's coalescing job: watch the call pattern from the client app, recognise when several calls are batched into a logical unit, fold them into a single wire request, dispatch to the server, then split the response so each call returned to its caller as if it had been independent.
The trade-off the layer mediated: application-team ergonomics versus wire cost. Naturally written client code makes lots of small calls; wire-optimal protocols want one big bundle. Without the glue, every client call site had to be wire-aware; with it, neither team had to think about the wire at all. The glue made the trade-off invisible to both sides.
This is the same posture, in 2007, that GraphQL would commit to for completely different reasons in 2015 — "let the client describe its data shape; let the server assemble the optimal response in one trip." Trimble's glue layer reached the same architectural answer through a different door (positioning hardware constrained the client side; the server side had to absorb the complexity).
The conviction at the heart of this work: two teams should not have their release cadence coupled to a wire contract. If shipping a server feature requires the client team to ship the same week, neither team can move at its true speed. The slower team becomes the rate limit for both.
The glue layer's contract was therefore not "the current API" but "the set of API versions either side might be running, and the translations between them." When the server team added a new field, the glue layer learned to translate calls from old-client-version to new-server- version and vice versa. When the client team added a new call, the glue layer learned to break that call apart for servers that hadn't yet adopted it. Both sides kept shipping, on their own rhythm, into a wire that was always current with whichever side was further ahead.
The same conviction holds in the Coherence Network 's design today. The web client and the API ship through independent CI runs; the OpenAPI contract is generated from FastAPI's source of truth and the TypeScript client adapts. Either side can land a change without breaking the other; the substrate absorbs version differences. The shape Trimble committed to in 2007 is still the right shape twenty years on.
Lineage of decoupling
The deepest reading: this is the same conviction the Schindler 7-layer ISO/OSI work committed to thirty-six years earlier — every layer is addressable, every layer does exactly its job, no layer collapses into another. At Trimble the conviction landed at the application-protocol layer: the client and server were two layers, the glue was a layer between them with its own discipline, and the wire was a layer below that with its own constraints. Each layer authored against its own job, not the layers around it. The architecture survives at every altitude where this body has applied it.