Skip to content
Agile Defense

Curriculum / Foundry Foundations

INTERMEDIATEUnit 5day-05

Workshop Command Center

not started~360 min
Assemble a Workshop application that lets analysts review risk, inspect detail and move through triage.

Introduction

Scenario: The operations team needs a lightweight command center before the next weekly disruption meeting.

Day 5 turns your ontology into something the operations team can actually use under pressure. Workshop is Foundry's low-code application builder for operational interfaces, and today you assemble a lightweight 'command center' as a Workshop module — a self-contained view you create from a Project via New > Workshop module, inheriting that Project's permissions. The goal is a single screen the team can open before the weekly disruption meeting to see at-risk shipments, suppliers, and routes without writing a query.

Why this matters for disruption response: a command center collapses the gap between data and decision. Workshop modules read and write your domain objects through object sets — collections of objects you can filter and transform — and the whole experience is wired together with variables that control how data moves through the module. When an analyst picks a region or a severity in a filtering widget, that selection flows as a variable into the object set powering a table, a map, and a chart, so the picture updates instantly for everyone in the room.

By the end of the day you will have defined the primary user journey, built the module, connected object sets to filtering widgets and selections through input and output variables, and stress-tested it against two realistic disruption scenarios. You are not just displaying data — you are building the operational surface where the team triages the next disruption.

Capability focus: Workshop application building, widgets, variables · Artifact: Simple supply-chain command center

Key concepts

  • Workshop module: a self-contained, low-code operational view created from a Project (New > Workshop module); it inherits permissions from its parent Project or folder and is composed of widgets arranged in sections.
  • Widgets: the core building blocks of a module's UI, grouped into core display (Object Table, Object List, Object View, Property List), visualization (Chart XY, Map, Gantt, Pivot Table), filtering (Filter List, Object Dropdown, String Selector, Date/Time Picker), and event-triggering/navigational (Button Group, Tabs). Each is configured in its Widget setup tab with input and output variables.
  • Object sets: variables representing a collection of one or more objects, optionally filtered or transformed via linked-object traversals; they are the data backbone every display and visualization widget reads from.
  • Variables: the configuration layer that controls how data moves through a module. Types include primitives (Boolean, Date, Numeric, String, Timestamp), Object Set, Object Set Filter (property-value pairs that constrain an object set), Array, and Struct.
  • Input vs. output variables: widgets consume input variables to populate themselves and emit output variables for downstream use — e.g., a Filter List takes an object set input and produces an Object Set Filter output that a table then consumes, creating a data-flow pipeline.
  • Variable lineage graph and recompute behavior: the lineage graph visualizes how variables and widgets depend on one another for debugging, while recompute settings control whether a variable updates automatically on dependency change, only on an event, or on module load plus events.

Companion video

Build with Us: Speedrun Your First End-to-End Workflow · watch 20:05–26:35 · open on YouTube

Hands-on activity

each step validates · the unit completes when all steps pass
  1. 1

    Define the primary user journey

    Before opening Workshop, write down the single path the operations team will walk during the disruption meeting: open the command center, narrow to at-risk shipments by region and severity, select one to inspect its supplier and route, and decide on an action. Map each step of that journey to the object types it touches (Shipment, Supplier, Route) and the object sets that will feed it, since in Workshop everything a module displays flows from an object set you can filter and transform. Keeping the journey to one clear flow now is what lets you choose the minimum set of widgets later rather than over-building.

    not startedself-attested

    Self-attested: you defined the daily-review journey before building.

  2. 2

    Create the Workshop command-center module

    From your supply-chain Project, choose New > Workshop module so the module inherits the Project's permissions, then name it clearly (for example, 'Disruption Command Center'). Lay out sections that mirror the user journey — a filtering rail, an Object Table of at-risk shipments, and an Object View detail panel — using sections as the layout containers that hold and optionally collapse your widgets. Start by adding an Object Table widget bound to a Shipment object set so the team has the central list to triage from.

    not startedinstance check

    Confirms a Workshop module exists at the expected path (existence-only).

  3. 3

    Connect object sets to filters and selections

    Add a Filter List widget that takes the Shipment object set as its input and produces an Object Set Filter output (property-value pairs such as region and severity), then feed that filtered object set into the table, map, and any chart so a single selection updates them all at once. Wire the table's selected row to an 'active object' variable and bind an Object View widget to it, so picking a shipment reveals its linked supplier and route via the object set's linked-object traversals. Use the variable lineage graph to confirm the data flows the way you intend — filter output into the table's input, table selection into the Object View — and check recompute behavior so the views refresh automatically when the filter changes.

    not startedself-attested

    Self-attested: filters/selections behave predictably (config not API-readable).

  4. 4

    Test with two disruption scenarios

    Validate the command center against two concrete cases — for example, a port closure spiking severity in one region, and a single-supplier failure cascading across multiple routes — and walk the full user journey for each. Confirm the filtering widgets correctly constrain the object set, that selecting a shipment populates the Object View with the right linked supplier and route, and that the visualization widgets recompute as expected. If a widget shows stale or empty data, trace it in the variable lineage graph to find the broken input/output link rather than guessing, then fix the binding or recompute setting.

    not startedself-attested

    Self-attested: the app demos in under five minutes.