A production-ready Palantir Foundry Ontology models the entities, events, and relationships people work with—not just the shape of the source datasets. Define object types around recognizable domain concepts, model relationships according to their meaning and cardinality, and route important changes through actions with explicit business rules, permissions, and operational monitoring. The right design depends on the domain, source data, workflow, and security requirements; there is no universal schema.
What should the Ontology represent?
Foundry’s Ontology is an operational, domain-facing model connected to an organization’s data and workflows. An object type defines a kind of real-world entity or event; an object is one instance of that type. Palantir’s documentation compares the distinction to a dataset schema and its rows, but a useful Ontology type should mean something to the people who use the system, rather than merely mirror a table name. See Palantir’s type reference and object types overview.
As an Amazon Associate I earn from qualifying purchases.
Foundry objects can be backed by data sources or created through actions. That supports a practical distinction between objects representing existing operational facts and records that originate in a workflow. Choose based on the entity’s lifecycle and the application’s needs, not on a rule that every object type must map one-to-one to a source table.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
How should you draw object-type boundaries?
Name domain concepts, not implementation details
Start with the nouns and events that domain experts use: for example, Employee, Department, Shipment, or Inspection. Use concrete, singular type names and concise property names. Palantir’s structural guidance recommends avoiding generic names such as “Data,” “Item,” and “Record,” as well as property names that expose implementation details. A type should remain intelligible if its backing dataset or pipeline changes.
#1 Best Overall
- Used Book in Good Condition
Keep canonical facts in one place
Palantir’s guidance puts it plainly: “Store each fact once. Use derived properties for convenience.” For example, avoid maintaining a manager’s report count as a manually edited value if that count should follow changes to linked employee records. A derived property can represent that changing relationship without requiring every affected manager’s stored counter to be updated.
Choose computation based on how stable the inputs are and when the value can change. Palantir recommends pipeline transforms for calculations based on stable properties on the same object, and derived properties for values that depend on linked objects or Ontology-level changes. Derived properties run at query time. The documentation describes them as generally suitable for low-to-moderate query scale under roughly 10,000 objects; above that scale, they may add latency, and selective denormalization may be appropriate. This is platform guidance, not a performance guarantee or benchmark. If you denormalize, document which value is copied, its source of truth, and how it is refreshed.
When should a relationship be a link or its own object?
A link type expresses a meaningful relationship between two object types. A direct link is appropriate when the relationship has no independent properties; when the association has its own role, dates, status, allocation, or workflow, model it as a first-class record instead. Palantir cautions against creating links solely because two datasets share a foreign key: the relationship should make sense in the domain.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →| Design choice | Use it when | What it represents |
|---|---|---|
| Direct link | The association has no attributes of its own. | A relationship such as Employee → Department. |
| Linking object | The association has its own dates, role, status, allocation, or workflow visibility. | A record such as Employee → Venture Staffing → Venture, where the staffing relationship carries its own information. |
| Join-table mapping | A many-to-many relationship is simple membership and does not need a first-class relationship record. | Key pairs connecting the two object types through a join table. |
Use the linking-object pattern when putting association-specific values on either endpoint would make them ambiguous—for example, when an employee can have different roles on different ventures. A simple many-to-many join table is a different implementation option when the relationship itself does not need those properties. Palantir’s link type creation documentation describes the mapping options; its structural guidance discusses modeling meaningful relationships.
How should cardinality and key mappings be set?
Decide the cardinality from the domain, then map keys to enforce the intended association. Foundry link types have two sides and can be traversed in either direction; creating one does not require a separate reverse link type. The link metadata includes related object types, cardinality on each side, key mappings, display and API names, and visibility. Details are in Palantir’s link type metadata documentation.
- One-to-one or one-to-many: map a foreign key to a primary key where that reflects the source relationship and intended cardinality.
- Many-to-many: use paired keys from a join table for straightforward membership, or use a backing object when the association needs its own properties or workflow.
- Both traversal directions: name and expose the relationship so users can understand it from either related type, without duplicating the relationship as another link type.
Before release, check that the configured keys actually identify the intended objects and that the declared cardinality matches the domain. A technically valid mapping can still produce a misleading model if its keys or cardinality encode the wrong business meaning.
Rank #3
How should actions govern changes?
An action type defines a set of edits to objects, property values, and links, potentially with side effects. It gives users a domain-level operation rather than an uncontextualized edit to an individual property. See Palantir’s action types overview and type reference.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Clear out junk files and repair common Windows errors3Fix the driver behind crashes, sound loss and screen glitchesUse submission criteria for business eligibility
Submission criteria—called validations in earlier documentation—determine whether an action may be submitted. Criteria can combine conditions involving the current user, parameters, objects, and relations, and are configured independently for each action type. Use them for rules such as whether a request is eligible or whether required conditions are met. Give users a useful failure message that explains what they can correct. Criteria do not grant permission to view or edit the action configuration; those are separate controls. See Palantir’s submission criteria documentation.
Specify the action’s operational contract
For each production action, record its intent, inputs, affected objects and links, criteria, side effects, and accountable owner. Make clear what the action changes and what it does not. This gives application owners and governance reviewers a common basis for assessing whether a proposed edit belongs in that workflow.
Rank #4
Decide what evidence successful submissions need to leave
Action logs are object types that can capture successful submissions and retain context beyond the individual values edited. Decide whether that context is needed for audit or later investigation, then define what should be recorded and who should be able to see it. Palantir documents the feature at action logs.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Which permissions need to line up?
Foundry separates access to Ontology resources—the object types, link types, action types, and their schemas—from access to the actual objects and links. A production review should account for both configuration access and data access, as described in Palantir’s object permissioning overview.
- Ontology configuration: identify who may configure the relevant types and action definitions.
- Data access: check who may read or edit the affected objects and links, and who can access their data sources.
- Action access and eligibility: ensure users can access the action and meet its submission criteria. Criteria are not a substitute for action permissions or data permissions.
- Writeback: whether a user also needs edit permission on a writeback dataset depends on the object’s edit policy. Palantir says new object types default to edits through actions and discourages opening additional edit paths solely to enable action-based editing, because dataset edit rights can expose more data than a workflow needs.
Action builders should verify underlying object and data permissions as part of release review: Palantir notes that these are not fully surfaced in the action configuration itself. The specific behavior depends on the edit policy and target environment; consult the action permissions documentation.
Assess read/write authorizations separately
Palantir marks read/write authorizations as beta in its documentation. Read authorization bounds the data an action may access, while write authorization sets a minimum security level for action outputs. Differing boundaries can permit declassification, so these controls require deliberate policy decisions and validation in the target Foundry environment. They do not replace user permissions or submission criteria. Verify availability and behavior against the applicable deployment; see Palantir’s read/write authorizations documentation.
How should you monitor actions after release?
Production governance continues after deployment. Palantir’s action metrics provide near-real-time usage information for the prior 30 days and categorize failures, including invalid parameters, scale limits, authentication, side effects, function failures, conflicts, and unclassified failures. Use these categories to investigate whether a failure points to an input or criteria problem, permissions, a side effect, a scale constraint, or another implementation issue. See action metrics.
Set an owner and review cadence appropriate to the action’s risk and use. A practical review can check submission volume, failure categories, unresolved incidents, changes to the underlying objects or links, and whether the action’s documented purpose and permissions still match how it is used. Metrics cover the documented 30-day window; they are not, by themselves, a durable audit record of successful submissions.
Recommended Free Tools
What should be checked before production?
- Validate the domain model: confirm that type names describe entities or events users recognize, and that each type has a clear boundary and source or creation path.
- Validate relationship meaning: decide whether each association has its own attributes, choose direct links or relationship records accordingly, and confirm cardinality and key mappings.
- Validate property behavior: identify canonical facts, distinguish stable calculations from values that depend on linked or action-edited data, and assess query-time implications.
- Validate the action contract: document the changes, inputs, rules, side effects, failure messages, and owner; decide whether successful submissions need logs.
- Validate authorization end to end: check schema configuration, object and link access, data-source access, action access, submission criteria, and writeback policy for the intended users.
- Validate operations: establish how action metrics and failures will be reviewed, and test beta authorization behavior and availability in the target environment if those controls are used.
Palantir’s Foundry documentation is a living product reference. Confirm tenant-specific permissions, current UI labels, beta status, and deployment behavior in the environment where the Ontology will run; this design guidance does not establish a universal schema or guarantee performance.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
