Technical Program Manager

Opening Statement (~60 sec)

I led the design and delivery of Amazon Prime Video's cross-platform design system — the shared component, token, and design-to-code layer that unified the consumer UI across TV, mobile, and web. Two compounding problems defined the starting point: design-to-code lead time sat at 3–4 weeks per component per surface, because each of three client surfaces hand-coded the same UI independently from static Figma redlines, and that lead time was the direct cause of cross-surface visual and behavioral drift of 40%+ on components that were supposed to be identical — together driving an estimated $8M+/year in duplicated engineering effort. A few quick definitions: Shared component — a reusable piece of the interface, like a button, title card, or navigation menu, built once and used everywhere it appears instead of being recreated for each screen or platform. Token — a single, named design value, such as a specific color, spacing amount, or font size, stored in one place and reused consistently, so a design decision only has to be made — and changed — once. How a token and a shared component relate — a shared component is built by referencing tokens for its visual values (color, spacing, type) rather than hardcoding them, so a single token update propagates automatically to every shared component that uses it, on every surface, without touching each surface's code. Design-to-code — the process of turning a visual design into working software code that actually runs on a device. Figma redlines — static design mockups with handwritten measurements and specifications that engineers use as a reference to manually rebuild a design in code. Cross-surface visual and behavioral drift — when the same feature ends up looking or working slightly differently across devices, like a button that's a different color on TV than on the phone app, even though it was meant to be identical everywhere. I owned it end-to-end: I built the cross-org business case, made the core platform bet — a canonical, versioned token-and-component contract with per-surface codegen adapters, plus the design-to-code tooling that let engineers build against it instead of hand-translating it every time — and built durable, trust-based partnerships across seven groups that didn't report to me: Design Platform, Client Engineering (TV, mobile, web), Experience Design, Product, QA, Risk & Compliance, and Legal. I set the lightweight structure myself — one intake process for every new component request, clear ownership for every partner, and pragmatic, not perfect, calls on where the contract had to hold firm and where each surface needed room to diverge — the same blend of platform thinking, developer-tooling instinct, and product judgment a design-systems program at this scale demands, translated into results the business could measure. The result: design-to-code lead time dropped from 3–4 weeks to under 2 days per component, cross-surface drift fell from 40%+ to under 5%, accessibility and regional-compliance defects reaching production went to zero, and the program delivered $5M+/year in reclaimed engineering capacity with 92% of client teams onboarded within 9 months — without a single top-down mandate.

Situation

