Enterprise

The Enterprise system begins with structure before design.

This includes:

• clear system architecture and file structure
• consistent naming conventions
• defined separation of concerns
• brand logic aligned with product reality

Everything is tailored to the product and the team at hand — never copied blindly from previous work.

Brand definition always comes first.
Whether supporting a single product or multiple products within the same organisation, brand logic acts as the connective tissue across product UI, marketing ecosystems, internal tools, presentations, and documentation.

Foundations define the primitives of the system.

This is where core design tokens are established — including:

• colour scales
• brand colours
• typography
• layout and spacing logic

Foundations never start “complete”.
Only the primitives required at the time are introduced, allowing the system to grow naturally as products evolve or new products are added.

This prevents premature complexity while preserving long-term scalability.

System logic applies across both architecture and workflow.

Key considerations include:

• separation between brand-level assets and product-level systems
• shared public libraries vs local product assets
• access control and role-based ownership within tools
• reducing risk from multi-person editing and accidental drift

Marketing ecosystems, internal tools, and business-facing materials draw from shared foundations — adapting locally where needed without destabilising the core system.

AI usage, roadmaps, company philosophy, and team structures are considered during system setup, ensuring the architecture supports real operational needs.

Documentation is introduced only when it adds value — evolving alongside the system rather than preceding it.

Once foundations are established, Themes are created per product.

Themes sit on top of Foundations and allow:

• product-specific brand expression
• independent evolution between products
• support for modes such as:
  • screen sizes and resolutions
  • devices and orientations
  • light / dark modes
  • localisation and multilinguality

Themes isolate change.
They allow flexibility and scale without affecting other products or the underlying system.

Semantic Roles apply meaning and intent to a themed system.

Where Themes provide adaptable values, Roles define how those values are used — supporting:

• accessibility
• consistency
• clear reasoning across interfaces
• alignment with development logic

Roles are never predefined in full.
They emerge and expand as design work progresses, ensuring the system reflects real product needs rather than hypothetical completeness.

This layer creates a shared language between design and development — reducing ambiguity during implementation.

Components and Screens are built last — once architecture, foundations, themes, and roles are in place.

This is where creative execution happens.

Components are:

• designed using Semantic Roles
• structured for responsiveness and variants
• organised into libraries by category and purpose
• governed through clear naming and usage rules

Libraries are treated as products themselves — accessible, understandable, and scalable across teams.

Screens are developed alongside components, often beginning in exploratory form.
Component needs emerge from screen design decisions, not the other way around.

Screen files focus on:

• layouts
• flows
• prototypes
• stakeholder and developer communication

Designers maintain and evolve component libraries in parallel — while teams collaborate primarily through screens and prototypes.

Light, developer-friendly documentation lives at the component level — explaining usage, variants, and implementation logic.

Product-specific styles (typography, colour usage, effects) are defined within the component layer — always aligned with the product’s intent and constraints.

When the full architecture is in place:

• responsibilities between team members are clear
• workflows remain coherent as teams grow
• brand, product, and marketing operate independently yet consistently

Marketing and business teams use shared public libraries and adapted local styles — supporting their needs without introducing system drift.

The result is a living enterprise system that remains flexible, controlled, and resilient over time.

This system is a practical application of LS Core — my framework for system-driven design, defining how structure, logic, and intent scale across products and teams.

If you’re navigating complexity across product, platform, or organisation — I work with teams and founders to bring structure, alignment, and long-term resilience into real-world systems.