Scaled Agile Plugin for Orangescrum Self-Hosted

Screenshots

Agile Release Train with teams, projects, and roles

Program board with cross team dependencies

Flow metrics over successive Program Increments

Key Features

Agile Release Trains

Define a train, attach the teams and projects that run on it, and assign the SAFe roles: release train engineer, product manager, system architect, and business owner.

Program Increments

Set the PI calendar, lock it once planning is done so the commitment stops moving, and close it when the increment ends.

Iterations Inside a PI

Schedule the iterations that make up a Program Increment, with sensible defaults you can change per company.

Epic, Feature, Story Backlog

A backlog that respects the SAFe hierarchy, with user stories and enabler stories, and enabler kinds for architecture, exploration, infrastructure, and compliance.

WSJF Prioritisation

Score business value, time criticality, and risk reduction against job size. Scores are recorded rather than overwritten, so you can see how a priority argument developed.

Program Board

Place features across teams and iterations and draw the dependencies between them. The layout service keeps the board readable as the plan grows.

Dependency Types

Link backlog items as blocks, related, duplicates, or parent of, so a dependency on the board carries a meaning instead of just a line.

PI Objectives

Capture committed objectives with planned business value, then record actual business value at the end. Uncommitted objectives are tracked separately.

Predictability Measure

Actual business value against planned, per team and rolled up to the train, so the conversation at the next planning session starts from evidence.

ROAM Risks

Raise a PI risk and put it in one of the four ROAM states: resolved, owned, accepted, or mitigated. Nothing sits unclassified.

Confidence Voting

Run the confidence vote at the end of planning and keep the result with the PI, so a low vote is a record rather than a memory.

Inspect and Adapt

Hold an Inspect and Adapt session against a PI and turn what comes out of it into a tracked improvement backlog with owners and status.

Five Flow Metrics

Flow velocity, flow distribution, flow time, flow load, and flow efficiency, snapshotted over time so you can see the trend rather than a single reading.

Kanban States and Rules

Define the Kanban states a backlog item moves through and the transition rules between them, separately from the task level workflow.

45 Permission Keys

Ten permission groups covering trains, backlog, WSJF, PI planning, the program board, objectives, ROAM and confidence, Inspect and Adapt, flow metrics, and administration.

Metric Export

Export flow metric series as CSV for a board pack, and recompute snapshots on demand when historic data changes.

About this plugin

Why Scaled Agile for Orangescrum?

Teams that adopt SAFe usually end up running the ceremony in slides and the work in a tracker, and the two drift apart within a Program Increment. This add-on puts the train, the increment, the board, the objectives, the risks, and the metrics in the same place as the tasks, so the plan and the work are the same records.

Essential SAFe, not a diagram of it

An Agile Release Train holds teams, projects, and the four roles: release train engineer, product manager, system architect, and business owner. A Program Increment holds iterations, can be locked once planning ends so the commitment stops moving, and can be closed when the increment finishes. Everything below it is ordinary Orangescrum work, so nobody has to re-enter anything.

Prioritise with WSJF and mean it

WSJF scores business value, time criticality, and risk reduction against job size. Scores are written as history rather than overwritten, so when somebody asks why a feature moved up the list you can show when and by whom it was rescored. The Fibonacci scale is configurable at the install level.

A program board that carries dependencies

Place features across teams and iterations and draw the dependencies between them, typed as blocks, related, duplicates, or parent of. A dependency is a record, not a line somebody drew on a slide, so when a feature slips you can see what else it takes with it.

Objectives, risks, and the honest conversation

Committed PI objectives carry planned business value, and actual business value is recorded at the end. Predictability is computed per team and rolled up to the train. Risks raised at planning are ROAMed into resolved, owned, accepted, or mitigated, and confidence voting is recorded against the PI. Inspect and Adapt turns the retrospective into a tracked improvement backlog rather than a set of good intentions.

Flow metrics over time

Flow velocity, flow distribution, flow time, flow load, and flow efficiency are snapshotted rather than calculated fresh each time you look, so you get trends across increments and can export a series as CSV for a board pack. There is a wider overview of scaled agile working in Orangescrum at /scale-agile-project-management.

What's included

