Skip to content

SYSTEM Cited by 1 source

Netflix Upper (UDA metamodel)

Upper is the metamodel — "the model for all models" — inside Netflix's UDA. It is the language in which every domain model (business or system) is written, and it is itself a domain model of itself (Source: sources/2025-06-14-netflix-model-once-represent-everywhere-uda).

What Upper is

Upper is "a language for formally describing domains — business or system — and their concepts." Domain models authored in Upper are controlled vocabularies that define:

  • Keyed entities — classes with identity.
  • Attributes — typed properties of those classes.
  • Relationships — connections to other entities (keyed or nested; same domain or cross-domain).
  • Taxonomies of types — keyed concepts organised into type hierarchies within a domain, arbitrarily complex.
  • Monotonic contribution — "Keyed concepts can also be extended from other domain models — that is, new attributes and relationships can be contributed monotonically." New additions never retract prior facts (concepts/conservative-extension).
  • Customisable datatypes — Upper ships a rich datatype library for attribute values, extensible per domain.

Upper is built from W3C semantic technologies — carefully

"Upper raises the level of abstraction above traditional ontology languages: it defines a strict subset of semantic technologies from the W3C tailored and generalized for domain modeling. It builds on ontology frameworks like RDFS, OWL, and SHACL so domain authors can model effectively without even needing to learn what an ontology is."

Upper's foundations:

  • RDF — conceptual data model; triples.
  • RDFS — basic class / property / subclass primitives.
  • OWL — advanced class-expression machinery.
  • SHACL — shape constraints.

Upper takes a "strict subset" of these + generalises some mechanisms (notably cross-graph resolution) + hides the rest. The authoring audience is domain experts, not ontologists.

Self-referencing / self-describing / self-validating

"Upper is the metamodel for Connected Data in UDA — the model for all models. It is designed as a bootstrapping upper ontology, which means that Upper is:

  • self-referencing, because it models itself as a domain model;
  • self-describing, because it defines the very concept of a domain model;
  • self-validating, because it conforms to its own model."

This is the self- referencing metamodel bootstrap pattern. The practical payoff:

  • Zero special-casing. Upper's runtime treats Upper itself using the same machinery as any other domain model.
  • Upper's own projections are dogfooded. "Upper itself is projected into a generated Jena-based Java API and GraphQL schema used in GraphQL service federated into Netflix's Enterprise GraphQL gateway. These same generated APIs are then used by the projections and the UI." The metamodel is its own first customer.
  • Every Upper tool works on Upper itself. Query, diff, version, validate — the metamodel is just another graph.

Conservative extension is the composition rule

"Because all domain models are conservative extensions of Upper, other system domain models — including those for GraphQL, Avro, Data Mesh, and Mappings — integrate seamlessly into the same runtime, enabling consistent data semantics and interoperability across schemas."

A conservative extension adds new vocabulary + axioms without invalidating any prior inference. In UDA this means:

  • Business and system domain models can grow independently.
  • Adding a new system-domain extension cannot break any business domain's projection.
  • The runtime semantics are guaranteed to be a consistent union across all loaded domains.

This is the algebraic analog of schema-evolution backward-compatibility (concepts/schema-evolution).

Upper domain models are data

"Upper domain models are data. They are expressed as conceptual RDF and organized into named graphs, making them introspectable, queryable, and versionable within the UDA knowledge graph."

Models-as-data (not code) means:

  • Version control is free — domain models diff + merge as triples.
  • Querying is free — SPARQL over the graph answers "what concepts depend on X?" or "what domains extend Character?" directly.
  • The knowledge graph is a single substrate for domain models, the schemas they transpile to, and the mappings between them.

Role inside UDA

Upper is the fixed point at the bottom of UDA. Every other domain model — including system domains for GraphQL, Avro, Data Mesh, Mappings, and mappings themselves — extends Upper. The transpiler family (patterns/schema-transpilation-from-domain-model) reads Upper-shaped input and produces concrete schemas as output.

Open source

Netflix has published the UDA repository — including Upper-modelled example domains (onepiece.ttl) — at github.com/Netflix-Skunkworks/uda.

Caveats

  • Upper's exact class / property vocabulary is not enumerated in the post. The open repo is the authoritative reference.
  • Transpiler mechanics opaque — how Upper constructs project into each target schema is not described.
  • Runtime scale unreported — Upper-runtime footprint at Netflix is not disclosed.

Seen in

Last updated · 319 distilled / 1,201 read