Free Palantir Foundry Application Developer Certification Sample Questions

Correct answer: B — Configure an Action Type in the Ontology to update the loan status, and add an Action button to the dashboard.

• A. Exporting data to CSV and emailing it is a manual workaround, not an operational workflow inside Foundry. This approach lacks traceability, introduces significant delays, and keeps the data static rather than actionable.
• B. The most appropriate first step in Foundry's operational framework is to define an Action Type in the Ontology. This allows users to update loan status or other properties in a governed, auditable, and secure way. Integrating an Action button into the dashboard (such as in Workshop) then allows analysts to trigger that workflow directly from the interface.
• C. A Python script in Code Repositories is typically used for automated data transformation or batch processing. It is not the correct tool for enabling analysts to interactively flag specific loans from a dashboard, as it bypasses the user-interaction layer and the Ontology.
• D. While Slate can be used to build custom UIs, rebuilding a dashboard with custom JavaScript to directly mutate datasets is a non-standard pattern that bypasses the governance and simplicity of the Ontology. Action Types are the preferred, native way to implement operational changes.

Correct answer: B — An operational workflow allows users to take actions that write back to the ontology or trigger external systems.

• A. Incorrect. Real-time streaming versus daily refresh relates to data latency and update frequency rather than the core distinction of the workflow type. Both operational workflows and dashboards can support varying data update cadences depending on the underlying pipeline design.
• B. Correct. The defining characteristic of an operational workflow is interactivity and agency. It centers on user actions that change the state of the business, such as writing back to the Ontology, updating object properties, creating tasks, or triggering external processes. In contrast, a static dashboard is primarily for passive data consumption and analysis.
• C. Incorrect. The distinction is functional, not tool-specific. While Slate is often used for complex operational apps and Contour for analysis, the nature of the workflow is defined by the capabilities provided to the user (action vs. insight), not the specific module used to build the interface.
• D. Incorrect. Neither operational workflows nor static dashboards typically require end users to write SQL. Foundry is designed to provide high-level, no-code or low-code interfaces that abstract away underlying query languages to enable business users to interact with data.

Correct answer: B — Slate applications have lower maintainability and slower development speed.

• A. Incorrect. Slate applications are fully capable of reading from and writing to the Ontology using Object Service queries or Actions. While the configuration is more manual than in Workshop, data access is not restricted.
• B. Correct. Workshop is a 'low-code' environment designed for rapid development with standard, maintained components. Slate is a 'pro-code' environment that offers granular UI control but requires manual implementation of logic and styling, which leads to slower development cycles and higher long-term maintenance costs.
• C. Incorrect. Sharing capabilities and permissions are managed by Foundry's Compass (the file system) and are independent of whether the application is built in Slate or Workshop.
• D. Incorrect. The choice of UI framework does not impact pipeline compute resources. Pipeline compute is utilized by data transformation processes (e.g., Spark jobs) in the data lineage, whereas Slate and Workshop run in the user's browser and interact with APIs.

Correct answers: A, B, C — The Rules or Logic (e.g., modify property, create object).; The Parameters (the inputs required from the user or application).; The Form layout (how the inputs are presented to the user).

• A. Correct. The Rules or Logic define the specific operations the action performs on the Ontology, such as modifying properties, creating new objects, or executing logic through a Function. This is the core business behavior of the Action Type.
• B. Correct. Parameters are essential as they define the inputs (e.g., strings, integers, or specific object types) required from the user or application to execute the action logic.
• C. Correct. The Form layout configuration determines the user interface for the action, including how parameters are grouped, their display names, and conditional visibility rules, ensuring the action is usable in end-user applications.
• D. Incorrect. Spark pipeline schedules are related to batch data processing and ingestion in the data integration layer, whereas Action Types are used for operational writebacks and transactional changes in the Ontology.
• E. Incorrect. While developers can customize the look of applications, specific CSS styling for the submit button is not a configuration component within the Ontology Action Type definition itself; it is handled by the platform or specific application builders like Workshop.

Correct answer: B — Build a Quiver dashboard, parameterize it by the Plant ID, and embed it as a widget within the Plant's Object View.

