Palantir Foundry Aware Study Guide: It Is Open Note, So Build the One-Page Sheet You Will Actually Use
Foundry Aware is an open-note exam. That sounds like preparation is optional, but two minutes per question is enough to check one name, not to learn a product. This guide treats the exam as what it is, a test of whether you know where each answer lives, and walks you through building a single page of notes that answers most questions on sight. It has three parts: product by need, cause by symptom, and tie-breakers.
Study guide · Palantir Foundry Aware (PLTR-AWARE)

What you are walking into
60 multiple-choice questions in 120 minutes. It is a foundation-level exam that you become eligible for by completing Palantir's Foundry & AIP Aware course. It is free, open note and open website, and retakes are allowed. Palantir does not publish a pass mark or domain weights, so check the official exam page for current details.
Palantir publishes no exam domains, so this question bank splits its questions by the course's three sections and weights them equally; that is our assumption, not an official figure.
| Course section | What it asks of you |
|---|---|
| Getting Acquainted with Foundry & AIP | The platform's purpose, the Ontology, security, branching and the first end-to-end workflow |
| Building Blocks for Developers | Data Connection, REST ingestion in code, object and link types, actions, Workshop |
| Applying Foundry & AIP in the Real World | Scoping use cases, Machinery, AIP Logic, chatbots, Automate and Evals |
Why open note changes the way you prepare
Among the 225 Foundry Aware questions we wrote for this question bank, 85 (38%) are troubleshooting scenarios: something is broken and you must name the cause. Every one has a single correct answer. Searching is slowest here, because the stem describes a symptom, not a product name you could search for. If you already know that "times out before any login" means the egress policy, you answer in fifteen seconds and keep your look-ups for the questions that really need them.
So the goal is a short sheet, organised by the way questions are asked.
Data Connection (REST APIs through an external transform)
Pipeline Builder
A Workshop app whose buttons run actions
Machinery
Automate
Analysis only: Contour for tables at scale, Quiver for objects and time series
Part 1: which product for which need
Many stems name a need and offer four products. The course explains the platform as a map with the Ontology in the middle: things that feed it below ("south", in the course's words) and things people and agents use to act on it above ("north"). Put the need on the map first, then pick the product.
| The stem needs to ... | Look for |
|---|---|
| bring data in from an outside system | Data Connection (a source plus a sync); a REST API through an external transform in code |
| clean, join or split data | Pipeline Builder |
| give the business shared meaning | The Ontology: object types, links, action types, functions |
| let people decide and record the decision | A Workshop app whose buttons run actions |
| analyse tables at scale, or unmapped data | Contour; object and time series analysis with links: Quiver |
| see where a process gets stuck | Machinery |
| add an LLM step, or a chat assistant | AIP Logic; AIP Chatbot Studio |
| act on a condition or a schedule | Automate (for pipeline and connection monitoring, health checks instead) |
| prove an AI step is ready | AIP Evals |
| test changes before production; ship software everywhere | Global Branching; Apollo |
| use the Ontology as the backend of your own product | The Ontology SDK (OSDK) |
Add one line of vocabulary under the table. An object type is like a dataset, an object like a row, a property like a column and a link like a join. A filtered group, such as all trucks in repair, is an object set, not a new type. A dashboard that only shows late shipments is analytical; a tool where the dispatcher reassigns the shipment and the decision is recorded is operational.
Beginner tip: the course's first speedrun is the moment the table above stops being a list of names. Do it with your own small example: two tables (shipments and warehouses), one pipeline that joins them, one Shipment object type linked to Warehouse, one Workshop page with a "reassign" action. Then write on your sheet which product did each step.
Part 2: symptom lines
This is the part that saves the most time. Write each line as "if you see this, look there first".
| Symptom in the stem | Look first at |
|---|---|
| Connection times out before any login | The egress policy: host, port, or still pending approval |
| Certificate path error | A missing server certificate on the source |
| Every build writes exactly one page of records | Pagination in the external transform |
| Code committed, but no dataset exists | Nobody ran a build; a commit only runs checks |
| A union fails | Mismatched schemas; rename or cast first |
| The app was right once, now it is stale | A missing schedule |
| A project Owner cannot open a dataset | A marking the Owner is not a member of |
| The app keeps the planner's value after a new source update | User edits win by default |
| Two users see different rows in one table | Object security policies or markings, not a bug |
| A change to an embedded module shows nowhere | It was saved but not published |
| A long chatbot conversation ends in an error | The context window; inject fewer properties |
| An automation stops after someone leaves | Effects run as the automation owner |
Going deeper: why the Owner role cannot beat a marking
Foundry has two kinds of access control. Project roles (Owner, Editor, Viewer, Discoverer) are discretionary: they grant access, and an Owner can share further. Markings are mandatory: a user must be a member of every marking on a resource, a boolean AND, and no role overrides that. Removing a marking needs the marking's own Expand Access permission, not the Owner role. Markings also propagate, so a summary derived from a PII dataset stays restricted even after it moves to another project. Hence the design rule: grant access with group roles on the project, and use markings only to restrict or hide.
Part 3: tie-breakers
When two options would both work, the course and the documentation usually lean the same way:
- Integrate, do not replace. Foundry and AIP sit on top of the ERP, CRM and warehouse and write decisions back to them. Merging three ERPs before a use case can start is the distractor.
- Controls over instructions. An action with submission criteria, or a chatbot tool that runs only after the user confirms, beats a prompt that says "be careful". Agents work under the same permissions as people, never a broader path.
- Evidence before change. An Evals suite run several times before swapping a model; a branch and an approved proposal before merging; revert first when a merged change breaks output.
- Start from the decision. A use case is a time-bound effort for one decision and named users. Syncing a whole HR system "in case it is useful later" is the opposite.
Going deeper: writeback or side effect webhook?
An action type can reach an external system of action, such as an ERP, through a webhook in two ways. A writeback runs before the action's other rules; if it fails, the Ontology edits do not happen, and an action can have only one. Side effects run after the edits, can be several, and suit best-effort notifications or updates to multiple systems. So when the external system must accept the change first, only a writeback guarantees it.
Using the two minutes
Read the last sentence of the stem first: it says whether you are asked for a product, a cause or a next step, which tells you which part of your sheet to open. Answer from the sheet when a line matches. Search only for a specific named setting, and drop a search after a minute. Be wary of absolute words ("always", "every", "only", "never"): in our practice sets, 45% of wrong options contain one, against 14% of correct answers.
Beginner tip: do your first full practice set with a timer and your sheet, and nothing else open. Each time you need to search, add the answer as a new line on the sheet. After two sets, the sheet stops growing; that is the sign it is ready.
Building the sheet in four sittings
- Section 1: the decision components (data, logic, action, security), the Ontology vocabulary, south and north, projects and markings, branching and Apollo. Fill Part 1 of the sheet.
- Section 2: sources and syncs, egress policies, REST ingestion in code, object keys and link cardinality, actions and Workshop wiring. Most of Part 2 comes from here.
- Section 3: scoping a use case, Machinery, AIP Logic, chatbots, Automate and Evals. Finish Part 2 and write Part 3.
- Practice: timed sets with only the sheet, adding a line for every look-up.
Practise
Practise in the question bank: every question explains each option, right and wrong. Start with the domain you just studied, then take a timed mock exam.
- PLTR-AWARE exam page · All 285 PLTR-AWARE questions · Timed mock exam · 12-day study plan
- By domain: Getting Acquainted with Foundry & AIP · Building Blocks for Developers · Applying Foundry & AIP in the Real World
Exam facts as described for Palantir's Foundry Aware exam and the Foundry & AIP Aware course. The pass mark and domain weights are not published; check the official exam page for format and policy changes.