Think Like an FDE II: The Ontology Is the Business
The ontology is not a database schema with nicer names. It is the business rendered as things and the verbs that change them: nouns become object types, verbs become action types, judgment becomes functions. This module teaches the interview method that produces that model: how to sit with ops people, extract the nouns and verbs they actually use, find the decision inside the conversation, and know when a noun is really a report or a verb is one nobody is allowed to run. Every modeling claim is anchored in the Avinyr labs: FM-ON-01 (rows into Work Order objects, identity is RID and API name), FM-ON-02 (the action renamed from mechanism to operator verb, submission criteria as authorization, the dry run as proof), and FM-ON-03 (functions as encoded judgment, with the platform enforcing the contract).
- FM-FDE-01. The three questions (decision, decider, what they need to see) are the input to the interview method here. Read it first.
Field notes from the Avinyr lab. This module has no screenshots because it is not about clicking. It is about the conversation you have before the clicking, and how that conversation becomes object types, link types, and action types. Every claim below is anchored in a lab we ran; where we cite evidence, we cite the module that holds it.
[ READ THIS FIRST: WHAT THIS MODULE IS ]
FM-FDE-01 gave you the stance: find the decision, find who makes it, find what they would need to see. This module is the next craft down. Once you have found the decision, you have to model the slice of the business that decision lives in, and the modeling happens in an interview, not in a schema tool.
The thesis, stated plainly: the ontology is not a database schema. It is the business rendered as things and the verbs that change them. Nouns in the operator's mouth become object types. Verbs become action types. The judgment calls, the rules of thumb the senior person carries in their head, become functions. If your ontology reads like the source system's table list, you modeled the database. If it reads like the way the operation talks about itself, you modeled the business.
This is a doctrine module. We do not walk a build. We show you how we run the conversation, what we listen for, what we reject, and we prove each rule with something that actually happened in FM-ON-01, FM-ON-02, or FM-ON-03.
[ WHAT YOU WILL HAVE AT THE END ]
A working method for the modeling interview: how to prepare it, the questions that surface the real decision, the translation rules from speech to ontology, the red flags that tell you a noun or verb is fake, and the anti-patterns that produce ontologies nobody uses. Plus a map from each rule to the lab evidence that taught it to us.
| What you might expect | What the labs actually taught us |
|---|---|
| Modeling starts from the client's tables | Modeling starts from the operator's sentences. FM-ON-01's cautionary twin, asset_tbl, is what table-thinking produces: schema mismatch, unindexed, zero objects |
| Display names identify things | Two types named Work Order coexist on our enrollment. Identity is RID and API name (FM-ON-01, FM-ON-02) |
| An action is a database update with a form | The wizard named ours "Modify Work Order", a mechanism. We renamed it "Reassign technician", the operator's verb (FM-ON-02) |
| Permissions are an admin afterthought | Submission criteria are an authorization decision you make in the interview, not in the wizard (FM-ON-02) |
| Business rules live in a wiki page | Ours live in a published TypeScript function, and the platform's linter enforces the contract: ""number" is not a supported type." (FM-ON-03) |
| You can trust the names people give you for values | "United Airlines" matched zero rows; the stored value reads "United Air Lines Inc." Probe real values before you model filters (FM-ON-03) |
[ THE TRANSLATION: NOUNS, VERBS, JUDGMENT ]
The whole method is one translation, run three times.
Nouns become object types. When the maintenance lead says "I need to know which work orders are blocking the north site", you hear two object types: Work Order and Site or Asset. Not a table called wo_hdr. In FM-ON-01 we did exactly this: the enriched work order rows from the FM-PB-01 pipeline became a Work Order object type, 66 objects, Indexed, and the repeating asset values became their own Asset type, 66 objects, fed by an aggregate pipeline we built for the job. The noun earned its own type because the business treats the asset as a thing with its own identity, not as three columns on a work order row.
Verbs become action types. When the lead says "I reassign it to whoever has capacity", that sentence is an action type waiting to be built. In FM-ON-02 we built it: a Modify action on Work Order with one parameter, Technician, mapped to the Technician property. The wizard's default name was "Modify Work Order". That is the mechanism talking. We renamed it "Reassign technician" because that is the operator's verb, and six months from now nobody remembers what "Modify Work Order" was for. The name is not cosmetics. The name is the model.
Judgment becomes functions. When the senior person says "show me the top aircraft by carrier, most flights first", that is not a filter on a dashboard. It is a piece of judgment, a ranking rule, and it belongs in code where it can be tested and reused. In FM-ON-03 we wrote it as topAircraftByCarrier: filter carrierName, order flightCount descending, return the summary. Published, tagged 0.0.2, verified against live runs. The rule of thumb stopped living in one person's head.
Hold the three translations together and the ontology stops being a diagram. Things, the verbs that change them, and the judgment that ranks and routes them. That is the business.
[ IDENTITY IS NOT A NAME ]
One modeling rule the labs taught us the hard way, and it shapes what you write down in the interview.
Names are not identity. Our enrollment currently hosts two object types named Work Order: ours (66 objects, Indexed, on our branch) and a demo twin (0 objects, schema mismatch, "Index not found", on main). Display names are not unique; the platform told us so by hosting both. Identity is the RID and the API name: ours is w8mkkb8q.id-aad52020-2f29-9364-f47c-819fd3a14432 with API name MaintenanceWorkOrder, and the demo twin is w8mkkb8q.good-work-order-f2443707. FM-ON-01 hit API name conflicts twice on save, because API names are enrollment-wide unique and case-insensitive.
The interview consequence: when an operator says "the work order", you do not yet know which thing they mean. Ask what makes one work order different from another (that is your primary key candidate), ask what other systems call it (that is your link and lineage surface), and never let the display name do the identifying. Two departments will use the same noun for different things and different nouns for the same thing. The API name is where you settle it, and FM-ON-01's naming doctrine applies: prefix by domain, never ship a bare noun, decide the convention before the first object type.
[ THE METHOD: THE MODELING INTERVIEW ]
Here is how we run this conversation. One operator or two, at their desk or their board, sixty to ninety minutes, after you have already shadowed them (FM-FDE-01's day 1 and 2). The shadowing gives you the raw transcript of the work; the interview is where you turn it into a model.
Step 1: replay the day. Ask them to walk the last real instance of the decision, not the general process. "Talk me through the last work order you triaged this morning. What did you look at first?" General questions get process-document answers, and process documents describe the org as designed, not as lived. Specific instances get the truth.
Step 2: transcribe their nouns and verbs verbatim. Do not translate as you listen. Write down the words they use, including the wrong ones, the abbreviations, and the jargon. "The CON unit at North Ridge ate another belt, I kicked it to Kowalski" contains an asset (CON unit), a site, a failure mode, an action (kicked it to), and a technician. Five modeling candidates in one sentence. You will clean the names later; you cannot recover a noun you did not write down.
Step 3: test each noun. For every candidate object, ask three questions. Does it have an identity of its own (one asset, many work orders about it)? Does anyone need to find it directly, not through something else? Does anything happen TO it? Three yeses: object type. If the noun fails the identity test, it is probably a property. If it is a list someone reads but never points at, it is probably a report, not an object. See the red flags below.
Step 4: test each verb. For every verb, ask: who is allowed to do this, what has to be true before they do it, and what does the world look like after. Those three answers are your submission criteria, your parameter validation, and your edit mapping. In FM-ON-02, "who is allowed" became an explicit authorization decision in the wizard (Organization, everyone in Yousufss), and we called it what it is: the front door guard, set on purpose, separate from the datasource permissions that guard the back door. A verb with no owner and no gate is not an action; it is a wish.
Step 5: find the judgment. Ask the senior person the question that separates them from the new hire: "When two of these come in at once, how do you pick?" The answer is a ranking, a threshold, a routing rule. That is a function. FM-ON-03's topAircraftByCarrier is exactly this shape: a filter and an ordering, the senior person's instinct written down as code. Write these down even if you cannot build them yet; they are the highest-value content in the interview.
Step 6: play the model back. Before you build anything, say the model back in their words: "So a Work Order services one Asset, a technician gets reassigned, and when two land at once you rank by downtime." Watch for the wince. The wince is the model being wrong while it is still free to fix.
[ QUESTIONS THAT SURFACE THE REAL DECISION ]
The ones that work, collected from how we scope our own labs:
- "What did you decide this morning, before you opened any tool?" Finds the decision, not the workflow.
- "Show me the last time this went wrong." Wrong is where the model's edge cases live. FM-ON-03's exact-match miss (List 0 for "United Airlines") is a gone-wrong story about names, and it is why we probe real stored values before we model any filter on them.
- "What do you write down that the system does not?" The side spreadsheet and the whiteboard are unmodeled objects and unpriced judgment.
- "Who is not allowed to do this?" Authorization is a modeling input. If the answer surprises you, your action's submission criteria just changed.
- "What would you never automate?" The answer marks where the action ends and the human's call begins. Build the verb up to that line and no further.
[ RED FLAGS ]
Signals in the conversation that the model is going wrong:
- A noun that is really a report. "I need the overdue list." A list is a view over objects, not an object. If the noun has no identity and nothing happens to it, model the things underneath it and make the list a filter.
- A verb nobody is allowed to do. If the operator describes a change and then adds "but that has to go through three approvals and never actually happens", the action is not the verb they said. The real verb is the approval request. Model the one the org will actually execute, or you have built a button nobody presses.
- An "object" that is just a join. If the proposed object exists only to connect two other things and carries nothing of its own, it is a link type, not an object type. FM-ON-01's link menu makes the distinction mechanical: foreign key for one-to-many, join table for many-to-many, backing object type only when the relationship itself has properties. Read the relationship's own nouns (does a contract between two parties have a start date? then it is a thing) before you promote a join to an object.
- Names you have not checked against stored values. Operators speak in short names; systems store long ones. "United Airlines" versus "United Air Lines Inc." cost us a zero-row run in FM-ON-03. Probe before you model.
- A model that matches the source tables one to one. That is not a model. That is the database wearing a name tag, and the next section covers what it costs.
[ ANTI-PATTERNS ]
Modeling the database instead of the business. The enrollment we work in carries the cautionary tale: asset_tbl, API name badAssetTbl, self-described as a "BAD EXAMPLE (database mirror)" that lumps two genuinely different real-world things into one table, leaving most columns null for any given row. Its fate, documented in FM-ON-01: a red schema-mismatch banner, "Index not found", zero objects, and a seat on the list of stale resources pinning our merge proposal. The platform punishes table-thinking mechanically, in index status and merge checks, not philosophically. Our Asset type beside it: one real-world thing, three clean properties, 66 objects, Indexed, linked. The mirror of the source system is the single most common way an ontology dies.
The read-only ontology. FM-ON-02 named this one in its opening line: a read-only ontology is analytics with better naming. If your model has objects and links but no action types, you have built a very expensive dashboard. The interview is where this is prevented. If you leave the room without a single verb that someone is allowed and willing to execute, you did not find the business; you found its reporting layer. Go back and ask what changed in the world the last time the decision got made.
Skipping the proof. Modeling is a claim, and claims get verified. FM-ON-02's dry run is the pattern: before anyone pressed Reassign technician for real, the Test run computed the exact edit against live state, Technician struck through from S. Kowalski to T. Nguyen, "Modifies 1 Object", 0.386 seconds, zero bytes written. The verb was proven to mean what the operator meant before it could touch anything. Whatever you model, demand the equivalent proof before the first real run.
[ FAQ ]
How many object types should a first model have?
Fewer than you think. FM-ON-01 taught the whole motion with two types and one link. If your first model has fifteen object types, you are modeling the org chart, not a decision. Model the slice that serves one named decider, ship it, expand from evidence.
The client already has a data model. Can I just import it?
You can mine it for vocabulary, but you cannot import its assumptions. A schema tells you what the system stores. The interview tells you what the business decides. Where they disagree, the interview wins, and asset_tbl is what you get when they are forced to agree.
What if two operators describe the decision differently?
Good. That disagreement is the modeling content. Sit them together, play each version back, and make them reconcile it in front of you. What survives is the model. What does not is a property or a view, not a type.
When do I write functions versus configuring in the UI?
When the rule is judgment (ranking, routing, thresholds) rather than lookup. FM-ON-03 shows the shape: judgment in TypeScript, published, versioned, callable. And expect the platform to enforce its contracts on you: the linter rejected our plain number with ""number" is not a supported type." until we used Long from @osdk/functions. The contract is strict because functions are where the business's rules live.
Do I need Foundry access to run this interview?
No, and you should not have it open. The interview produces a nouns-verbs-judgment sheet that is platform-neutral. Foundry enters when you turn the sheet into object types, action types, and functions, which is FM-ON-01 through FM-ON-03.
[ OPEN QUESTIONS ]
- The labs exercised one operation (maintenance triage) and one synthetic dataset. The method above is stated generally but evidenced narrowly; other domains may add red flags we have not met.
- We have not yet run the full loop from interview sheet to merged, applied writeback. The applied write landed in FM-WS-02, and the capstone (FM-CAP-01 onward) takes one interview end to end.
- How the method scales to multi-team ontologies with shared types is untested in our labs. The branch-wall findings in FM-ON-01 and FM-ON-03 suggest governance pressure arrives earlier than you expect.
[ NET POSITION ]
The ontology is the business, written down as things and verbs. Get the nouns from the operator's mouth, not the database's table list; give each thing an identity that is RID and API name, never display name. Turn the verbs into action types named for what the operator is doing, gated by submission criteria you chose on purpose. Put the judgment in functions where it can be tested and reused. Prove every verb with a dry run before anyone presses it for real. The interview is the modeling tool; Foundry is where the model becomes executable. Run the conversation well and FM-ON-01, FM-ON-02, and FM-ON-03 stop being three labs and start being one motion: rows into things, things into decisions, decisions into changed state.