• A. Building a full Workshop application involves higher overhead for setup and layout compared to using embedded widgets. While Workshop can display charts, it is primarily an application builder; Quiver is the specialized tool for complex time-series analysis and is easier to configure for this specific requirement.
• B. Quiver is Palantir's specialized tool for interactive time-series analysis. By parameterizing a Quiver dashboard with the Plant ID and embedding it as a widget within the Object View, you provide a seamless, context-aware analysis directly to the user with minimal development effort compared to building custom apps.
• C. Using Slate and D3.js provides maximum flexibility but requires significant custom code and engineering effort. This approach has the highest development overhead and is generally avoided when native tools like Quiver can satisfy the requirement.
• D. Providing a link to a blank analysis fails the requirement of providing an immediate, pre-configured analysis. It places the burden of analysis creation on the end user, resulting in a poor user experience.

Correct answers: A, B, D — Action Types to allow managers to reassign sales reps to different regions.; Conditional formatting in tables to highlight regions falling below their sales targets.; Object Set variables that filter the view to show only the current user's assigned regions.

• A. Action Types are the primary mechanism in Workshop for turning a static report into an operational workflow. They allow managers to take direct action on records, such as reassigning sales reps, by writing back to the Ontology.
• B. Conditional formatting improves the user experience of an operational dashboard by visually highlighting metrics that fall below targets. This allows managers to quickly identify and prioritize underperforming regions that require attention.
• C. A static PDF export button is a reporting feature that does not contribute to making an application operational. It does not allow for interactivity or active data management.
• D. Object Set variables can be used to filter the application view based on the current user's context (e.g., assigned regions). This provides a personalized experience and ensures managers focus on the data relevant to their specific operational responsibilities.
• E. Embedding a read-only legacy dashboard via an iframe keeps the experience static and fails to provide the operational or management capabilities requested by the business unit.
• F. A pipeline that overwrites user edits would undermine the purpose of an operational application. If managers use Action Types to update data, a pipeline that clears those edits would render the application ineffective for management.

Correct answer: B — Build a complex Workshop application with custom state variables.

• A. Slate is a developer-centric tool for building highly custom, bespoke web applications and forms. While powerful, it is not the standard or most efficient choice for turning analytical dashboards into operational workflows compared to the modular framework of Workshop.
• B. Workshop is specifically designed for creating interactive, operational applications. By utilizing custom state variables, developers can manage application state across various widgets and modules, allowing users to move from high-level dashboard insights to granular, actionable steps seamlessly.
• C. Object Explorer and Object Views are optimized for search, exploration, and individual record investigation. While they provide context for objects, they do not inherently provide the complex state management or multi-step logical flows required for a dedicated operational workflow.
• D. Quiver is primarily an analytical tool used for deep-dive analysis, time-series, and reporting. Parameterized templates allow for reusable analysis, but Quiver lacks the action-oriented framework and application-state logic found in Workshop.

Correct answer: B — The team will have to accept Workshop's standardized UI components, trading pixel-perfect custom design for maintainability.

• A. Workshop does not support the automatic import or application of custom CSS from Slate. The two platforms utilize different design frameworks and component libraries, making direct stylesheet inheritance impossible.
• B. Workshop is designed to provide a standardized, robust, and scalable set of UI components. This ensures better maintainability and consistency across the platform, but it often requires teams to move away from the pixel-perfect, bespoke styling possible in Slate.
• C. While Workshop allows for the creation of Custom Widgets using React to extend functionality, it is not intended as a tool to replicate legacy CSS designs. The platform guides builders toward a consistent layout pattern rather than arbitrary front-end development.
• D. A proprietary design system is not a barrier to using Workshop. While builders must work within the constraints of Workshop's component library, the platform is effective for operational workflows regardless of external design requirements.

Correct answer: A — Configure the Action's 'On Success' event to trigger a 'Show Toast' event, followed by a 'Set Variable' event to clear the input variables.

