Rolling Up Story Points Across Jira Projects

Four approaches exist for rolling up story points across Jira projects: (1) a manual JQL sum in a dashboard gadget, (2) Jira Plans' native velocity rollup (Premium only), (3) Structure's Expr formulas, and (4) Foundation's Lens rollups. Each trades accuracy, scale, or consistency — there is no single correct pick without knowing your team's tier, project count, and tolerance for drift.

Why can't Jira natively sum story points across projects?

Jira's Story Points field is a per-issue numeric custom field. JQL can filter issues across projects, and a dashboard gadget can sum that filter's results — but Jira's data model has no built-in concept of “total points for a program spanning Epics in five projects with their child Stories scattered across another three.” The sum is mechanically possible; the hierarchy-aware rollup is not.

That gap is exactly what program managers hit when a VP asks a simple question: “How far along is the Roadmap initiative?” The Roadmap initiative is an Epic in project ROAD. Its Stories live in ALPHA, BETA, and GAMMA. Native Jira has no screen that sums the Stories' points back up to the initiative. You end up building the rollup by hand, which is where the four options below come in.

Option 1 — Dashboard gadgets (Two-Dimensional Filter Statistics, etc.)

The cheapest option: build a JQL filter, drop it into a Two-Dimensional Filter Statistics or Filter Results gadget with “Statistic Type” set to Sum of Story Points, and you'll get a cross-project total. A filter like:

"Epic Link" = ROAD-42 OR parent = ROAD-42

returns every child of the Roadmap Epic across every project the user has BROWSE in, and the gadget sums their Story Points. For a single initiative with a one-layer hierarchy, this works. See the JQL configuration docs for operator reference.

Where it breaks: multi-level hierarchies (Initiative → Epic → Story), Flex Items outside Jira, point sums that need to exclude resolved work older than N days, and any question that requires knowing the parent-child relationship at sum time. The gadget is flat by design. For a program with 8 Epics and 600 Stories across 5 projects, you end up stacking 8 gadgets on one dashboard — each with its own JQL — and emailing a screenshot to the VP. That's the failure mode this cluster exists to solve.

Option 2 — Plans / Advanced Roadmaps rollups

Jira Plans (formerly Advanced Roadmaps) does hierarchical rollups natively — Initiative totals include Epic totals, which include Story totals. It also supports capacity planning by team velocity, which is the correct way to think about story points at the program level: not as a raw sum, but as velocity-adjusted completion forecasts.

The catch: Plans requires Jira Premium. Standard and Free tiers have no access. If you're already paying for Premium across the org, Plans is the path of least resistance for cross-project rollup. If you're on Standard, the math usually doesn't work — upgrading to Premium for rollup alone is typically 2–4x the per-user cost of a Marketplace PPM app. Plans' rollups are also strongest for Epic-level and above; for deep trees with custom hierarchy levels (Theme → Program → Initiative → Epic → Story), the native Plans hierarchy is limited compared to what Structure or Foundation expose.

Option 3 — Structure Expr formulas (what they can/can't do)

Structure by Tempo ships an expression language called Expr that computes values at the rollup level with a spreadsheet-like formula syntax. For story points, the canonical formula is roughly:

sum(children, 'Story Points')

You can layer filters, conditionals, and percentage calculations on top — “sum of points in Done Stories divided by sum of all points, shown as a progress bar” is a one-line Expr formula. This is the most flexible of the four options for teams who want to model program metrics beyond raw sums (weighted effort, points-per- assignee, velocity-adjusted ETAs, etc.).

Cost: Structure and Structure.Gantt are separate paid Marketplace subscriptions stacked on top of each other, and Expr has a learning curve comparable to spreadsheet formulas. For a team that already builds in Structure and has a formula champion, Expr rollups are powerful. For a team that just needs “340 of 600 points done,” it's more machinery than the question requires.

Option 4 — Foundation Lens rollups (today vs. when formula engine ships)

Foundation rolls up numeric fields — Story Points, Original Estimate, Time Spent, any custom numeric field — at the parent level inside a Lens. The math today is a sum of the field across descendants, computed server-side against Foundation's issue cache and served inline in the hierarchy grid. No formula string, no Expr to learn, no per-column config — if the field is numeric, Foundation rolls it up.

Foundation's MVP does not ship a formula engine. If you need “points weighted by priority divided by team-specific velocity” today, Foundation cannot express that; Structure's Expr can. The formula engine is on Foundation's Q1 2027 roadmap, at which point the gap closes. Until then, Foundation's pitch is: the 80% of teams who just need clean hierarchical sums get a dramatically simpler experience (and a single-app bundle — Lens, Gantt, and rollup are all one product, not three stacked subscriptions), and the 20% who need Expr-grade formulas can keep using Structure.

Story-point normalization — what to do about different team scales

Story points are a team-relative unit of effort, per the Scrum Guide. A 5-point Story on Team Alpha is not the same amount of work as a 5-point Story on Team Bravo — each team calibrates its scale against its own past work. Summing across teams produces a number, but the number is semantically misleading because you're adding unlike units.

Three pragmatic workarounds. Report at the team level. Don't roll up across teams; show “Team Alpha: 120 of 200 points, Team Bravo: 80 of 100 points” and let the VP do the mental math. Convert to percentage complete. Percentage is scale-free: 60% on Team Alpha and 80% on Team Bravo means something even though the absolute point counts aren't comparable. Convert to a neutral unit. Some orgs use ideal days or hours as a cross-team lingua franca, computed per team as “team velocity in points per sprint ÷ team capacity in days.” Works but adds overhead. Most mature programs settle on percentage complete because it survives team scale changes.

How do you keep the rollup fresh as issues move?

Every approach above has a freshness model, and they differ materially. Dashboard gadgets poll their underlying JQL when the dashboard loads — stale until refresh, no push notifications. Plans refreshes on Plan open and on explicit recalculation; it does not push updates into an open tab. Structure recomputes formulas on change detection in its own data layer; the exact latency depends on your Structure tier and how the formula is scoped. Foundation subscribes to Jira's `avi:jira:updated:issue` product event (free under Forge's rate-limit model) and updates the rollup within seconds without the user refreshing — including when an issue moves between projects.

Event-driven freshness matters more than it sounds. In a program with 500+ active issues, batch-refresh tools feel stale by mid-morning; by the time the VP's 2pm status meeting runs, the dashboard has absorbed three hours of change without reflecting any of it. A push-based system gives you “as of right now” answers without a ritual of hitting refresh.

Comparison table

Where Foundation fits

For a Scrum Master or engineering manager who just needs to tell a VP “the Roadmap program is 340 of 600 points complete,” Foundation is the shortest path: one Lens scoped by Sync Agent, numeric column set to Story Points, parent rows show the sum automatically, and the number refreshes in seconds as Stories get resolved. No formula writing, no Premium upgrade, no stacked subscriptions. If your rollup needs cross-team normalization or weighted velocity math, Structure's Expr remains the more expressive tool until Foundation's formula engine ships.

Related reading

• Cross-Project Jira Reporting — pillar guide
• See all Jira issues across projects
• Cross-project JQL vs Sync Agents
• Foundation Lenses — cross-project hierarchical views

Frequently asked questions

Sources

• Use story points in Jira Software — Atlassian support
• Configure advanced issue search with JQL — Atlassian support
• What are Plans? — Atlassian support
• The Scrum Guide — scrumguides.org
• Structure by Tempo — Atlassian Marketplace
• Foundation for Jira — Atlassian Marketplace listing