1. Prime Video's consumer UI had organically forked across three client surfaces with no shared foundation. TV alone spanned 10+ device families — Fire TV, Roku, LG/Samsung smart TV OEMs, and game consoles — each with its own rendering constraints, input model [the primary way a user interacts with a surface — a remote control's D-pad focus navigation on TV, versus direct touch on mobile and web], and firmware release cadence, in addition to iOS, Android, and web. (Focus navigation is how a TV interface highlights and moves selection between elements as someone presses the remote's directional buttons — mobile and web skip this entirely, since a person just taps what they want.) 2. Design delivered static Figma redlines; each of the three platform engineering orgs hand-translated the same component independently, taking 3–4 weeks per component per surface — meaning a single redesigned feature, like a title-detail page, was effectively built three separate times. 3. An internal audit quantified the consequence: 40%+ visual and behavioral drift on components that were supposed to be shared — inconsistent spacing, typography, and focus-navigation behavior reaching production — plus recurring accessibility non-conformance (caption rendering, TV focus states) and regional content-compliance [region-specific legal and regulatory requirements a UI component must satisfy before it can ship in a given market — for example, matching a title's age-rating badge to the local ratings board (TV-MA in the U.S. vs. 18 in the UK), or formatting subtitles to a region's mandated caption styling] gaps that Risk & Compliance and Legal were catching after launch rather than before. 4. Engineering estimated $8M+/year in duplicated design-to-code labor across the three surface orgs, and there was no shared architecture, no intake process for new components, and no organizational owner for the problem end-to-end.

Task

1. I was given the mandate to build and roll out a unified, cross-platform design system — component library, design-token layer, and design-to-code pipeline — from the ground up, with no existing architecture and no cross-org consensus on ownership. 2. The program needed to do three things simultaneously: give design and engineering a shared source of truth so a component shipped once and rendered correctly on all three surfaces; build compliance and accessibility requirements into the system rather than retrofitting them per market; and do this without slowing down the three client engineering orgs' existing roadmaps. 3. My mandate covered program strategy, the intake and governance process for XFN partners, the architecture bet, cross-org alignment across seven partner groups — Design Platform, Client Engineering (TV, mobile, web), Experience Design, Product, QA, Risk & Compliance, and Legal — risk and dependency management, and delivery end-to-end.

Action

1. 1.Defined the program's scope, milestones, and phase sequencing end-to-end: quantified the problem into an $8M+/year business case, then set a risk-validated roadmap — Phase 0 (TV), Phase 1 (mobile), Phase 2 (web) — gated by adoption and drift metrics instead of fixed calendar dates, so I could adjust sequencing as real data came in rather than defending the original plan.
2. 2.Made the core platform trade-off myself, without writing a line of code: a canonical, versioned token-and-component contract with per-surface codegen adapters, over a forced common runtime (too risky given TV's hardware constraints) or a documentation-only style guide (too slow to move the needle) — a pragmatic call made with TV, mobile, and web engineering leads in the room, not a theoretically perfect one made in isolation.
3. 3.Coordinated platform adoption across TV, mobile, and web on a deliberate sequence — validating the contract against TV, the most constrained surface, before extending it to mobile and then web — so each surface adopted the system once it was proven, not on a uniform push-out date.
4. 4.Built lightweight structure instead of heavyweight process: a single RFC-style intake path and a joint Design Platform / Experience Design / Product review council, replacing three separate, ad hoc component requests per surface with one clear mechanism — simple enough that it never slowed any of the three engineering orgs down.
5. 5.Built durable, trust-based relationships across seven partner groups who didn't report to me — Design Platform, Client Engineering, Experience Design, Product, QA, Risk & Compliance, and Legal — bringing Risk & Compliance and Legal in as co-authors of the compliance metadata schema instead of late-stage reviewers, so a compliant UI became the system's default output.
6. 6.Surfaced and managed dependencies and risks before they became blockers: maintained a single dependency map and risk register — including TV firmware release windows that constrained rollback options — with named owners and mitigations reviewed on a standing biweekly cadence.
7. 7.Leveraged GenAI to scale my own impact and the program's throughput: piloted a GenAI-assisted design-to-code pipeline that generated first-pass component implementations directly from Figma files against the token contract, freeing engineers to review and refine instead of hand-transcribing every component.
8. 8.Partnered with QA to build automated cross-surface visual-regression and accessibility conformance testing directly into CI [continuous integration — the automated pipeline that builds and tests every code change before it can merge], protecting both the developer experience (a fast, trustworthy merge gate) and the designer experience (confidence that what shipped matched what was designed).

Result

1. Design-to-code lead time dropped from 3–4 weeks to under 2 days per component, and a component now shipped once and rendered correctly across TV, mobile, and web instead of being rebuilt three times. 2. Cross-surface visual and behavioral drift fell from 40%+ to under 5%, measured by the same automated visual-regression suite QA and I had built into CI. 3. Accessibility and regional-compliance defects reaching production dropped to zero, because conformance was now enforced pre-merge instead of caught in review. 4. The program reclaimed $5M+/year in previously duplicated engineering effort, and 92% of client engineering teams had onboarded onto the design system within 9 months — organically, without a top-down mandate. 5. The intake and governance model was adopted as the reference pattern for two other cross-surface initiatives in the org.

Closing Statement (~60 sec)

What made this a program-management problem rather than a pure design or engineering one was that the architecture, the rollout sequencing across three very different client surfaces, and the compliance trade-offs all had to be resolved before a single shared component shipped — and none of it had a clean 'right' answer, only a better trade-off given the constraint. Design could tell me what the ideal component looked like; TV engineering could tell me what a low-power device could actually render; neither could tell me whether to sequence TV or mobile first, or how to get Legal and Risk to co-author requirements instead of gatekeeping them after the fact. That's the gap I closed: I turned a fragmented, three-times-rebuilt UI into a single source of truth, a governance model that made compliance a default instead of an exception, and a design-to-code pipeline — GenAI-assisted where it made sense — that scaled without proportional headcount. The pattern I'd bring here is the same: validate the architecture against the most constrained surface first, bring compliance and QA in as co-authors, not gatekeepers, and make adoption the rational choice by making the shared path faster than the workaround.