• A. This is the standard and recommended approach in Workshop. Action buttons have built-in 'On Success' and 'On Failure' event triggers. You can chain multiple events in the 'On Success' block, such as 'Show Toast' for user feedback and 'Set Variable' to reset the UI state by clearing input variables.
• B. While Functions on Objects (FoO) can handle complex backend logic, standard Workshop UI behaviors like showing toasts and resetting variables are configured through the Workshop Event system. Executing UI-specific events like 'Show Toast' is generally handled via the low-code event configuration rather than within a TypeScript Function itself.
• C. Requiring a user to click multiple buttons for a single workflow is a poor user experience. Post-submission tasks like clearing forms and showing confirmation should be automated as part of the submission event chain.
• D. Quiver is primarily used for analytical workflows and dashboards. Workshop is the appropriate tool for application building, and it provides native event handling to manage UI updates following an Action without needing external Quiver templates.

Correct answer: A — Create an Object Set variable starting with all 'Vehicles', and apply a filter where the 'Mileage' property is greater than a Numeric variable bound to the user's input.

• A. Correct. In Palantir Workshop, the standard pattern for dynamic filtering is to define an Object Set variable and apply property-based filters that are bound to other application variables (like a Numeric variable). This allows the UI to update dynamically as the user modifies the input variable.
• B. Incorrect. Hardcoding a threshold in the Ontology Manager creates a static definition. This does not allow the application to respond to user-specific inputs or changing criteria at runtime within Workshop.
• C. Incorrect. Actions are intended to modify the underlying data or trigger workflows, not to manage transient UI filters. Deleting objects is a destructive process and would permanently remove data that might be needed for other views or users.
• D. Incorrect. Although Quiver can filter data, using a Quiver template solely for property-based filtering in Workshop is unnecessarily complex. The native Object Set variable filtering mechanism is more efficient and provides better performance for this use case.

Correct answer: B — Time Range

• A. Object Sets are the primary data entities used in Quiver. While they can be passed as inputs into Quiver Templates, in the specific context of 'Canvas Inputs' (global interactive parameters), the platform often distinguishes between data sources like Object Sets and scalar/range parameters used for dashboard interactivity.
• B. Time Range is a core interactive input type for Quiver canvases. It allows developers to create a global parameter that users can manipulate to filter time-series data or object sets across multiple cards and visualizations simultaneously.
• C. While Boolean parameters are supported within the platform's logic, 'Time Range' is a more specialized and characteristic interactive input type specifically documented for synchronizing temporal analysis within a Quiver canvas.
• D. Video Stream is not a supported input type for Quiver canvases, which are designed for the analysis and visualization of structured data and time-series.
• E. Raw JSON Object is not a valid interactive input type for Quiver. Quiver utilizes structured parameters such as strings, numbers, and dates to ensure consistency across the analysis.
• F. Binary File is not a supported interactive input type for Quiver canvases; the tool is built to handle structured object data and numerical time-series.

Correct answers: B, C — Adding a new column calculated via a formula from existing columns.; Grouping rows and calculating aggregate metrics (e.g., Sum, Average).

• A. Incorrect. In Quiver, combining Object Sets is typically achieved through 'Search-around' or 'Link to' operations based on defined relations in the Ontology. While tabular data derived from objects can be joined, it is less common than standard column or aggregate transformations.
• B. Correct. Adding a new column via a formula is a core transformation in Quiver. The formula editor allows users to perform logic and arithmetic on existing columns to derive new values for real-time analysis.
• C. Correct. Quiver provides 'Aggregate' and 'Pivot' transformations that allow users to group data by specific dimensions and calculate metrics such as Sum, Average, or Count.
• D. Incorrect. Training machine learning models is handled in specialized Palantir environments like Foundry ML, AIP, or Code Workbooks, rather than within the Quiver canvas.
• E. Incorrect. Triggering webhooks is an automation or integration task usually handled by Palantir Actions or the Object Management Architecture, not a data transformation within Quiver.
• F. Incorrect. The Ontology schema is managed centrally in the Ontology Manager. Quiver is a tool for consuming and analyzing Ontology data, not for modifying its structural definitions.

Correct answers: A, B, C — Creating a new object and setting its properties.; Modifying the properties of an existing object.; Adding or removing links between two existing objects.

