cert-bank

Guides

이 글을 한국어로 읽기

Palantir Data Engineer – Associate Study Guide: Seven Short Rules Behind Most of the Scenarios

The Palantir Data Engineer – Associate exam is open-book, but looking things up will not save you. Its questions are scenarios: a sync produces stale data, an incremental build suddenly recomputes everything, some users see empty objects, a reviewer must choose between two designs. What decides them is judgement, and that judgement rests on a small number of rules that come back in every domain. This guide collects seven of them, with the trap that goes with each, so you can recognize them under time pressure.

Study guide · Palantir Data Engineer – Associate (PLTR-DE)

Palantir Data Engineer – Associate Study Guide: Seven Short Rules Behind Most of the Scenarios

The exam in brief

95 multiple-choice questions in 3 hours, open-book, with a pass mark of 70% correct. Certificates are valid for two years, and after a failed attempt there is a 14-day wait before a retake. The exam covers eight domains, from Data Connectivity and Ingestion to AI-Assisted Data Engineering. Palantir does not publish domain weights, so our practice sets weight them equally; do not skip any. Check the official exam page for current details.

Among the 475 PLTR-DE questions in this question bank, every one has a single correct answer, 31% are troubleshooting scenarios and another 19% ask you to weigh a trade-off. Plain definition questions are almost absent. The tools that come up most often are Code Repositories, Pipeline Builder, expectations and Data Health, so those four deserve the most attention.

Rule 1: choose the simplest option that meets the stated requirement

Read the scenario for the real requirement, then pick the least complex design that satisfies it:

  • A snapshot sync for a small or slowly changing table; CDC only when a large table changes often and deletes must be captured.
  • Incremental processing when freshness is daily; streaming only when a decision must happen within seconds.
  • A lightweight single-node engine for small inputs; Spark when data outgrows one node.
  • A direct connection when Foundry can reach the source; an agent only when the source sits in a network Foundry cannot reach.
  • Pipeline Builder for standard joins, filters and aggregations; Code Repositories for complex, tested or library-dependent logic.

Trap: the most powerful option. Streaming, CDC or a bigger cluster sounds impressive, but if nothing in the stem needs it, it is the wrong answer.

Rule 2: know the four transaction types

A Foundry dataset is a sequence of transactions. SNAPSHOT replaces the whole view; APPEND adds files and cannot change existing ones; UPDATE adds or replaces files while keeping the rest; DELETE removes files. Two consequences appear again and again: a SNAPSHOT containing only today's rows hides all the older ones, and an APPEND that would overwrite an existing file name fails.

Going deeper: why an incremental build suddenly runs as a full recompute

An incremental transform processes only the data added to its inputs since its last run. That works only while its inputs just gain new files. A SNAPSHOT, an UPDATE that modifies existing files, or a DELETE on an input changes or removes data the transform already processed, so that run falls back to a full recompute, unless the input is declared a snapshot input. Deletions by a retention policy have the same effect unless the transform sets allow_retention=True. When a scenario says "the incremental build ran as a snapshot", look at the input's transaction history first. The same mechanism explains two design rules: a pipeline is only as incremental as its weakest link, and switching an upstream sync to snapshot mode forces every incremental consumer to recompute, so the change must be coordinated. It also explains why running totals must be rebuilt, not added to, after a fallback; otherwise they double count.

Rule 3: find the first bad stage before you change anything

The exam guide's troubleshooting playbook runs: state the symptom precisely, find the first bad stage, classify the cause (data, code, permissions, resources or upstream), assess the blast radius, apply the smallest safe repair, verify, and add a control so it does not happen again. Some symptoms point in a fixed direction:

SymptomLook first at
Stale output, green buildsThe sync upstream: its history, the agent, the credentials
Exactly one page of records from an APIPagination in the sync configuration
Row count dropped, code unchangedInput transactions since the last good build, walking lineage upstream
A build is much slower than usualSpark details and Job Comparison against a normal run (small files, skew, a new duplicate join key)
A build's access suddenly failsThe executing identity, new markings upstream, the Check access panel

