Palantir Application Developer – Associate Study Guide: Build One Inspection App on Paper, Layer by Layer
Many Application Developer – Associate questions are really one question: which component should own this? A validation rule, a computed score, a follow-up notification, a partner portal, a free-text classifier: each has a right home in Foundry, and the wrong options usually put it somewhere else. The best way to learn those homes is to build one application in your head and ask, at each layer, what the exam would ask. This guide does that with a simple equipment inspection app, from the data model to monitoring.
Study guide · Palantir Application Developer – Associate (PLTR-APD)

The exam in brief
85 multiple-choice questions in 3 hours, open-book, pass mark 70% correct, eight domains. Certificates are valid for two years, and there is a 14-day wait before a retake after a failed attempt. Palantir publishes no domain weights, so this question bank weights the eight domains equally. Check the official exam page for current details.
Of the 425 PLTR-APD questions in this question bank, nearly half are use-case questions ("the team needs X; what should the developer build?") and almost a third are troubleshooting scenarios. Action types are the most frequent topic, ahead of Automate, Workshop and Functions.
The example
Inspectors record pump inspections on tablets, supervisors review failures, contractors see their assigned work in a portal, and every failed inspection needs a follow-up task. We will build it layer by layer.
Layer 1: the model comes before the screens
- Pump is an object type keyed on the asset number from the system of record. Names and locations are not keys: when a key value changes, the platform sees a new object, and user edits and links appear to vanish.
- Inspection is its own object type, not a list property on Pump. It is an event with its own data (date, result, notes), linked many-to-one to Pump and to Inspector. History is then a link traversal sorted by date.
- If pumps, valves and compressors must be listed together, they share an interface, rather than being merged into one catch-all type with dozens of empty properties.
If a link looks empty although the target exists, compare key formats first (case, padding, prefixes), and check whether the user can see the target at all. Before renaming or removing anything, check Workflow Lineage for the modules, Functions, Actions and automations that depend on it.
Layer 2: writes go through Actions
"Record Inspection" is an Action type. Setting a few properties directly is a declarative Action. It becomes function-backed only when real computation or cascades appear: for example, a failed result that must also close the pump's open work orders and create a new one, all succeeding or failing together.
Good Action forms pre-fill from the current selection, offer valid lists and require a reason for consequential changes. But any rule about current object state or the acting user also belongs in submission criteria, with a message that names the failed rule.
Going deeper: why form constraints are not enough
A form is filled in against the object as it looked when the form opened. By the time the user submits, another user or an automation may have changed it: the inspection may already be approved, or the last spare part may already be reserved. Submission criteria are evaluated when the Action actually runs, against the current state and the acting user, so they still hold in that race. The same reasoning explains why conditional visibility in Workshop is not security, and why external applications should write through Actions too: the rule must live where every path passes through it. Running an Action also requires several independent layers to pass (permission to run the Action, permission to edit the objects, their markings, and the criteria), so diagnose a denial layer by layer.
Layer 3: logic lives in Functions
A pump's risk score from fixed rules is deterministic, so it belongs in a TypeScript v2 or Python Function, chosen by the libraries needed and the team that maintains it. "Top five pumps by failures this quarter" is a server-side filter and grouped aggregation, never a loop over every Inspection loaded into memory, and never a total computed from one page of results. A Function behind an Action returns all its edits together for the Action to apply in one submission. When a shared Function needs a breaking change, publish a new version, introduce new parameters as optional with defaults, and migrate consumers deliberately.
Layer 4: the supervisor's screen in Workshop
The review queue is a table of failed inspections; its selection variable feeds a details panel and pre-fills the Approve and Reject Actions. Think in variables, not separate queries per widget. Typical exam points:
- A value used to sort thousands of rows that changes daily should be stored as a property by a pipeline, not computed per row in the module.
- Variables recompute when anything they depend on changes; remove unneeded dependencies and load hidden tabs lazily. A spinner does not fix slowness.
- After an Action, refresh dependent widgets from its completion event instead of a fixed delay.
- An embedded module's inputs and outputs are a contract; compatible changes are additive.
Beginner tip: draw this example on one sheet of paper: the object types with their keys and link cardinalities, the Actions, the Functions, the module, the portal and the automation. Then, for every practice question you get wrong, write the fix onto the sheet in the box where it belongs. After a few sessions, the sheet shows you which boundaries you keep confusing, and those are the domains to revisit.
Layer 5: the contractor portal, Workshop or OSDK
Internal forms and tables fit Workshop. Custom branding, users without Foundry accounts or embedding in an existing application call for the OSDK. A hybrid shares the same Actions and Functions.
- Register the application with scopes that list exactly the object types and Actions it uses. A new feature that needs another Action needs a scope change and a regenerated OSDK.
- User-based OAuth when people sign in, so results and audit reflect individuals. Effective access is the intersection of the app's scope and the user's permissions: a user who can run an Action in Workshop still cannot run it through an app whose scope lacks it.
- Service-based client credentials for headless jobs, with the secret kept on a server. A secret in front-end code must be rotated and moved.
- Follow page tokens until none remain; use grouped aggregations instead of summing client-side.
- Calls that start failing once the access token's lifetime (
expires_in) has passed mean expired tokens are not being refreshed.
Layer 6: the follow-up task in Automate
"When an inspection fails, create a follow-up task" is an event trigger with a condition on the new status. Use schedules for periodic work such as a Monday digest of overdue tasks. A threshold is a transition: Automate's threshold condition fires when the limit is crossed (in either direction), not on every check while a reading stays above it. Two facts carry many points:
- Conditions and Action and Logic effects run with the automation owner's permissions; notifications use each recipient's. Ownership should sit with a team-controlled, least-privilege service user, not a person who may leave.
- Execution is at least once, so effects must be idempotent: check for an existing follow-up task before creating one, and send external calls with an idempotency key. The order of several Action effects is not guaranteed.
Layer 7: where AI helps
Classifying an inspector's free-text notes into a fixed list of fault types is a good AIP Logic task, with the output limited to that fixed list and a confidence value that routes uncertain items to triage. Routing by fault type, the risk score and permission checks stay deterministic. Store the AI suggestion and the human-confirmed value in separate properties, with the confirmation written by an Action. Code generated by AI FDE gets reviewed for the real schema, server-side queries, governed edits and idempotent side effects before it is published.
Layer 8: security and operations
Being able to open the app depends on access to the application resource. Seeing data inside it depends on the object types and backing data. Regional visibility is an object security policy; a sensitive property needs property-level control. Branch protection with required review guards Actions and Functions in production. For operations, monitor Action failures, Function latency, automation failures, data freshness and Ontology indexing lag: values that stay outdated for a while after a successful build point to indexing.
A study order
- Ontology schema design, then Action types; most other domains build on them.
- Functions, then Workshop.
- OSDK and external applications, then Automate.
- AI features, then application security and operations; finish with timed mixed sets.
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-APD exam page · All 485 PLTR-APD questions · Timed mock exam · 17-day study plan
- By domain: Ontology Schema Design and Workflow Assembly · Action Types and Write-Back Patterns · Ontology Functions · Workshop Application Development · OSDK, APIs, and External Applications · Automate and Operational Workflows · AIP Logic and AI-Powered Applications · Application Security, Governance, and Operations
Exam facts as described in Palantir's exam guide for the Application Developer – Associate certification. Domain weights are not published; check the official exam page for format and policy changes.