> ## 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.
# Plans Modes
> Nextedy PLANNINGBOARD organises its columns around a single controlling concept: the **Plans Mode**.
## What a Plans Mode Is
Think of the Plans Mode as a lens. The same pool of work items sits behind the board in every case; the mode controls which Plans frame them as columns. Changing the mode does not change your work items or your swimlane configuration — it changes what the columns *are* and which planning hierarchy they reflect.
Planningboard supports five Plans Modes, controlled by the `plansMode` widget parameter:
| Mode identifier | Description |
| ---------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| `PROJECT_PLANS` | **Project Plans** — standard Polarion Plans from the current project, selected by a custom query |
| `safeSprints` | **SAFe Sprints (Program)** — iteration plans within a SAFe Agile Release Train at Program level |
| `safePflSprints` | **SAFe Sprints (Portfolio)** — iteration plans across all programs in a Solution portfolio |
| `safePIs` | **SAFe Program Increments (Program)** — PI-level planning within an Agile Release Train |
| `safeSIs` | **SAFe Program Increments (Solution)** — PI-level planning coordinated across multiple Agile Release Trains in a Solution train |
The default is **Project Plans** (`PROJECT_PLANS`), which is appropriate for most standard Polarion projects that do not use the SAFe solution structure.
***
## Project Plans Mode
In Project Plans mode, Planningboard loads Plans directly from the current project using a Lucene query you supply. This mode imposes no structural assumptions about your planning hierarchy — if the Plans exist in the project and match the query, they appear as columns.
The relevant widget parameters are:
* `plansQuery` — a Lucene query that selects which Plans to show. When empty or absent, no filter is applied.
* `lastPlans` — how many already-completed Plans to include (default `1`). Showing past Plans lets planners compare what was done against what is being planned now.
* `nextPlans` — how many upcoming Plans to include (default `5`). A wider window gives a longer planning horizon; too many columns can make the board dense.
* `planLink` — a URL template used to link each Plan column header to its Polarion Plan record, supporting `${plan.*}` variables (default points to the Polarion plan detail page).
Plans are ordered chronologically. If your Plans have irregular dates or naming, the chronological order may not match your intuitive sprint sequence — in that case, tighten the `plansQuery` to select only the Plans that matter.
Loading many Plans means loading many work-item sets. Keep `nextPlans` to a practical window (5–8) and use `plansQuery` to exclude irrelevant Plans. The `maxItems` parameter (default `1000`) caps total work items loaded regardless of mode.
***
## SAFe Plans Modes
The four SAFe modes — **SAFe Sprints in Program** (`safeSprints`), **SAFe Sprints in Portfolio** (`safePflSprints`), **SAFe Program Increments in Program** (`safePIs`), and **SAFe Program Increments in Solution** (`safeSIs`) — are designed for organisations using Siemens Polarion ALM's native SAFe Solution structure. They differ in **level** (Sprint vs PI) and **scope** (Program vs Portfolio/Solution).
### Why SAFe modes exist separately
In a SAFe deployment, Plans are not just arbitrary date ranges — they belong to a hierarchy: Team Iterations live inside Program Increments, Programs belong to Agile Release Trains (ARTs), and ARTs belong to a Solution. Planningboard needs to know which level you are planning at so it can load the right set of Plans and present the right column granularity.
When you select **SAFe Sprints in Program** (`safeSprints`), for example, Planningboard automatically queries for Plans using the `iterationPlan` template — you do not write a manual `plansQuery`. The SAFe structure in Polarion drives the discovery.
### SAFe Sprint modes
**SAFe Sprints in Program** (`safeSprints`) and **SAFe Sprints in Portfolio** (`safePflSprints`) both show iteration-level Plans (two-week sprints or similar). The difference is scope:
* **SAFe Sprints in Program** (`safeSprints`) — iterations within the current ART. Planners see one sprint per column for the teams inside a single Program.
* **SAFe Sprints in Portfolio** (`safePflSprints`) — iterations across all programs in the Solution. Use this for portfolio-level coordination when you need to see sprint cadence across multiple ARTs at once.
### SAFe Program Increment modes
**SAFe Program Increments in Program** (`safePIs`) and **SAFe Program Increments in Solution** (`safeSIs`) both show PI-level Plans (typically 8–12 week increments). The difference again is scope:
* **SAFe Program Increments in Program** (`safePIs`) — PIs within a single Agile Release Train. Typical use: an RTE or Product Manager planning features across the teams in one ART.
* **SAFe Program Increments in Solution** (`safeSIs`) — PIs across the entire Solution train, coordinating multiple ARTs. Use this for Solution-level planning where a Solution Train Engineer needs a consolidated view.
The four SAFe Plans Modes only work when your Polarion instance has the SAFe Solution structure configured. Without it, these modes will not find any Plans to display. If you are not using the Polarion SAFe framework, use `PROJECT_PLANS` (Project Plans) mode.
The four SAFe Plans Modes only work when your Polarion instance has the SAFe Solution structure configured. Without it, these modes will not find any Plans to display. If you are not using the Polarion SAFe framework, use **Project Plans** (`PROJECT_PLANS`) mode.
SAFe configuration in Planningboard is highly context-dependent. The widget parameters exposed in the configuration UI differ depending on which Plans Mode you select — `PROJECT_PLANS` shows Scope/Query/Type fields, while SAFe modes show different fields such as the Program Increment Parameter ID. Each SAFe hierarchy level (Portfolio, Program, Team) requires distinct configuration. If you are setting up a SAFe Planningboard for the first time, consult the SAFe Integration concept page: [SAFe Integration](/planningboard/concepts/safe-integration).
SAFe configuration in Planningboard is highly context-dependent. The widget parameters exposed in the configuration UI differ depending on which Plans Mode you select — Project Plans mode shows Scope/Query/Type fields, while SAFe modes show different fields such as the Program Increment Parameter ID. Each SAFe hierarchy level (Portfolio, Program, Team) requires distinct configuration. If you are setting up a SAFe Planningboard for the first time, consult the SAFe Integration concept page: [SAFe Integration](/planningboard/concepts/safe-integration).
***
## How Plans Mode Interacts with Other Configuration
Plans Mode is not an isolated setting — it affects what other configuration options are available and meaningful.
### Effect on Plan query fields
When `plansMode` is set to Project Plans (`PROJECT_PLANS`), you write your own `plansQuery`. When any SAFe mode is active, the Plans query is set automatically (for example, SAFe Sprints in Program (`safeSprints`) hardcodes the iteration plan template filter) — your manual `plansQuery` is not used for Plan discovery in those modes.
### Effect on plan cells mode and normalization
`planCellsMode` — which enables capacity normalization per plan–resource cell — works with Project Plans (`PROJECT_PLANS`), SAFe Sprints in Program (`safeSprints`), and SAFe Sprints in Portfolio (`safePflSprints`) modes. It is **not** compatible with **Parent Item** (`PARENT`) assignment mode. If you are using parent items as swimlanes, plan cells mode (and therefore normalization) is unavailable regardless of which Plans Mode you choose.
See [Normalization](/planningboard/concepts/normalization) and [Capacity Tracking](/planningboard/concepts/capacity-tracking) for the relationship between Plans Mode, plan cells, and capacity bars.
### Effect on the Plans column window
`lastPlans` and `nextPlans` apply in Project Plans mode. In SAFe modes, the Plans visible are determined by the SAFe hierarchy structure and not by a numeric past/future window.
***
## Choosing the Right Mode
The following decision points help you select the appropriate mode:
For the majority of Polarion projects without SAFe, **Project Plans** is the right starting point. It gives you full control via `plansQuery` to select exactly which Plans appear as columns.
***
## Common Misconceptions
**"Plans Mode controls what work items are shown."** No — `plansMode` controls which Plans become columns. Which work items appear is controlled by the `query` widget parameter and the `wiType` filter. Plans Mode and work-item filtering are independent.
**"Changing Plans Mode changes the swimlane configuration."** No — swimlanes are determined by the `assignmentMode` and related parameters. You can combine any Plans Mode with any swimlane Assignment Mode. Plans Mode affects columns; Assignment Mode affects rows.
**"SAFe Sprint modes require a manual plansQuery."** No — in SAFe modes, the Plans query is automatic (e.g. SAFe Sprints in Program (`safeSprints`) uses the iteration plan template). You do not write a Lucene `plansQuery` for Plans discovery in SAFe modes.
**"lastPlans and nextPlans always apply."** Only in Project Plans mode. SAFe modes discover Plans from the SAFe structure, not from a numeric window relative to today.
***
## Limitations
* Planningboard swimlane configuration does not support Polarion page parameters (e.g. `$pageParameters.xxx`) for dynamic plan filtering. Plan selection through `plansQuery` uses static Lucene expressions.
* Custom Team work item types (as opposed to Nextedy's standard Team work item) are not supported in Planningboard for swimlane configuration. If your deployment uses custom Team work item types, consider using Nextedy GANTT (which added support for custom team types in version 25.5.0) as the primary planning tool for team-based scenarios.
* SAFe modes require Polarion's SAFe Solution structure. There is no partial or emulated SAFe Plans Mode for projects that model SAFe hierarchies with custom work item types outside the Polarion SAFe plugin.
***
## Related Concepts
* [Board Structure](/planningboard/concepts/board-structure) — how Plans (columns), swimlanes (rows), and cards fit together
* [Swimlane Assignment Modes](/planningboard/concepts/assignment-modes) — how work items are grouped into rows
* [Capacity Tracking](/planningboard/concepts/capacity-tracking) — how capacity bars relate to Plans and their work item loads
* [Normalization](/planningboard/concepts/normalization) — how plan cells mode distributes capacity across Plans
* [SAFe Integration](/planningboard/concepts/safe-integration) — detailed guidance for SAFe Plans Mode configuration at each hierarchy level
**KB Articles**
* Introduction to Planningboard
* Swimlane Assignment Types
* Planningboard interface & basic interactions
**Support Tickets**
* [#6681](https://support.nextedy.com/helpdesk/tickets/6681)
* [#5879](https://support.nextedy.com/helpdesk/tickets/5879)
* [#6546](https://support.nextedy.com/helpdesk/tickets/6546)
**Source Code**
* `AssignmentMode.java`
* `Config.java`
* `PlansMode.java`
* `PlanningBoardWidget.java`
* `enum-rows-filter.cy.ts`