• A. Correct. Creating a new object and setting its initial properties is a core native capability of standard Action Rules in the Ontology Manager and does not require custom code.
• B. Correct. Modifying properties of an existing object is one of the standard operation types (Modify Object) available directly within the Action Rule configuration.
• C. Correct. Standard Action Rules natively support managing relationships between objects by adding or removing links between specific instances.
• D. Incorrect. Standard Action Rules are designed for specific object instances passed as parameters. Programmatic iteration, loops, or bulk updates across a collection of objects require the logic handling provided by Function-backed actions.
• E. Incorrect. Interacting with external systems via REST APIs requires integration logic and network side-effects that are not available in standard Action Rules; these must be implemented using Function-backed or External Actions.
• F. Incorrect. While object deletion is a standard rule, complex conditional logic or mathematical evaluations that go beyond simple parameter checks require the computational power of TypeScript in a Function-backed action.

Correct answers: A, B — Binding it to the Active Object variable of an Object List widget.; Binding it to a static value entered directly in the Workshop configuration.

• A. Correct. Workshop Action parameters can be bound to dynamic application variables. A common use case is binding the parameter to the Active Object variable of an Object List widget, allowing the action to execute on the specific object currently selected by the user.
• B. Correct. Action parameters can be configured with static values directly within the Workshop UI. This is used when the parameter input is a constant that does not change based on user interaction or application state.
• C. Incorrect. Action parameters in Workshop must be bound to defined variables, object references, or static primitives (strings, numbers, etc.). They cannot be directly bound to an arbitrary local file upload at runtime.
• D. Incorrect. CSS class variables are used for styling components and managing visual themes. They do not provide data values suitable for populating Action parameters, which require ontology-compatible data types.
• E. Incorrect. While Workshop can interact with Quiver, it can only bind to variables that have been explicitly exported. It cannot access the internal, non-exported state of a Quiver dashboard.

Correct answer: C — To provide semantic metadata that dictates how frontend applications like Workshop format and render the value.

• A. Uniqueness is typically enforced by designating a specific property as the Primary Key or through validation logic in the data pipeline. Property metadata like display names do not enforce database-level constraints.
• B. The Ontology does not automatically generate backing datasets; instead, properties are mapped to existing columns within datasets that have been indexed into the Ontology.
• C. Property metadata and type classes provide the semantic context necessary for frontend applications like Workshop or Object Explorer to know how to display the property (e.g., as a currency, a date, or a custom status badge) and what label to show to the user.
• D. Visibility and access control are managed through granular security features such as Markings and dataset permissions, rather than through display metadata or type classes.

Correct answers: B, C — Traverse the link from the `Region` to the `Sales` objects using `.sales.all()`.; Iterate through the linked `Sales` objects and sum their revenue properties.

• A. While passing the `Region` object as an input argument is a prerequisite to provide context to the function, it is the input mechanism rather than the logic used to retrieve or aggregate the related data.
• B. To access related data in the Ontology, you must use the generated accessor methods for the link types. Using a traversal method like `.sales.all()` obtains the connected sales records for that specific region.
• C. Once the linked objects are retrieved as an array, the logic must iterate through them to access the specific revenue properties and perform the mathematical summation to calculate the total.
• D. The `@Edits(Region)` decorator is used to indicate that a function modifies an object type. It is not relevant for performing read-only aggregations or for simply returning a calculated value.
• E. Configuring a Webhook is for interacting with external services. Since the `Sales` data is already stored within the Ontology and linked to the `Region` object, data should be accessed directly through ontology relationships.
• F. An `ActionType` refers to the configuration of an Action in the Ontology. Functions used for calculations typically return primitive types (like Double or Integer) or object instances, not ActionType objects.

Correct answer: B — Timestamp

• A. LocalDate represents a date without a time zone or time component (year, month, day). It is used for calendar dates and is not suitable for representing a precise point in time.
• B. Timestamp is the standard type in Palantir Functions for representing a specific point in time, including both date and time components, typically with millisecond precision.
• C. While Date is a standard JavaScript object, in the context of Palantir TypeScript functions and Ontology values, Timestamp is the specific type used to represent high-precision date-time attributes.
• D. Moment refers to the Moment.js library used for date manipulation. It is not a native Palantir Ontology type and is now generally considered legacy in the JavaScript ecosystem.

Correct answer: D — Objects.create().logEvent(id);

