Skip to main content
Unlisted page
This page is unlisted. Search engines will not index it, and only users having a direct link can access it.

Roles in the Semetrika end-to-end workflow

Defines the human roles involved in delivering a website built on Semetrika - from the Semetrika core team through to the content author publishing pages. This is a generic reference; specific decision documents reference these roles by name rather than redefining them.

Why this exists​

Semetrika's mission is end-to-end design-to-code workflow support. That workflow spans multiple humans, each with distinct artifacts, vocabularies, and handoff points. Decision documents need stable role names so they can talk about who does what without re-defining the cast each time.

Companion to glossary.md (which defines the terms each role uses).

The five roles at a glance​

#RoleOwnsLayerHands off to
1Semetrika core maintainerSemetrika framework code, Figma library, CMS base theme, rules, vocabulary0 (foundation)Consumer design system designer
2Consumer design system designerBrand-specific Figma file, brand tokens, component spec docs~5 (system extension)Site theme developer
3Site theme developerPer-project site theme (CSS, Twig, theme info)6 (brand application)Site builder
4Site builderCMS configuration (content types, fields, view modes, paragraphs, blocks)6 (brand application via CMS admin)Content author
5Content authorContent (pages, articles, paragraphs created in CMS)above 6 (content layer)End user / visitor

Layer numbers reference the customization-layers concept. The end user / visitor receives the rendered HTML but does not interact with Semetrika's vocabulary; they are listed only as the final destination of the chain.

Role detail​

1. Semetrika core maintainer​

The team that builds and maintains Semetrika itself. Sits at the foundation; everything else consumes their output.

FieldValue
OwnsSemetrika framework code (CSS bundle, JS bundle, Twig templates), Semetrika Figma library, Semetrika CMS base theme, architectural rules in docs/content/handbook/rules/, canonical vocabulary in Rule 22, design tokens, documentation
Vocabulary consumedOwn (canonical)
Vocabulary may extendOwn (via Semetrika releases)
Hands off vianpm package, CDN bundle, Figma library URL, GitHub repo
Receives feedback fromAll downstream roles via issues, RFCs, contributions

2. Consumer design system designer​

The designer who takes Semetrika's Figma library and customizes it into a brand-specific design system for a consumer organization. Sits between Semetrika and the codebase - their output is design specs, not code.

FieldValue
OwnsConsumer design system Figma file (forked from or built on Semetrika Figma), brand token definitions (typically Figma Variables exported as JSON), component spec docs, brand guidelines
Vocabulary consumedSemetrika's vocabulary (value names, capabilities, token names)
Vocabulary may extendBrand-specific composition names ("Featured Newsletter Card", "Hero Banner Variant B") and possibly new values when Semetrika's vocabulary doesn't cover the need
Hands off viaFigma file (read-only or shared library), exported tokens (JSON / Style Dictionary input), spec documentation
Receives feedback fromSite theme developer (where Figma can't translate cleanly to code)

A consumer organization may have multiple sites that share the same consumer design system. The designer's work is reused across those sites.

3. Site theme developer​

The developer who implements the consumer design system in a per-project site theme. Sits on top of the Semetrika CMS base theme. Translates Figma specs into CSS, Twig templates, and theme-level configuration.

FieldValue
OwnsSite-specific theme (CSS, Twig templates, theme info file, JS where needed), token overrides at :root, new components when the consumer design system requires them, override Twig for any CMS-specific patterns
Vocabulary consumedSemetrika's vocabulary + consumer design system extensions from the Figma spec
Vocabulary may extendSite-specific component classes when consumer design system introduces new vocabulary; site-specific values added to the project's local vocabulary
Hands off viaTheme installed in the site, Twig templates ready for the CMS to render, documented field-formatter mappings
Receives feedback fromSite builder (when the available templates don't cover the editorial need)

4. Site builder​

The person who configures the CMS admin: content types, fields, view modes, paragraphs, blocks. Maps content structure to Semetrika components via field formatters and template selections. Typically does not write CSS or Twig but selects from what the site theme provides.

FieldValue
OwnsCMS configuration (content types, fields, view modes, paragraphs, blocks), field formatter assignments, form and display configurations, plain-English admin labels
Vocabulary consumedSite theme's exposed components and variants (which trace back through consumer design system to Semetrika)
Vocabulary may extendAdmin labels - the human-facing names content authors see in the CMS UI
Hands off viaConfigured site with content types and field options exposed in admin
Receives feedback fromContent author (when admin options are confusing or missing)

In smaller projects this role may be the same person as the site theme developer. In larger projects they are typically distinct roles.

5. Content author​

The CMS user who creates and edits content. Picks from configured options (paragraph types, view modes, field values). Does not see Semetrika's vocabulary directly - sees the plain-English admin labels chosen by the site builder.

FieldValue
OwnsContent (pages, articles, paragraphs, media)
Vocabulary consumedPlain-English admin labels in the CMS admin UI
Vocabulary may extendNone (content authors do not extend the design system)
Hands off viaPublished content visible to end users / visitors
Receives feedback fromEditorial review, end users

The content author is often the only role that sees the design system as a finished product rather than a thing to extend. Their experience is the test of how well the vocabulary chain held together.

Role-to-layer mapping​

Layers are defined by the customization-layers concept:

RoleLayerNotes
Semetrika core maintainer0Foundation - all layers consume this
Consumer design system designer~5System extension - extends Semetrika with brand-specific design
Site theme developer6Brand application - implements consumer design system in code
Site builder6Brand application - via CMS admin config rather than code
Content authorabove 6Content layer - downstream of all design system decisions

Layers 1-4 from the customization-layers concept apply when Semetrika is used without the consumer-design-system pattern (drop-in usage, token theming, class composition, custom CSS). Roles 1 and 5 still exist in those simpler cases; roles 2-4 may collapse or merge depending on project scale.

How roles hand off to each other​

A linear chain in the standard case:

Semetrika core maintainer
↓ (Figma library, framework code, CMS base theme, vocabulary)
Consumer design system designer
↓ (Figma file, brand tokens, spec docs)
Site theme developer
↓ (site theme with Twig templates, CSS, token overrides)
Site builder
↓ (configured content types, fields, view modes, admin labels)
Content author
↓ (published content)
End user / visitor (receives rendered HTML)

Each handoff is also a vocabulary translation point. The decision question for any vocabulary or extension mechanism is: does the vocabulary survive this handoff cleanly, or does it require re-translation?

Role overlaps in practice​

In real projects roles often collapse:

  • Small project: site theme developer and site builder are the same person. Content author is the project owner.
  • Single-site organization: consumer design system designer and site theme developer may be the same person. The "consumer DS Figma" and "site theme" exist but for one site only.
  • Multi-site organization: all five roles are distinct, possibly across multiple teams. The consumer DS designer's work is reused across sites; each site has its own site theme developer.
  • Semetrika core team using their own framework: roles 1 and 2 collapse - they design and maintain the system simultaneously.

When decision documents reference these roles, they refer to the function, not necessarily a separate person.