Skip to content

How we work together

Getting something into the Connected Design System runs through GDI, Platform and the Dev Teams, in that order. This page describes the route a business need takes to become a released component, who holds each stage, and who makes each decision.

It covers both directions: how work gets into the system, and what happens when a team wants something already in it to behave differently. For how to edit and add pages on this site, see Contribute to the Playbook.

How work reaches the Connected Design SystemA business need goes to a Dev Team's BA, then to a design alignment meeting the requesting team owns, then to GDI who design it in Figma until it is dev-ready and tokenised. Platform import the tokens, and Platform and the Dev Teams then decide together whether the result is reusable by other teams. If it is, Platform ship the CSS and publish a release that the Dev Teams build their React components against. If it is not, the Dev Team builds it in their own app.StyleguideDev TeamBADesign alignmentGDI Figma designPlatform import tokensReusable?Platform ship the CSSBuilt in their own appDev Teams build React

Business reaches a Dev Team. A need arrives at a Dev Team’s BA, who take it to design. The requesting team owns those meetings: if your team wants something, your team schedules the conversation.

GDI design it. GDI move legacy components, pages and apps onto the CDS in Figma, iterating with business and the PO until the design is dev-ready and tokenised. “Dev-ready” is the handover bar, and tokenised is part of it: the design expresses its values as design tokens before it leaves Figma. See Inside GDI below.

Platform import the tokens. The token structure and values are GDI’s; getting them into the repository is Platform’s.

Platform and the Dev Teams decide what belongs where. The call is made together, in a meeting — not by either side alone, and not by whoever opens the CSS first. See In or out the styleguide? below.

Platform ship it, then the Dev Teams build on it. Platform implement the CDS update, document the CSS and publish the release. The Dev Teams then build the React component and the app behaviour against that release, and document the React components other teams can reuse.

Three questions, asked about the thing being built:

  1. Is it, or should it be, reusable by other teams? Not “could it conceivably be reused” — whether other teams actually have this problem.
  2. Can primitives be extracted so that it can be reused? Sometimes the whole thing belongs to one app but a layout, a component or a utility inside it does not. Pulling those out turns a one-off into something shared.
  3. Can it, or should it, be brand-specific? Toyota, Lexus and Kinto do not have to resolve the same way, and a design that only makes sense for one brand is a different proposition from one that has to work for all three.

Yes to the first two makes something Platform’s. No leaves it with the Dev Team, built in their own app — a legitimate outcome, not a rejection.

A design team starting a new module or card checks, in parallel, whether the design system already has what it needs. Every gap becomes a ticket to the DS team.

How GDI design a moduleA design team analyses which components and tokens a new module needs and runs three checks in parallel. A missing component, a change to an existing component, or a need for component-specific tokens each becomes a ticket to the DS team, who create or change it. The design team then completes the module in its own files and requests a DS review, applying the feedback until the DS team approves. Approval marks the design done.NoYesYesYesNoNoNo, apply feedbackYesModule or card neededAnalyse components andtokensAll components in the DS?A component needs achange?Component tokensneeded?DS team create itDS team change itDS team create themDesign the module in teamfilesApproved in DS review?Done: dev-ready
  • A missing component is created by the DS team; the team that requested it owns it.
  • A change to a component is ticketed by the team that owns it. If that is another team, contact them and they open the ticket and validate the result.
  • Component-specific tokens, beyond the semantic set, are created by the DS team. Otherwise the module applies semantic tokens.

DS review approval is what “dev-ready” means: the design is done, and the handover to Platform starts here. A module built entirely from existing components needs nothing new from Platform — the Dev Team builds it.

A component exists, and a team wants it to look or behave differently.

Every such request is a design call. Platform triage it; Platform do not decide it.

How a request about an already-shipped component is triagedA request about a shipped component goes to Platform, who triage it against Figma. If Figma specifies the behaviour and the styleguide does not do it, it is a bug and Platform fixes it. If Figma does not specify it, or specifies otherwise, it is a design change request — GDI decide and update Figma first, and Platform implements it afterwards.Yes, and the CSS differsNo, or it says otherwiseRequest about a shippedcomponentPlatform triage it againstFigmaDoes Figma specify it?A bug. Platform fix itA change request.GDI update Figma firstThen Platform implement it
Figma says… It is… Who acts
X, and the styleguide does not do X a bug Platform fix it
not-X, or nothing at all a design change request GDI decide and update Figma first, then Platform implement it

“Figma is silent at this breakpoint” is not “Platform decides.” It is still GDI’s to specify: the request has not been designed yet.

A change request enters GDI’s flow as a component that needs a change: the owning team opens the DS ticket and validates the result.

A commit that changes a component’s behaviour cites the Figma evidence for it, so the decision holds up when the opposite request arrives.

Where to send one. A Teams message to Platform. There is no intake form and no queue.

GDI own TME design in Figma, the token structure and values, and the usage and accessibility documentation. Accessibility documentation is part of design documentation: written by GDI, sourced from Figma, and reviewed by Platform both manually and with agentic AI. GDI are formally responsible for this site’s Design documentation; in practice Platform author those pages from GDI’s Figma documentation.

Platform own getting the tokens into the repository, this Playbook, the styleguide, and every component in it, including the CSS documentation.

Dev Teams build the shared React components and AEM structures, and document the ones that are reusable by other teams.

Teams outside DXP consume the design system rather than contribute to it. Design requests go through the Dev Teams, so they cannot be raised directly. Feedback and support are open: if something in the styleguide is broken, unclear or missing, tell Platform.

Internal

Open questions — please correct these in review.

  • Who is “the DS team”? Read here as GDI’s design-system designers, not Platform. Dev Teams will read “DS” as Platform unless the page says otherwise.
  • Design ownership vs. code ownership. In GDI’s flow a design team owns the components it requested; Platform own every component in the styleguide. Is that the right split?
  • When does Platform hear about a new DS component? A DS ticket for a missing component or component tokens is effectively where reuse is decided. Should it notify Platform then, rather than at token import?
  • Who signs off, by name — on the GDI side, and on the Dev Team side.
  • Is accessibility documentation really GDI-written and Figma-sourced as described above?
  • Should this page say that GDI formally own Design documentation while Platform actually write it?
  • The alignment cadence. One to two backlog meetings per month is unconfirmed.
  • Where change requests should go. Today it is a Teams message to Platform. Should that be a queue, a recurring support ticket, or a channel?