• A. Incorrect. Ontology-backed objects in Palantir are not instantiated using the standard TypeScript 'new' keyword. Object lifecycle is managed via the Ontology API to ensure consistency and proper transaction handling.
• B. Incorrect. While 'Ontology' is a central concept in Palantir, 'Ontology.create' is not a valid method in the standard Functions API for creating objects. The entry point for object manipulation is the 'Objects' namespace.
• C. Incorrect. This syntax suggests a static method on the object class, which is not the pattern used in the Palantir Functions API or the Ontology SDK.
• D. Correct. In Palantir TypeScript functions (typically used within Actions), new objects are created using the 'Objects.create()' method. This returns a builder where you call the camel-cased API name of the object type (e.g., 'logEvent') and pass the primary key as the argument.

Correct answer: B — Trigger an Action configured to apply the Scenario modifications.

• A. Incorrect. Scenarios in Workshop are isolated simulation environments designed for what-if analysis and do not write directly to the base Ontology. This allows users to experiment safely without affecting production data.
• B. Correct. To persist modifications made within a Scenario to the base Ontology, the user must execute an Action that has been specifically configured to apply those Scenario changes. Actions serve as the bridge between simulated environments and the permanent data model.
• C. Incorrect. While CSV export is possible in some contexts, it is not a standard or supported workflow for persisting Scenario results. This method would bypass the Ontology's integrated action and validation workflows.
• D. Incorrect. Foundry Rules are used to define custom logic and allow users to customize pipeline behavior, but they are not the mechanism for applying or merging Scenarios into the base Ontology.

Correct answers: A, C — Ensuring URL parameters passed to Slate are stable and well-documented.; Managing the performance overhead of loading a separate application context within an iframe.

• A. Correct. In a Workshop-to-Slate integration, data is typically passed via URL parameters (permalinks). Ensuring these parameters are stable and well-documented is crucial for maintainability, as it prevents breakage when either application is updated and ensures the dashboard receives consistent context for a better UX.
• B. Incorrect. Slate dashboards can be successfully embedded within Workshop using the iframe widget. A redirect is a different architectural pattern and is not a requirement for this specific workflow.
• C. Correct. Embedding one application within another via an iframe involves loading two separate application contexts, which can lead to significant performance and memory overhead. Managing this is critical for a responsive user experience.
• D. Incorrect. Slate is a separate environment and does not automatically inherit Workshop's state or variables. Explicit wiring through parameters and Slate's internal variable configuration is required.
• E. Incorrect. While Foundry Rules are used for allowing users to customize pipeline logic, they are not the primary mechanism for passing UI state or bridging data between a Workshop application and an embedded Slate dashboard.

Correct answer: B — Configure an Object View tab with an iframe embedding the Slate app, passing the Customer ID via URL parameters.

• A. Incorrect. Requiring a user to manually copy and paste a URL is not a 1-click transition and results in a poor user experience. It also fails to leverage Foundry's native capabilities for application integration.
• B. Correct. The standard way to provide contextual transitions from Object Explorer is by configuring an Object View tab. By embedding the Slate application (using an iframe or external link widget) and passing the object's primary key (Customer ID) via URL parameters, the Slate app can automatically filter and display the correct data for that specific object.
• C. Incorrect. Foundry Rules are intended for data logic, transformations, and automated actions within the Ontology. They are not used for UI navigation or for triggering Slate application builds upon a user viewing an object.
• D. Incorrect. Scenarios are used for 'what-if' analysis and staging changes to the Ontology. They do not serve as a mechanism for mapping Object Explorer views to Slate or for handling application redirects.

Correct answer: B — Use a Scenario Array to load multiple Scenarios simultaneously and configure a chart widget to group by Scenario.

• A. Creating separate Workshop applications prevents side-by-side comparison in a single chart and is not an efficient or unified operational workflow. It ignores the built-in scenario configuration features designed for this purpose.
• B. This is the correct approach. A Scenario Array allows multiple scenarios (what-if versions of data) to be loaded into the application state simultaneously. By configuring a chart widget to group by Scenario, the user can directly compare the projected outcomes of different strategies in a single view.
• C. Concatenating strategies into a single string property is not a valid method for data visualization or comparison. It would not support numerical chart projections or the multi-variant modeling required for scenario analysis.
• D. Overwriting the base ontology is destructive and sequential. It prevents the concurrent comparison of different alternatives and risks permanent data loss. Scenarios are intended to isolate changes from the base data until a decision is made.

