# netflix-uda-unified-data-architecture-knowledge-graph-2025-06-12

## Veille

Unified data architecture at Netflix, RDF/SHACL knowledge graph, domain modeling, Upper metamodel, semantic mappings, automatic GraphQL/Avro/Iceberg projections - Netflix Technology Blog

## Titre Article

Model Once, Represent Everywhere: UDA (Unified Data Architecture) at Netflix

## Date

2025-06-12

## URL

https://netflixtechblog.com/uda-unified-data-architecture-6a6aee261d8d

## Keywords

UDA, Unified Data Architecture, knowledge graph, domain modeling, RDF, SHACL, Upper metamodel, semantic integration, data catalog, schema registry, GraphQL, Avro, Iceberg, Data Mesh, mappings, projections, transpilation, PDM, Sphere, Netflix, content engineering, connected data, ontologies, SPARQL, named graphs, federated schemas, CDC, devil fruit, data discovery, operational reporting, SKOS

## Authors

Alex Hutter, Alexandre Bertails, Claire Wang, Haoyuan He, Kishore Banala, Peter Royal, Shervin Afshar (Netflix Technology Blog)

## Ton

**Profile:** Deep technical engineering dive | Institutional tech voice | Descriptive-technical register | Expert level

The Netflix engineering team adopts a deep technical exposé voice typical of the Netflix Tech Blog presenting its architectural innovations. The multi-author collaboration (7 engineers) signals a cross-team effort. Highly specialized language (RDF/SHACL, Upper metamodel, semantic mappings, SPARQL) aimed at senior data engineers. Systematic structure (problem → solution → implementation → results) demonstrating engineering rigor. A confident tone of technical authority sharing lessons learned at scale. Typical of big-tech engineering blogs (Uber, Airbnb, LinkedIn style) documenting complex systems for a community of engineers learning from scale challenges.

## Pense-betes

- **Core principle**: "Model once, represent everywhere"
- **Problem solved**: duplicated/inconsistent models, inconsistent terminology, data quality issues, limited connectivity
- **UDA = knowledge graph** for connected data across Content Engineering
- **RDF/SHACL foundations** but with enterprise-scale operational challenges
- **Upper metamodel**: model of all models, self-referential, self-describing, self-validating
- **Named-graph-first** information model for resolution, modularity, governance
- **Domain models** expressed as conceptual RDF within named graphs
- **Data container representations**: faithful interpretations of systems as graph data
- **Mappings**: connect domain models to concrete data containers
- **Projections**: produce concrete containers (GraphQL schema, Data Mesh source, Iceberg table)
- **Automatic transpilation**: domain model → GraphQL/Avro/Iceberg/Java with semantic preservation
- **PDM (Primary Data Management)**: controlled vocabularies with SKOS, generated UI
- **Sphere**: self-service operational reporting, discovery via business concepts
- **Upper built on RDFS/OWL/SHACL** but at a higher level of abstraction
- **GraphQL Federation**: support for federated schema generation
- **Intent-based automation**: UDA reasons about data movement while preserving semantics
- **Knowledge graph unifies**: domain models + transpiled schemas + mappings
- **Programmable via Java/GraphQL/SPARQL**
- **Semantic catalog**: tracks only assets connected to domain models
- **Spider-Man problem**: the same concept ("movie") modeled differently everywhere

## RésuméDe400mots

Netflix presents UDA (Unified Data Architecture), a groundbreaking infrastructure based on a knowledge graph to address the chronic fragmentation of data models across its Content Engineering ecosystem. The fundamental problem: core business concepts such as "actor" or "movie" are independently redefined in each system (GraphQL Gateway, asset management, media computing), creating duplication, terminological inconsistencies, quality issues, and limited connectivity.

**Foundational architecture: RDF/SHACL knowledge graph**

UDA adopts RDF and SHACL as technical foundations, but confronts major operational challenges at enterprise scale: RDF lacked a usable information model, SHACL was not designed for enterprise data with local schemas and typed keys, teams lacked shared authoring practices, and ontology tooling offered no support for collaborative modeling. Solution: a "named-graph-first" information model in which each named graph conforms to a governing model, itself a named graph within the knowledge graph.

**Upper Metamodel: the model of all models**

Upper constitutes the formal language for describing business domains or systems, organizing concepts into domain models: controlled vocabularies defining key entity classes, attributes, and relations. Crucially, Upper is a bootstrapping upper ontology: self-referential (it models itself), self-describing (it defines the concept of a domain model), self-validating (it conforms to its own model). Upper projects to a Java Jena-based API and a federated GraphQL schema in the Enterprise Gateway. Since all domain models are conservative extensions of Upper, seamless runtime integration guarantees consistent data semantics.

**Mappings and projections: connection and automation**

Mappings connect domain model elements to data container representations (GraphQL resolvers, Data Mesh sources, Iceberg tables). Everything is addressable: from the domain model down to the specific attribute, from the Iceberg table down to the individual column. Mappings enable bidirectional discovery: from the business concept to the physical system storing the data, and vice versa. Projections produce concrete containers implementing characteristics derived from the registered domain model, with automatic transpilation to GraphQL/Avro schemas preserving semantics.

**Production adopters: PDM and Sphere**

PDM (Primary Data Management) manages authoritative controlled vocabularies using the SKOS (W3C) model. It takes a domain model as input, automatically generates the UI, and provisions Domain Graph Services and Data Mesh pipelines via UDA projections. Consuming vocabularies are unaware of SKOS—they work with familiar domain terminology.

Sphere: a UDA-powered self-service operational reporting system. Discovery happens via business concepts ("actors", "movies"), not technical tables. The UDA knowledge graph generates SQL queries via graph traversal, eliminating manual joins and technical mediation. Aggregated metadata is presented with unified vocabulary, and data landscape boundaries and islands are identified automatically.

**Transformational impact**

UDA turns conceptual models into an active control plane: it not only documents concepts but generates schemas, provisions services, orchestrates data movement, and enforces consistency automatically. Future developments: Protobuf/gRPC support, materialization of instance data into the knowledge graph, and resolution of the original Graph Search challenges that inspired this work.

## GrapheDeConnaissance

- Netflix —a_créé→ UDA (TECHNOLOGIE, 0.99)
- UDA —est_basé_sur→ RDF (TECHNOLOGIE, 0.98)
- UDA —est_basé_sur→ SHACL (TECHNOLOGIE, 0.98)
- Upper —fait_partie_de→ UDA (TECHNOLOGIE, 0.97)
- Upper —permet→ génération de schémas GraphQL (CONCEPT, 0.95)
- Upper —permet→ génération de schémas Avro (CONCEPT, 0.95)
- UDA —permet→ PDM (TECHNOLOGIE, 0.96)
- UDA —permet→ Sphere (TECHNOLOGIE, 0.96)
- PDM —utilise→ SKOS (TECHNOLOGIE, 0.95)
- Sphere —permet→ génération de requêtes SQL (CONCEPT, 0.93)
- UDA —résout→ duplication des modèles (CONCEPT, 0.97)
- UDA —permet→ connexion des domain models aux conteneurs de données (CONCEPT, 0.95)
- Netflix —utilise→ principe "Model Once Represent Everywhere" (CONCEPT, 0.94)

---
Canonical: https://www.thekb.eu/en/fiches/netflix-uda-unified-data-architecture-knowledge-graph-2025-06-12/