In 2001, Natalya Noy and Deborah McGuinness at Stanford University wrote "Ontology Development 101: A Guide to Creating Your First Ontology" — a short, practical paper that has introduced more people to ontology building than any other single document. It accompanies the Protégé editor and walks through building a wine ontology from scratch.
Twenty-five years later, its method still holds. This guide summarizes the paper's seven steps and shows where each one happens in RDF Studio.
Read the original: Ontology Development 101 (PDF, Stanford) — about 25 pages, and worth every one of them.
The paper opens with three observations that beginners rediscover the hard way:
Answer four questions before touching a tool:
Competency questions are the paper's most enduring idea: a short list of questions the finished knowledge graph must be able to answer. They become your acceptance test.
In RDF Studio: competency questions map naturally to SPARQL queries you save in Query ▸ Library. When the ontology is right, the queries answer correctly — and they stay behind as living documentation. RDF Studio's AI-assisted generation flow (Model ▸ Generate) also produces competency questions for a generated ontology, for exactly this reason.
Almost every domain already has vocabularies worth borrowing: FOAF for people, SKOS for taxonomies, Dublin Core for metadata, schema.org for common things, and domain ontologies like FIBO for finance. Reusing them makes your graph interoperable with everyone else who reused them.
In RDF Studio: the create-database wizard's Reference Ontologies step lets you bring standard vocabularies in from the start, and Model ▸ Ontologies can import any ontology file into your database.
Brainstorm a flat list of terms before organizing anything. For a wine ontology: wine, grape, winery, region, vintage, color, body, sugar. Do not worry yet about which are classes and which are properties.
Organize the terms into classes and arrange them in a subclass hierarchy. The paper describes three strategies: top-down (start general, specialize), bottom-up (start specific, generalize), and combination — the most common, starting from the salient middle-level concepts.
The rule that catches most beginners: a subclass relationship means every instance of the subclass is a instance of the superclass. "Wine" is a subclass of "PotableLiquid"; "Winery" is not a subclass of "Wine".
In RDF Studio: build the hierarchy visually in Model ▸ Editor — classes on a canvas, subclass arrows between them, committed to the database when you are happy with the draft.
The terms left over after choosing classes are mostly properties: intrinsic qualities (a wine's body), extrinsic ones (its name), parts, and relationships to other objects (its maker — a Winery). Attach each property to the most general class that can have it; subclasses inherit it.
In RDF Studio: object and datatype properties are created in the same Model ▸ Editor canvas, with domains and ranges drawn as connections.
Cardinality (a wine has exactly one maker), value types, and allowed ranges. This is where a modern workflow diverges most from the 2001 paper: today the constraint story is split between OWL (what can be inferred) and SHACL (what data must look like to be valid) — a distinction the paper predates.
In RDF Studio: OWL restrictions live on the ontology in Model ▸ Editor; validation constraints live as shapes in Model ▸ Shapes, and GENERATE FROM OWL derives a first set of shapes from your OWL definitions automatically. The guide OWL vs SHACL: When to Use Which in this same Guides tab covers the split in depth.
Finally, fill the classes with individuals — actual wines, actual wineries — and check them against your competency questions.
In RDF Studio: instances are created and edited in Explore ▸ Browse, with forms driven by the ontology and validated by your shapes on every save. Then run the saved competency-question queries in Query ▸ Editor — if they answer, your ontology does its job.
Three things have changed around the method (not inside it):
The Northwind sample database that ships with RDF Studio is a finished worked example of all seven steps: a business domain (Step 1), reused vocabularies (Step 2), a class hierarchy over customers, orders, and products (Step 4), properties with chains and inverses (Step 5), SHACL shapes (Step 6), and full instance data (Step 7). The Northwind Ontology Walkthrough guide in this tab reads it in that order.