[ T-02 // TRACK ]
PIPELINES
Pipeline Builder and AIP task recipes, run against real data.
- [ FM-PB-01 ]
Your First Foundry Pipeline, Verified End to End
We built a real Foundry pipeline with one AIP prompt, deployed it, and verified the output row by row against source: 66 of 120 synthetic work orders, zero mismatches. The useful parts are the three field repairs: your Pipeline Builder output label is not the dataset's registered name, fresh datasets are invisible to Quicksearch for a while, and the dataset preview grid is canvas-rendered, so the honest way to check rows is to capture the preview API response and diff that. Nobody's docs tell you the last one.
- [ FM-PB-02 ]
When AIP Gets It Wrong: Adversarial Prompts in Pipeline Builder
We reran the friendly FM-PB-01 prompt verbatim against trap-laden data and AIP produced a chain that previewed as working while silently dropping 30 of 70 closed rows. When we asked AIP to fix it, it wrote the correct condition and then appended it after the broken filter, where it could do nothing. Three findings worth the read: AIP summaries describe intent, not effect; an AIP repair must be audited for placement, not just content; and the silent drop accidentally hid a second defect, four rows closed before they were reported. The repaired pipeline previews and builds 70 rows, matching ground truth exactly.
- [ FM-PB-03 ]
Pipeline Builder Fundamentals: The Vocabulary Palantir Assumes You Know
A guided tour of every Pipeline Builder surface that matters, photographed on a real deployed pipeline: graph anatomy, the four input paths, transform boards, outputs, the build system (deploy, schedules, monitored items), and the version model (saves, branches, proposals, history). The non-obvious findings: schedules attach to outputs rather than pipelines, the checkmark button in the top bar is a cross-pipeline build monitor, Pipeline Builder ships unit tests almost nobody mentions, and History is git-shaped with deployment as a pointer to a saved version.
- [ FM-PB-04 ]
Data Health Checks Are Tripwires, Not Gates
We put two failing data health checks on a live 70-row output dataset and forced two builds to find out what checks actually do. The core finding: a failing check never stops a build, at either severity, because there is no severity that blocks. Checks observe and report. Enforcement is a separate opt-in: auto-issues route a failure into a triage queue with an owner, a measured body line, and your note text carried verbatim into the issue. Also verified live: checks live on the dataset page, not in Pipeline Builder; they do not evaluate retroactively; and the Numeric range editor cannot save a single bound of exactly 0.
- [ FM-PB-05 ]
Snapshot Rewrites the World, Append Accumulates It
We built a second pipeline on a stream of synthetic work order batches to find out what transaction types actually are and who controls them. Verified live: file uploads create APPEND transactions with zero jobs, pipeline builds create SNAPSHOT transactions by default, incremental is a read-mode dropdown on the input node, and the output's Default write mode adapts on its own. The first build snapshotted (40s); after we appended a third batch to the source, the rebuild appended (52s), exactly as the write mode dialog promises. Row math checked: 19 source rows in, 18 output rows out, the one trap row filtered.
- [ FM-PB-06 ]
When the Board Isn't Enough: Your First Code Transform
We rebuilt the FM-PB-05 filter as a Python transform in a Code Repository to find out what the escape hatch actually costs and buys. Verified live: the 2026 template defaults to lightweight polars on a single machine (not Spark), the repo is a real git repository with a real remote, the Build button targets whichever file has editor focus (we learned this from a failed build), and the output is an ordinary dataset with the same SNAPSHOT transaction semantics Pipeline Builder uses. 19 source rows in, 18 out, the trap row filtered, plus one computed column no board expressed.
- [ FM-PB-07 ]
The Meter Is Running: What a Build Actually Costs
We built the same 19-row filter three ways (Spark via Pipeline Builder, lightweight polars via Code Repositories, DataFusion via a Faster pipeline) and read the meter on each. Verified live: identical logic cost 40 to 52 seconds on Spark, 20 seconds of job time on single-machine polars, and 6 seconds on DataFusion with the Small compute profile. We captured the creation-time feature matrix (what Faster cannot do), the deploy-time compute profile dial (Small is 1 core and 7.5 GB), the write format list (Default or PARQUET, nothing else), and the uncomfortable truth that on small jobs the queue and startup phases cost more than the query.