Frame
Most design systems own their parts. They define the canonical type, color, components, and tokens that everything downstream inherits. Cast worked the other way around. It owned almost none of its parts, and that was the point.
Cast is Google's protocol for moving media playback across shared devices. Developers build casting into their apps through the Cast SDK. It surfaces across half a dozen products and platforms that each have their own teams and way of building. The Cast Design System was created to make that experience coherent everywhere it happened: one source of truth for casting, composed from systems it didn't own.
The Problem
Most of what a design system needs didn't exist yet. The piece that mattered most didn't exist as design at all. The Cast SDK is the core of casting, the kit developers use to make their apps and devices cast-able. It was built and maintained as an engineering product, with no design artifacts: no components, specs, or design presence of any kind. It had finally been decided that it needed one. The assignment was to give design a place in a product that had only ever been code.
The SDK components had to be built from shipped code and screenshots pulled from sample apps and slide decks. I needed to reverse-engineer their design and specs from screens I couldn't open, and rebuild them as real, editable, documented components.
Casting also ran across products that each had their own systems and teams: YouTube, YouTube TV, Google TV, Chromecast, the Home app, Nest Displays. The casting components on those surfaces were governed elsewhere, scattered across libraries I didn't own. Making casting coherent across all of them meant composing from those systems and staying continuously aligned with the teams that held them.
The conditions were narrow: one designer, remote, no test devices, building a system for casting with nothing to cast to, documenting flows from screenshots of the flows themselves.
The Approach
Building design system foundations is Design Systems 101. For Cast that would have been the wrong move. The products it served already had mature systems, each with teams maintaining them; a parallel Cast foundation would have been a fifth wheel, drifting out of sync the moment any of those systems changed. The system's job was to make the parts cohere, weaving cast through their existing functions and components.
So the approach would invert the usual model: compose, don't define. Cast components would be built from the atoms and foundations their origin systems already owned.
That decision set the architecture. If the components belonged to many systems but the experience had to feel like one, the system couldn't be organized the way a single-product library is. It would be organized by surface — mobile, tablet, smart displays, TV, Chrome — how casting actually shows up to a user. Foundations and atoms would stay where they lived, in their origin systems; what Cast would hold was the composition: the casting components, specced per surface, addressable by where they were used.
The SDK was the exception. It owned nothing to inherit from, no design layer at all, so its components had to be built rather than composed. Once built, they entered the same structure as everything else: specced, surfaced, and connected to the rest.
Alignment was where the system actually lived. A system tethered to half a dozen others is only as coherent as its connection to the teams maintaining them. So the work would run on a standing cadence: meeting with the owning teams, tracking what changed in their systems, reflecting it back into Cast before it drifted. The connective tissue was a practice.
The hardest call underneath all of it was where to draw the system's edges. A small system wired into many larger ones breaks if it absorbs too much, so each connection took only the minimum it required. The boundary was the architecture.