Correct answer: B — Appending URL parameters containing the Object RID.

• A. Storing a selection in a Global Variable is not the standard mechanism for transferring UI context across separate Foundry applications, as global variables are typically scoped within a single application session and are not designed for cross-application handoffs.
• B. The standard approach for deep-linking into Foundry applications like Object Explorer or Quiver is to append URL parameters, specifically the Object RID (Resource Identifier), to the destination URL. This allows the target application to immediately resolve, load, and focus on the specific object instance.
• C. Foundry Rules are used for automation, data processing, and workflow logic. They are not a navigational mechanism and do not serve as a standard way to pass UI context or object selections during an application redirect.
• D. Scenario objects are designed for 'what-if' analysis and managing proposed data changes within the Ontology. They are not intended to be used as a context carrier for simple user navigation between different Palantir applications.

Correct answer: B — Configure a button in Workshop to open a Contour analysis URL, passing the current filters as parameters.

• A. Embedding a Contour analysis directly inside Workshop tightly couples the two tools and can lead to performance overhead and maintenance complexity. Workshop is better used to surface insights and then redirect users to specialized analysis tools when deeper exploration is required.
• B. This is the best practice for cross-application workflows. Using a button to open a Contour analysis URL while passing parameters ensures that the user's context is preserved. This approach leverages Contour's native ability to perform high-scale analysis on hundreds of millions of rows while maintaining a clean separation of concerns between the operational application (Workshop) and the analytical tool (Contour).
• C. Foundry Rules is designed for automated, logic-based alerting and decision-making on objects, not for ad-hoc, interactive, exploratory big data analysis. It would not provide the necessary flexibility or UI for a user to perform a 'deep-dive' into 500 million rows.
• D. Workshop variables and object sets are optimized for operational data and specific object interactions. Attempting to rebuild complex big data aggregations for 500 million rows directly in Workshop is inefficient, difficult to maintain, and duplicates functionality that Contour is already purpose-built to handle.

Correct answer: B — Embed the Slate application within Workshop using the Slate iframe widget, passing necessary variables via the iframe configuration.

• A. Incorrect. Workshop Functions are used for executing server-side TypeScript logic and data transformations, not for rendering custom frontend visualizations like D3.js. Rewriting the code would be inefficient and increase the maintenance burden.
• B. Correct. The recommended pattern for embedding Slate applications or visualizations into Workshop is using the Slate iframe widget. This approach allows the developer to leverage existing Slate functionality and pass variables through the iframe configuration, ensuring a maintainable and integrated user experience.
• C. Incorrect. Foundry Rules are logic-based components used for data transformation, validation, or workflow branching. They cannot be used to convert application graphs into UI widgets.
• D. Incorrect. Slate can be natively embedded within Workshop using a dedicated widget. A URL redirect would force the user out of the current application context and does not constitute embedding for maintainability.

Correct answers: A, B, C — Embedding a Workshop module as a tab in an Object Explorer Object View.; Embedding a Slate application inside a Workshop application using an iframe widget.; Embedding a Workshop module inside another Workshop application.

• A. Embedding Workshop modules into Object Views (via tabs) is a standard pattern that allows developers to create specialized, interactive workflows for specific object types, enhancing modularity and reuse.
• B. Workshop provides a dedicated Slate widget (which functions via an iframe) to embed Slate applications. This allows developers to leverage Slate's flexible UI and logic capabilities within a structured Workshop layout.
• C. The Workshop Module widget is specifically designed to embed one module inside another. This promotes a modular architecture where discrete pieces of functionality are built once and reused across multiple applications, significantly improving maintainability.
• D. Pipeline Builder is a backend tool for data transformation and workflow orchestration; its graph interface is not designed to be embedded as a UI component within a Slate application.
• E. The Rule Editor and deployed ML models serve different architectural roles. While models can be used within rules, embedding the editor itself into a deployed model is not a supported or valid workflow.
• F. The Ontology Manager is an administrative tool for defining the data model. While Workshop and Slate can embed external content, the Ontology Manager itself does not support embedding third-party websites.