Trap: options that rebuild everything, add memory blindly or grant broad access before any evidence has been gathered.

Beginner tip: when you work through troubleshooting practice questions, write one word next to each before reading the options: data, code, permissions, resources or upstream. Then check whether the correct answer acts on that class. After twenty questions you will notice that most distractors fix the wrong class, for example buying memory for what is really a skewed join key. Many questions also ask what to do first; on those, the answer is usually the step that gathers evidence.

PLTR-DE: the troubleshooting playbook, step by step
1
State the symptom precisely
Stale output, one page of records, a row count drop, a slow build, failed access
2
Find the first bad stage
Walk lineage upstream before you change anything
3
Classify the cause
Data, code, permissions, resources or upstream
4
Assess the blast radius
How far the problem reaches, before any repair
5
Smallest safe repair, then verify
Not a full rebuild, blind memory or broad access
6
Add a control
So the same failure does not happen again
Work through the steps in order; on a question that asks what to do first, the answer is usually an early, evidence-gathering step.

Rule 4: expectations block, health checks alert

Expectations are assertions evaluated during a build: keys unique and not null, allowed values, schema, row counts. A failing expectation can fail the build, so the bad transaction is never committed and the last good version stays published. Health checks in Data Health watch datasets over time (freshness, size, schema, build status, content) and raise alerts about data that already exists. Decide by consequence: block when a violation would harm consumers and has no legitimate exception (duplicate primary keys); alert when the change might be legitimate (a 30% shift in average order value). Critical datasets usually need both. Remember too that a green build can still carry an empty, duplicated or stale dataset, which is why content checks exist.

Trap: deleting or overriding a failing check to get data through. Fix the data or correct the rule precisely.

Rule 5: access is layered, and markings follow the data

A user must pass every layer: the organization boundary, every marking on the data, and a project role with the needed permission. Markings are mandatory and conjunctive and propagate into derived datasets; even the Owner role does not satisfy a marking the user lacks. Restricted views filter rows per reader but cannot be used as transform inputs, have no column-level policies and do not propagate. For Ontology data, object and property security policies are recommended over restricted views for most use cases.

Trap: unmarking or moving sensitive data to make an error go away. To serve a wider audience, publish a separate derived dataset without the sensitive columns.

Rule 6: keys are identity

An object type's primary key must come from the entity's identity and survive rebuilds: an employee number, a shipment number, or a deterministic hash of identifying columns. Row numbers, names, emails and timestamps re-key objects when they change, which detaches user edits and links. Even trimming whitespace in the key logic can re-key objects. Link cardinality must match reality: many invoices to one customer is many-to-one. A many-to-many relationship that carries its own attributes, such as order lines with quantities, becomes its own object type.

Rule 7: south for shared and stable, north for interactive

South of the Ontology means computing in the pipeline and storing the result as a property; north means computing at interaction time in applications or functions. Deterministic, widely used values needed for filtering or sorting go south. Values that depend on what a user is doing right now go north. The same split applies to AI: reusable batch enrichment, such as classifying every ticket or building an embedding column for search, belongs in the pipeline; a free-form question about one record belongs at the application layer. AI output needs a constrained schema, validation, and the prompt version and model stored per row. Unparseable values are flagged, never guessed.

Role boundary: agents, prompts and interactive AI belong to the AI engineer. An option that makes the data engineer own the agent is usually a distractor.

A study order

  1. Processing modes and transactions (rules 1 and 2), then ingestion and sync patterns.
  2. Authoring tools, compute engines and testing; then schedules, lineage and the troubleshooting playbook.
  3. Expectations and Data Health.
  4. Security and projects, then Ontology modeling.
  5. AI-assisted engineering last, then timed mixed sets at under two minutes per question.

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.

Exam facts as described in Palantir's exam guide for the Data Engineer – Associate certification. Domain weights are not published; check the official exam page for format and policy changes.