> ## Documentation Index > Fetch the complete documentation index at: https://learn.nextedy.com/llms.txt > Use this file to discover all available pages before exploring further. # SAFe Integration > Nextedy PLANNINGBOARD includes native support for **Scaled Agile Framework (SAFe)** environments, enabling planning at the portfolio, program, and team hierarchy levels directly within Siemens Polarion ALM. *** ## What SAFe integration means in Planningboard In a standard Planningboard setup, columns represent Polarion Plans and rows represent swimlanes based on assignees, projects, or custom fields. SAFe integration extends both of these axes to reflect the multi-level planning hierarchy that SAFe introduces: **Program Increments (PIs)**, **Sprints**, **Agile Release Trains (ARTs)**, and **Programs** within a Solution Train. Rather than treating SAFe-level planning as a workaround involving custom fields and manual queries, Planningboard exposes dedicated plan modes and swimlane assignment types that map directly onto SAFe structures stored in Polarion's SAFe Solution data. The result is that the planning hierarchy you configured in Polarion's SAFe module — with its ARTs, teams, and PIs — surfaces on the board without duplicate configuration. *** ## The two axes of a SAFe board Understanding how SAFe integration works requires seeing how SAFe concepts map onto the board's two independent axes. SAFe mode board with PI plan columns (SAFe Program Increments in Program) across the top and team swimlanes (Program / Solution Teams (SAFe)) down the side, showing cards distributed across the PI/team grid **Columns (Plans Mode)** determine what appears as the board's time axis. SAFe-specific plan modes are: * **SAFe Sprints in Program** (`safeSprints`) — SAFe Sprint iterations within a Program (ART level). Plans are loaded automatically using Polarion's Iteration Plan template; no manual plan query is required. * **SAFe Sprints in Portfolio** (`safePflSprints`) — SAFe Sprint iterations at the Portfolio level, spanning multiple programs in a solution portfolio. * **SAFe Program Increments in Program** (`safePIs`) — Program Increments at the ART (Program) level, showing the 8–12 week PI cadence. * **SAFe Program Increments in Solution** (`safeSIs`) — Program Increments at the Solution level, coordinating PIs across multiple ARTs in a Solution Train. **Rows (Swimlane Assignment Type)** determine which SAFe organizational unit each row represents. SAFe-specific assignment modes are: * **Program / Solution Teams (SAFe)** (`SAFE_TEAM`) — Swimlanes for each SAFe team within the current program, discovered from Polarion's SAFe Solution data. * **Agile Release Train Teams (SAFe)** (`SAFE_TRAIN_TEAM`) — Swimlanes for teams within a specific Agile Release Train, filtered by ART ID. * **Programs (SAFe)** (`SAFE_PROGRAMS`) — Swimlanes for SAFe programs within a Solution Train, used for portfolio-level planning. The two axes are independent: you can combine **SAFe Program Increments in Program** (`safePIs`) columns with **Program / Solution Teams (SAFe)** (`SAFE_TEAM`) swimlanes for a classic PI planning view, or use **SAFe Sprints in Program** (`safeSprints`) columns with **Programs (SAFe)** (`SAFE_PROGRAMS`) swimlanes for cross-program sprint coordination. *** ## How SAFe data is sourced A critical difference from non-SAFe configuration is *where* the board gets its data. In Project Plans mode, Planningboard reads plans from the current Polarion project using a Lucene query you supply. In SAFe modes, the board reads from **Polarion's SAFe Solution model** — the structured ART, team, PI, and program data managed by Polarion's SAFe module, not from custom fields you define yourself. This means: * Teams appearing in **Program / Solution Teams (SAFe)** (`SAFE_TEAM`) swimlanes come from Polarion's SAFe team registry, not from a custom field called `team`. * PIs appearing as columns in **SAFe Program Increments in Program** (`safePIs`) mode are the actual PI plans tracked by Polarion's SAFe module, not plans matching a user-defined query. * ART filtering in **Agile Release Train Teams (SAFe)** (`SAFE_TRAIN_TEAM`) mode is driven by the ART ID from Polarion's SAFe configuration, not by a tag or custom field value. The practical consequence: **SAFe integration requires that Polarion's SAFe Solution is already configured** for the relevant project or project group. Planningboard reads from that configuration; it does not substitute for it. The **Program / Solution Teams (SAFe)** (`SAFE_TEAM`), **Agile Release Train Teams (SAFe)** (`SAFE_TRAIN_TEAM`), and **Programs (SAFe)** (`SAFE_PROGRAMS`) assignment modes, and the **SAFe Program Increments in Program** (`safePIs`), **SAFe Program Increments in Solution** (`safeSIs`), **SAFe Sprints in Program** (`safeSprints`), and **SAFe Sprints in Portfolio** (`safePflSprints`) plan modes, all require that Polarion's SAFe Solution is active and configured for the current project context. Without it, these modes cannot discover teams, ARTs, or PIs. *** ## SAFe fields on work items For SAFe swimlane assignment to work correctly, work items must carry SAFe-specific custom fields that Planningboard reads to route them into the right row. Two field IDs matter: * `safeTeam` — stores the SAFe Team assignment for a work item. Used when `assignmentMode` is `SAFE_TEAM` or `SAFE_TRAIN_TEAM`. * `safeProgram` — stores the SAFe Program assignment for a work item. Used when `assignmentMode` is `safePrograms` (SAFE\_PROGRAMS). These field IDs are the defaults. If your Polarion project uses different field IDs for team and program assignment, the widget parameters `safeTeamField` and `safeProgramField` let you override them. Capacity configuration parameters and field ID overrides are whitespace-sensitive. A trailing space in a field ID value will cause the field to go unresolved silently. Always trim values when entering them in the widget parameter panel. *** ## Planning hierarchy levels and their configurations SAFe planning happens at different levels of the hierarchy. The configuration that works at one level does not simply transfer to another — the Plans Mode selection, the swimlane assignment type, and sometimes the portfolio suffix all change. SAFe hierarchy tree from Portfolio Level down to Team Sprint, mapped to Plans Mode and Swimlane Assignment values at each level A common source of confusion: when you switch Plans Mode from **Project Plans** (`plans`) to **SAFe Program Increments in Program** (`safePIs`), the configuration UI in the widget parameter panel changes. Fields that were visible for Project Plans — such as Scope, Query, and Type — are replaced by SAFe-specific fields including the **Program Increment Parameter ID** field. This is not a UI bug; it reflects that the two modes require fundamentally different inputs. Expecting the same configuration fields across plan modes is a misconception that frequently causes configuration errors. Selecting **SAFe Program Increments in Program** (`safePIs`) or **SAFe Sprints in Program** (`safeSprints`) as the Plans Mode replaces the standard plan query fields with SAFe-specific configuration fields. If you see unexpected or missing fields after switching Plans Mode, this is expected behaviour — check the SAFe-specific parameters rather than looking for the standard plan query fields. *** ## Page Parameters and Program Increment Parameter ID One aspect of SAFe configuration that frequently causes confusion is the use of **Page Parameters**. In SAFe mode, the board may need to know which specific PI or ART to display — and this information is often passed as a page parameter rather than being hardcoded in the widget. The **Program Increment Parameter ID** field in the widget configuration references a Page Parameter defined on the Polarion page containing the widget. This indirection exists so that a single board widget can be reused across multiple PIs or ARTs by changing the page parameter value, rather than reconfiguring the widget each time. The setup flow is: 1. A Page Parameter is created on the Polarion page (not inside the widget). 2. The widget's **Program Increment Parameter ID** field references that page parameter's ID. 3. The page parameter's value supplies the actual PI ID or ART ID to the board at runtime. If Page Parameters are not explicitly created and referenced, the board cannot resolve the PI or ART context and will either show an empty board or fall back to unexpected defaults. Page Parameters do not exist by default. They must be created on the Polarion page containing the Planningboard widget before the **Program Increment Parameter ID** field can reference them. If the board shows no SAFe plans or teams after configuration, verify that the Page Parameter exists and that its ID matches the value entered in the widget. *** ## SAFe-specific swimlane assignment types and support The KB lists three SAFe swimlane assignment types as available for SAFe environments: * **Program / Solution Teams (SAFe)** * **Agile Release Train Teams (SAFe)** * **Programs (SAFe)** Enabling SAFe swimlane assignment types requires setup guidance specific to your Polarion SAFe Solution configuration. If these swimlane options do not appear in the Assignment Type dropdown of your Planningboard widget, contact Nextedy support for setup assistance — the options require the SAFe Solution to be active and may require additional configuration steps beyond the widget parameter settings. *** ## SAFe sprints: auto-applied plan query One small but important detail about **SAFe Sprints in Program** (`safeSprints`) mode: the plan query is **automatically set** to filter plans by Polarion's Iteration Plan template (`template.id:iterationPlan`). You do not need to — and should not — supply a manual plan query when using **SAFe Sprints in Program** mode. The auto-applied filter ensures only iteration-level plans appear as columns, preventing PI-level or other plan types from mixing into the sprint view. This contrasts with Project Plans mode, where the plan query is entirely user-defined. *** ## Common misconceptions **"I can use a custom `team` enum field instead of the SAFe team field."** You can use **Enumeration Field** (`ENUM`) swimlane assignment mode with a custom team field for non-SAFe team planning, but this is a different configuration from **Program / Solution Teams (SAFe)** (`SAFE_TEAM`) mode. The two approaches differ in how teams are discovered (custom enum options vs. Polarion's SAFe team registry) and in the drag-and-drop behaviour when moving cards between swimlanes. Do not use one as a substitute for the other in a genuine SAFe environment. **"The SAFe plan modes work like Project Plans mode with a pre-filled query."** SAFe plan modes use Polarion's SAFe Solution data source, not the standard plan query mechanism. This is why the configuration UI differs: the inputs required are structurally different, not just different query strings. **"Changing Plans Mode just changes which plans are shown."** Changing Plans Mode also changes the configuration schema the widget expects. Fields available in one mode may not exist in another. Always re-check the widget configuration panel after switching Plans Mode. **"Global enumeration custom fields can be used for SAFe-style swimlanes."** There is a known limitation: global enumeration custom fields may fail validation after saving in Planningboard swimlane configuration, even if they appear to resolve during initial setup. If you need enum-based swimlanes, use project-scoped enumeration fields. See [Swimlane Assignment Modes](/planningboard/concepts/assignment-modes) for the full discussion of field scope requirements. *** ## Relationship to Plans modes and assignment modes SAFe integration is not a separate feature switch — it is realized through the combination of the **Plans Mode** setting and the **swimlane assignment type** setting. The concepts page for [Plans Modes](/planningboard/concepts/plans-modes) covers all available plan mode values. The [Swimlane Assignment Modes](/planningboard/concepts/assignment-modes) page covers the full set of assignment types including the SAFe-specific ones. Capacity tracking in SAFe environments follows the same capacity bar and normalization model as non-SAFe boards, with the same limitations: no multi-assignee capacity distribution and no sub-item effort distribution. See [Capacity Tracking](/planningboard/concepts/capacity-tracking) for details. *** ## Summary: the mental model Think of Planningboard's SAFe integration as a **translation layer** between Polarion's SAFe Solution data model and the board's column/row grid. The board does not manage SAFe structure — it reads it. Your ARTs, teams, and PIs exist in Polarion's SAFe module; Planningboard surfaces them as columns and swimlanes for visual, drag-and-drop planning without leaving the ALM environment. The configuration challenge is choosing the right Plans Mode for your hierarchy level, ensuring the corresponding SAFe data exists in Polarion, and wiring up any Page Parameters the board needs to resolve the specific PI or ART context. Once those three things align, the board constructs itself from live Polarion data rather than from manually maintained lists. For practical configuration steps, refer to the [Guides](/planningboard/guides/index) section when those pages become available. **KB Articles** * Introduction to Planningboard * Swimlane Assignment Types * Planningboard interface & basic interactions **Support Tickets** * [#5879](https://support.nextedy.com/helpdesk/tickets/5879) * [#6681](https://support.nextedy.com/helpdesk/tickets/6681) * [#6734](https://support.nextedy.com/helpdesk/tickets/6734) **Source Code** * `AssignmentMode.java` * `Config.java` * `PlanningBoardWidgetRenderer.java` * `PlansMode.java` * `enum-rows-filter.cy.ts`