Correct answer: B — Revert the application to the previously tagged stable version using the application's version history.

• A. Manually rewriting code from memory is highly error-prone, time-consuming, and extremely risky during a production incident. It cannot guarantee an accurate restoration of the previous stable state and may introduce additional defects.
• B. Reverting to the previously tagged stable version using version history is the fastest and safest rollback strategy. This approach utilizes Palantir Slate's versioning capabilities to quickly restore the application to a known-good state with minimal downtime and human error.
• C. Deleting the application and restoring from a manual backup is unnecessarily disruptive and significantly slower than using built-in version history. Manual restoration processes are also more prone to configuration errors and potential data loss.
• D. Leaving the application broken until the next scheduled release window is unacceptable for critical bugs, especially those affecting authentication. This results in prolonged downtime and a poor user experience, violating basic service level expectations.

Correct answer: A — Create the new Action type on an Ontology branch, test it in a staging application, and merge the branch to master only after validation.

• A. Correct. Ontology branching is the standard Palantir Foundry workflow for managing isolated changes. Creating the new Action type on a branch allows the developer to test changes safely in a staging environment without affecting the production 'master' branch. Merging only after validation follows release management best practices and minimizes risk to current users.
• B. Incorrect. Editing the master Ontology directly exposes production users to partially completed or unvalidated changes. Using CSS to hide UI elements is a superficial presentation fix that does not prevent backend or schema-level impacts from affecting the production environment.
• C. Incorrect. Creating a completely duplicate Ontology is unnecessarily complex and resource-intensive for feature development. It introduces significant migration and synchronization risks compared with using Foundry's native branching and controlled merge workflow.
• D. Incorrect. Requiring all users to log out is highly disruptive and impractical for a production environment. Effective release management should isolate testing from production using branching rather than interrupting user access.

Correct answer: A — The pipeline output dataset is not configured to sync to the Ontology.

• A. In Palantir Foundry, operational applications like Workshop and Slate typically consume data through the Ontology. Even if a data pipeline (Build) completes successfully, the resulting dataset must be configured to sync to the Ontology (Object Storage) for the updates to be reflected in the frontend. If the sync is missing, misconfigured, or failed, users will see stale data.
• B. Palantir is a managed SaaS platform; users do not manually restart frontend application servers. Furthermore, a server restart would not resolve a data synchronization issue between the dataset and the Ontology.
• C. Browser caching typically affects static assets (HTML/JS/CSS) or specific UI states. It is highly unlikely to cause a consistent display of 'yesterday's metrics' across multiple users when the backend data flow is the actual bottleneck.
• D. Using an outdated branch of frontend code would likely lead to UI bugs, missing features, or logic errors, but it would not prevent the application from fetching the most recent data available in the underlying Ontology objects.

Correct answer: A — To enforce data quality rules and optionally halt pipeline builds if the data does not meet defined criteria.

• A. Correct. Data Expectations allow developers to define data quality checks (such as null checks, uniqueness, or range constraints). They can be configured to fail a build if criteria are not met, which ensures data integrity and prevents invalid data from propagating to downstream consumers.
• B. Incorrect. Data Expectations are a validation and quality control feature, not a predictive analytics or machine learning tool used for forecasting trends.
• C. Incorrect. Formatting and exporting data to external systems are handled by Data Connection, Egress, or sync tasks. Data Expectations focus strictly on data quality within the pipeline.
• D. Incorrect. Row-level security and user access management are handled by Foundry's security and governance framework (e.g., Markings, Organizations, and Multipass), not by Data Expectations.

Correct answers: A, B — Implement query caching for static or infrequently changing data.; Move complex aggregations and joins from Slate queries into the upstream data pipeline.