Agile Release Trains with team membership, project attachment, and role assignments
SAFe roles: release train engineer, product manager, system architect, business owner
Program Increments with a calendar, locking, and closing
Iteration scheduling inside a Program Increment
Backlog of epics, features, and stories with user and enabler subtypes
Enabler kinds: architecture, exploration, infrastructure, compliance
WSJF scoring on business value, time criticality, risk reduction, and job size
WSJF score history and recalculation, with a configurable Fibonacci scale
Backlog ranking and re-ranking
Typed backlog dependencies: blocks, related, duplicates, parent of
Program board with cross team feature placement and dependency visualisation
Automatic program board layout as the plan grows
PI objectives with committed and uncommitted tracking
Planned versus actual business value and a predictability roll-up per team and train
ROAM risks in four states: resolved, owned, accepted, mitigated
Confidence voting recorded against the Program Increment
Inspect and Adapt sessions with a tracked improvement backlog
Five flow metrics: velocity, distribution, time, load, efficiency
Flow metric snapshots with time series, weekly granularity, and CSV export
On demand metric recomputation
Kanban states and Kanban transition rules for backlog items
45 permission keys across 10 groups, managed from a permission matrix
Demo data seeding command for evaluation environments
Multi-tenant company-scoped data isolation

Compatibility

Requires the Orangescrum Self-Hosted edition running PHP 8.2+, CakePHP 4.6+, and PostgreSQL 16. The plugin folder is ScaledAgile and it is gated by the SCALED_AGILE_ENABLED flag in config/constants.php. The interface is a Vue 3 application bundled with the plugin and built with npm. Numeric defaults such as page size, PI and iteration length, the WSJF Fibonacci scale, the confidence vote ceiling, and the objective business value ceiling are set in the host config/constants.php rather than inside the plugin. Multi-tenant aware, so every train, increment, objective, risk, vote, and metric snapshot is company-scoped.

Installation

A self-hosted install takes a few minutes. Buy the add-on, drop the plugin into your plugins/ directory, run the migrations, and you're live.

1
Buy the add-on
Purchase the Scaled Agile add-on from /self-hosted/pricing at $499/year per company, payable annually.
2
Drop the plugin into your install
Copy the ScaledAgile/ folder into plugins/ on your self-hosted Orangescrum server.
3
Enable the feature flag and register the plugin
Add `define('SCALED_AGILE_ENABLED', true);` to config/constants.php and register `ScaledAgile` in src/Application.php with `routes => true, bootstrap => true`.
4
Run the migrations and seeders
Run `bin/cake migrations migrate --plugin ScaledAgile` then `bin/cake migrations seed --plugin ScaledAgile` to create the tables and register the module, menu, and role permissions.
5
Build the interface
Run `npm install` then `npm run build` in plugins/ScaledAgile/vue-app so the application assets are compiled.
6
Set your tunables
Review the SCALED_AGILE_ block in config/constants.php for page size, default PI and iteration length, the WSJF Fibonacci values, the confidence vote ceiling, and the objective business value ceiling.
7
Define your first train
Create an Agile Release Train, attach the teams and projects that run on it, and assign the release train engineer, product manager, system architect, and business owner.
8
Plan your first increment
Create a Program Increment and its iterations, score the backlog with WSJF, lay features out on the program board with their dependencies, commit objectives, ROAM the risks, and take the confidence vote.

Frequently Asked Questions

Which parts of SAFe does this cover?

▾

Essential SAFe. Agile Release Trains, Program Increments and iterations, the epic, feature, and story backlog with enablers, WSJF prioritisation, PI planning and the program board, PI objectives and predictability, ROAM risks and confidence voting, Inspect and Adapt, and the five flow metrics.

Does it cover portfolio or large solution SAFe?

▾

No. The scope is Essential SAFe. There is no portfolio kanban, no lean portfolio management, no epic funding or guardrails, and no solution train layer above the Agile Release Train. If your operating model needs those, this add-on covers the train level only.

Do we have to re-enter our work as SAFe items?

▾

No. The backlog layers on top of the work items you already have in Orangescrum, and WSJF scores and Kanban states are keyed to those items. A story is a story in both views rather than a copy that has to be kept in step.

How is WSJF calculated?

▾

Business value plus time criticality plus risk reduction, divided by job size. Each scoring is written as a new record with the person and the time rather than replacing the last one, so the history of a priority decision survives. The Fibonacci values offered on the scale are set in the host configuration.

How is PI predictability measured?

▾

Actual business value against planned business value on committed objectives, computed per team and rolled up to the train. Where an objective has no team set and the train has exactly one team, it is attributed to that team; with none or several, it is shown as unassigned so somebody can fix it.

How granular are the permissions?

▾

45 keys across 10 groups: ART management, backlog, WSJF, PI planning, program board, PI objectives, ROAM and confidence, Inspect and Adapt, flow metrics, and administration. Module visibility is handled by the core role system, and the feature level matrix is managed from the plugin's permission screen.

Can we try it with sample data?

▾

Yes. A demo data command seeds a train, a Program Increment, iterations, and backlog items so an evaluation environment has something to look at before you plan a real increment.