WorkAboutContact
Back to Work
Enterprise governanceHierarchyPermissionsContent systems

Designing Content Governance for Enterprise Franchise Networks

Creating a tag-based inheritance and publishing model that allowed corporate teams to distribute reusable marketing content across a large local network while preserving local customization.

Recreated enterprise content management interface concept with settings navigation, tags, content, companies, search, filtering, and governance table rows.
Recreated enterprise content management governance concept visual.

1. Executive Summary

A large franchise organization needed specialized tooling to manage content across a distributed network. The system had to let corporate teams create reusable marketing content, group content by tags, distribute it across many local accounts, and still allow local operators to customize content for their own location.

The design problem was governance, not content editing. Users needed to understand who controlled what, which studios inherited which content, how tags connected content and companies, when changes were pushed, and how centralized content became locally relevant.

2. System Context

Mental model:

Platform Admin -> Corporate Users -> Local Operators

Content types included journeys, segments, templates, campaigns, brand assets, sign-up units, and brand values.

The system connected parent organizations, corporate teams, local locations, tags, content groups, content items, organization variables, publish actions, sync status, and history.

Visual Artifacts

Enterprise hierarchy model

Recreated hierarchy diagram showing how platform admins, corporate accounts, franchise groups, and local locations relate across governance layers.

3. The Real Problems

Enterprise hierarchy made content ownership hard to understand. Corporate users needed to know which level controlled content, which level received content, and which local edits remained under local control.

Tags created tiered content membership. Tags could classify content and companies across tiers, appointment types, regions, languages, verticals, or franchise-specific needs.

Centralized content still needed local relevance. Local teams needed editable versions and structured variables such as booking links, phone numbers, location names, and social links.

Governance actions had downstream consequences. Adding a tag, removing a tag, adding content, or publishing changes could affect many child studios.

4. Design Principles

  • Enterprise platform design depends on making relationships visible.
  • Governance should be explicit before changes are distributed downstream.
  • Central control and local autonomy can coexist when variability is structured.
  • Tags can act as governance metadata, not just labels.
  • Publishing actions should explain consequences before they happen.
  • Sync visibility and source indicators build operational trust.

5. Major Decisions

Make Tags The Connective Tissue

One-off content-to-company assignment would not scale across many studios and changing franchise structures. Tags became the relationship layer between content and companies.

This made the system flexible, but also more abstract. The interface needed to show which content and companies were connected by a tag and what would happen when membership changed.

Balance Central Governance With Local Autonomy

Fully locked corporate content would be too rigid. Fully local content creation would be too hard to govern.

The model distributed content to local teams as editable versions, with organization variables providing local details. This created controlled variability: centralized templates plus structured local values.

Make System Consequences Visible

The design needed to show sync status, source indicators, tag history, and prompts explaining what would happen before changes were pushed.

Complex admin systems need previewable consequences, not only completion states.

Support Manual Push / Publish

Automatic sync on every change could create confusion or accidental downstream changes. Explicit push/publish behavior created a deliberate checkpoint before high-impact changes were distributed.

6. System Evolution

Requirements / RFC
-> hierarchy and tag model
-> content/company IA
-> push/publish workflow
-> sync visibility and operational trust

The model moved toward Content and Companies as primary concepts, with tags managed in context as the relationship layer.

7. Collaboration Model

I worked with product, backend engineering, frontend engineering, admin stakeholders, product stakeholders, and implementation partners.

The project brief captured many technical and business requirements. My design challenge was translating those requirements into a product model that admins and corporate users could understand, trust, and operate.

8. Results

Visual Artifacts

Company tag management

Recreated company management surface showing how corporate users could review studios, edit tag membership, and understand sync status in one governance table.

Product outcomes:

  • Helped define enterprise franchise content governance workflows.
  • Translated hierarchy, tags, sync, source, and publishing requirements into a usable product model.
  • Moved the IA toward Content and Companies as primary concepts with tags managed in context.

Business outcomes:

  • Supported tooling for onboarding and managing a large distributed network.
  • Supported corporate control while preserving local customization.

9. Reflection

This project sharpened a platform design principle: governance is often metadata plus consequences.

Tags, source indicators, publish actions, sync status, and history are not administrative details. They are the user's mental model for how control moves through the system.

10. Reusable Patterns

  • Tag-based inheritance.
  • Parent/child hierarchy model.
  • Controlled variability.
  • Editable local-version distribution.
  • Company variables and macros.
  • Manual push/publish.
  • Source indicators.
  • Sync status.
  • Governance through metadata.
  • Consequence-preview prompts.

11. Lessons That Carried Forward

This project reinforced a lesson that also appears in integration, data ingestion, and observability work: users need to understand relationships and consequences before they can trust a system.

Recommended next case studies