• A. Implementing query caching for static or infrequently changing data significantly improves performance. Caching reduces repeated computation and data fetching, lowering latency and the overall load on the backing database.
• B. Shifting complex aggregations and joins into the upstream data pipeline (pre-computation) ensures the application only fetches final results. This leverages Foundry's compute power and reduces the computational work required by the application at runtime.
• C. Increasing the number of widgets rendered simultaneously increases the client-side rendering load and often triggers more concurrent queries, which typically degrades rather than improves performance.
• D. Using SELECT * is an inefficient practice because it retrieves unnecessary columns, increasing the data payload size and processing time. Specifying only required columns is a standard performance optimization.
• E. While running queries sequentially might reduce peak database pressure, it significantly increases the total time required to load the application. Parallel execution is generally preferred in Slate to minimize total wait time.

Correct answer: A — Implement error handling to display a graceful fallback message when the Webhook fails.

• A. Correct. Implementing error handling and a graceful fallback prevents the application from crashing when the Webhook call fails. This improves resilience and ensures a better user experience by allowing the app to continue operating—potentially showing cached data or a user-friendly message—even during external service disruptions.
• B. Incorrect. Restricting the application's operation to specific weather conditions does not address the underlying technical dependency failure and severely limits the application's functionality.
• C. Incorrect. Moving the external API call to a yearly batch pipeline removes the real-time behavior required for the application and results in stale data. It does not solve the resilience issue for real-time operations.
• D. Incorrect. Demanding 100% uptime from a third-party provider is not a technical solution and is practically impossible to guarantee. Resilience should be built directly into the application architecture to handle unavoidable outages safely.

Correct answer: A — Object tables displaying the manager's name directly on the department row will break and must be updated to handle an array of linked objects.

• A. Correct. When cardinality changes from single (many-to-one) to multiple (many-to-many), UI components like Object Tables that were configured to render a single linked value will no longer be valid. These components cannot automatically resolve which of the multiple linked objects to display and must be updated to handle arrays or object sets.
• B. Incorrect. Ontology changes do not trigger the automatic deletion of Action Types. While the actions may become invalid or require manual logic updates to handle the new relationship structure, they remain in the system.
• C. Incorrect. The backing dataset build process is generally independent of Ontology-level relationship metadata. A change in relationship cardinality in the Ontology layer does not inherently cause the Spark or Foundry transforms producing the backing dataset to fail.
• D. Incorrect. Slate applications do not provide automatic migration of variable types. Developers must manually update variable definitions and logic bindings to transition from single-object variables to object set variables when the underlying data model changes.

Correct answer: B — Remove the mapping for the status_code property in Ontology Manager and save the changes to allow the sync to succeed.

• A. Deleting the entire object type is an extreme and destructive measure. It would break all downstream applications, API consumers, and workflows that depend on the Order object, which is disproportionate for resolving a single missing property mapping.
• B. If a source column is no longer available, the Ontology mapping becomes invalid, causing the indexing (sync) to fail. Removing the mapping for the specific missing property in the Ontology Manager aligns the Ontology definition with the current source schema, allowing the sync process to proceed successfully.
• C. TypeScript Functions are used for execution logic and dynamic data retrieval within applications. They are not designed to patch or recreate physical schema columns at the data indexing layer or resolve Ontology synchronization errors.
• D. Reverting the dataset is a heavy-handed rollback strategy that can lead to data loss and inconsistency. It doesn't address the underlying issue that the Ontology mapping is now out of sync with the intended state of the data. Updating the mapping is the standard maintenance procedure.

Correct answers: A, C — Create the new Action Type alongside the old one and test it in a separate Workshop branch.; Update the Workshop application to point to the new Action Type, test in a staging environment, and then promote the Workshop app to production.

• A. Creating the new Action Type alongside the old one allows for parallel testing and validation without disrupting existing functionality. Testing in a separate Workshop branch provides isolation, ensuring changes are verified before any production cutover.
• B. Modifying existing Action Types directly in production is high-risk. This approach lacks a validation phase and can cause immediate disruptions or errors for users during active business hours.
• C. Testing changes in a staging environment and then promoting the application is a standard safe migration strategy. This allows developers to identify affected resources and verify the logic before switching the production version over to end users.
• D. Deleting the old Action Type immediately will break existing workflows, automations, or integrations that still depend on it. A safer approach involves keeping both versions available until the migration and decommissioning phase is complete.
• E. Pausing the Ontology sync does not address the configuration or logic migration of Action Types. It is more likely to cause data staleness and operational issues rather than facilitating a safe transition.