In Palantir Foundry Workshop, a widget is more than a chart or table: it links a dashboard interface to Ontology data and responds to user actions. A click can filter nearby views, start a workflow, or update related records, making the workspace feel connected and responsive.

Multiple Choice

What is a Widget in Workshop terminology?

In Workshop terminology, a Widget is a UI component you place on a dashboard that connects directly to the Ontology data model. This binding means the widget can display data from defined entities and attributes, and it can also affect that data based on user interaction. What makes a widget powerful is that it can trigger events—actions that propagate through the workspace, such as filtering other components, initiating a workflow, or updating related data when a user clicks, selects, or edits something. Think of a chart, table, or control on a dashboard that reflects the underlying Ontology, and when you interact with it, it causes other parts of the interface to respond. This distinguishes a Widget from other concepts like data export tools, serverless compute, or stylesheets, which serve different roles.

A dashboard becomes useful when its parts do more than sit side by side. In Palantir Foundry’s Workshop, a chart, table, or input control can connect to the Ontology and respond to what people do. Workshop calls these interface elements widgets. They’re the pieces users see and interact with, and their connection to Ontology data gives them a role beyond simple display.

That connection is the key idea. A widget can show information about real-world objects represented in the Ontology, such as a shipment, customer, or piece of equipment. It can also respond to a click, selection, or edit by sending an event through the workspace. The result is an interface that feels connected: a choice in one place may filter another component, reveal related details, or start a workflow.

So, what makes something a widget?

Think of a Workshop application as a purpose-built workspace. It may help an operations team review deliveries, support staff follow customer issues, or managers monitor equipment. Widgets are the visible components that make those tasks possible.

A chart might summarize delivery status. A table might list individual shipments. A control might let someone select a region or choose a date range. Each component has a particular job, but a widget’s usefulness often comes from how it connects to other parts of the application.

The chart, for example, may display data tied to Ontology objects. If a user selects a bar representing delayed deliveries, the application could use that interaction to filter a shipment table. The table then shows the records behind the summary. Instead of jumping between disconnected screens, a person can move from a broad view to a specific case in a few clicks.

That’s the difference between a static picture and an interactive workspace. Both can show information; a widget can also take part in what happens next.

The Ontology connection

The Ontology provides a structured way to represent things an organization cares about. These may include people, places, assets, transactions, or events, along with the relationships between them. In Workshop, a widget can connect to this model so it can display relevant object data and respond to user activity.

Suppose a maintenance team tracks machines, work orders, and service history. A Workshop page might include a list of machines, a chart showing open work orders, and a detail panel for the selected asset. When someone chooses a machine, the detail panel can show information related to that object. The widgets aren’t merely pulling unrelated figures into one screen; they’re working with data represented through the Ontology.

This model can make an application easier to understand. A person may know a machine by its name or location, not by the technical structure behind the data. The Ontology helps connect those recognizable objects to the information and relationships that matter. Widgets then give users a practical way to view and act on that context.

Of course, the exact data and behavior depend on how the Workshop application is configured. A widget doesn’t automatically know what a team needs. Someone has to choose its data source, set its properties, and define how it should respond.

From clicks to events

A widget can trigger events when a user interacts with it. An event is a signal that something happened—such as a selection, a change to a control, or an action the user has taken. Other parts of the application can respond to that signal.

Picture a logistics dashboard with a map and a shipment table. When a user selects a location on the map, that action can produce an event. The table may then filter to show shipments associated with that location. The reverse can work too: selecting a shipment in the table might focus the map on its destination.

This kind of interaction creates a useful chain:

  • A user selects or changes something in a widget.

  • The widget produces an event.

  • The application uses that event to update another component or begin an action.

The individual step may be small, but the effect can make a workspace feel much more natural. Users can follow a line of thought—“show me what’s happening here”—without manually repeating the same filter across several views.

Events may also connect to workflows or actions, depending on the application’s setup. For instance, a user might select an item and then take an action that updates related data or routes work to another process. The important point is that the widget provides an interface for interaction; the application’s configured logic determines what that interaction does.

A widget isn’t a data export, a cloud function, or a stylesheet

It’s easy to confuse a widget with other technical components because they can all play a part in an application. Their jobs are different, though.

A data export tool moves or sends data to another system. That may be valuable for sharing information, but exporting data isn’t what defines a Workshop widget.

A serverless function runs code in a cloud environment. It can handle computation or other backend tasks, but it isn’t the visible interface component a person clicks or reads.

A stylesheet controls appearance, such as colors, spacing, and typography. Styling can shape how a widget looks, but it isn’t the widget itself.

A widget is best understood as a user interface component that can connect to Ontology data and take part in application behavior. It might display information, collect a selection, or trigger an event. Appearance, data movement, and backend computation can all support an application, but they describe separate roles.

That distinction is useful when planning a Workshop page. If a team wants to show a list of objects, it needs an appropriate display component. If it wants to send data elsewhere, it needs a data movement capability. If it needs custom computation, that points to a different part of the system. Clear roles make the whole design easier to reason about.

Good widgets serve a clear task

A page can have plenty of widgets and still be hard to use. More components don’t always mean more insight. A crowded dashboard can feel like a kitchen drawer full of gadgets: everything may be useful somewhere, but finding the right thing takes too long.

A stronger design starts with the user’s task. What information needs to be visible? What choices might someone make? Which details should update when they make a selection? These questions help determine which widgets belong together and how they should respond.

For example, a customer support workspace might show a list of open cases, a summary of case volume, and details for the selected customer. If choosing a case updates the detail area, the relationship between those components is clear. If the same selection also exposes an appropriate action, the interface can support the next step without burying it in another page.

It’s also worth considering how much information a widget should show at once. A chart may offer a quick overview, while a table provides more detail. Neither is automatically better. The right choice depends on the task, the data, and the people using the application.

Why the distinction matters

Understanding widgets helps people see how Workshop applications are built. A widget isn’t just a decorative box on a screen. It’s a component in an interactive application—one that may display Ontology-backed information, collect user input, and trigger events that influence other parts of the workspace.

That makes widgets a bridge between data and action. The Ontology gives the application a structured view of important objects and relationships. Workshop provides a way to present that context in a usable interface. Widgets connect the two, helping people explore information and respond to it.

When each widget has a clear purpose and its interactions make sense, the result can feel less like a dashboard assembled from separate pieces and more like one coherent tool. A chart points to a group of records; a selection reveals the relevant details; an action carries the work forward. That’s the everyday value of a widget in Workshop: it brings data into view and gives users a meaningful way to engage with it.