Portfolio

The Innovation Engine

Every company has more technology ideas than capacity to build them. This page is a working model of a system that decides. Requests come in, get scored with an industry-standard prioritization framework, and only what fits the quarter gets committed. Everything on this sheet is live: drag the controls, click the cases.

Why I built this

Working in Enterprise Architecture, technology portfolio intake and prioritization are a key component of my work. This tool demonstrates the three things a portfolio owner actually does: score demand honestly, commit within real capacity, and account for the value that ships.

Open the live consolethe backlog is infinite. the quarter is not.
REQUESTS INST-0101INTAKERequest loggedST-0202TRIAGEScored & ratedST-0303SCOPINGSolution shapedST-0404DELIVERYBuilt & shippedST-0505LOOKBACKValue verifiedCAPACITY GATE60 ENG-WK / QTRBACKLOG (HOLDING)7 CASES · SCORES RETAINEDVALUE OUT$3.87M/QTR
Fig. 1 — How a request becomes delivered valueORANGE = COMMITTED | GRAY = HELD FOR A LATER QUARTER

0

Active cases

0

Departments served

$0.00M

Value committed / qtr

0

Eng-weeks planned

Fig. 2

Same portfolio, four strategies

Change what the business values and the ranking changes with it. The red line is where capacity runs out. Click any case to open its file and see exactly why it ranks where it does.

Strategy
BalancedEvery factor weighed evenly. The default plan.
capacity · 60 wk
Cycles automatically. Hover or tap to explore.Take the controls
Index

Systems in scope

Prioritizing this work means understanding what it plugs into. The sixteen cases touch 34 systems across the estate — ERP and land, CRM, real-time operations, the data platform, workflow, and compliance. Open any case in Fig. 2 to see the stack behind it.

ERP, land & finance
  • SAP S/4HANA
  • SAP Plant Maintenance
  • SAP Ariba
  • Quorum Land
  • Quorum Revenue
  • Quorum JIB
  • Aucerna Enersight
CRM & customer platforms
  • Salesforce Sales Cloud
  • Salesforce Service Cloud
  • Salesforce Field Service
  • Salesforce Experience Cloud
  • Salesforce Marketing Cloud
  • DocuSign
  • Twilio
Operations & real-time data
  • AVEVA PI System
  • Peloton WellView
  • Quorum Pipeline (TIPS)
  • ION Openlink Endur
  • Project Canary
  • Samsara
  • Aucerna Aries
Data platform & analytics
  • Databricks
  • Snowflake
  • Azure Data Factory
  • Azure ML
  • Power BI
Workflow & automation
  • ServiceNow
  • Power Automate
  • Power Apps
  • SharePoint
  • Kofax
Geospatial, HSE & compliance
  • Esri ArcGIS
  • Sphera
  • ISNetworld
Notes

How the scoring works

The method is standard. The discipline is applying it to everything, every time.

  1. 1
    Every case gets the same math: Weighted Shortest Job First (WSJF), the prioritization standard from the Scaled Agile Framework. Cost of delay divided by job size, adjusted for delivery risk and how well the work is understood.P = (w₁·value + w₂·strategic + w₃·time) ÷ effort × conf × (1 − risk)
  2. 2
    Capacity is treated as a physical constraint. The quarter holds 60 engineer-weeks. The plan commits the highest-scoring cases that fit and holds the rest, with their scores intact, in plain sight. Triage scores are deliberately cheap estimates; full diligence is spent only on cases that clear the gate.
  3. 3
    We track delivered work. At lookback, realized value is recorded against the original estimate. Shortfalls stay on the record; that is what makes the estimates worthwhile.
  4. 4
    The portfolio here is synthetic, since real case data is confidential. The ratings are tuned so the trade-offs are real: the biggest-dollar case does not simply win. The scoring engine is not simplified.

Reference standards

STD-01WSJF · Weighted Shortest Job FirstScaled Agile Framework (SAFe)Priority scoring: cost of delay ÷ job size
STD-02Cost of DelayReinertsen, Principles of Product Development FlowValue + strategic + time-criticality numerator
STD-03Confidence weightingRICE scoring model (Intercom)Discounts poorly scoped cases
STD-04Greedy knapsack allocationClassical combinatorial optimizationFills finite capacity in rank order
Fig. 3

Pipeline health, measured

Five dimensions computed from the live plan, not asserted on a slide: does delivered work hit its value target, how fast demand clears, whether the team is sanely loaded, how much available value the plan captures, and how well-scoped the portfolio is.

050100
62

Overall

050100
67

Reliable

050100
36

Fast

050100
98

Supported

050100
41

Valuable

050100
69

Clean

Record

What shipped, and what it returned

Lookback results for delivered cases. The estimates are accountable.

CasePromisedRealizedFinding
Vendor onboarding & compliance portalSPC-1078$430K$470KMet · 109%
Drilling-cost benchmarking modelSPC-1096$790K$610KShort · 77%
Contractor-safety analyticsSPC-1128$340K$355KMet · 104%
Spec

How it's built

The portfolio thinking is the point, but the implementation is mine too, end to end.

The scoring engine is a pure TypeScript module with typed interfaces for cases, weights, and plans. The same functions rank the cases in every figure on this page and in the live console, so the drawing can never disagree with the tool.

The interface is React with spring physics driving the re-ranking, the diagrams are hand-authored SVG animated with native browser primitives, and the whole site ships as a static export. No backend, no database, nothing to patch: it runs from any CDN and the plan recomputes client-side in under a millisecond.

Motion respects prefers-reduced-motion, the console exports its plan to CSV, and the case files you can open in Fig. 2 read from the same data model the engine scores.

Construction spec

  • TypeScript
  • React 19
  • Next.js 16 · static export
  • Tailwind CSS 4
  • Framer Motion
  • SVG + SMIL animation
  • Pure-TS scoring engine
  • CSV export
  • prefers-reduced-motion support

Demonstration project · portfolio data is synthetic · the scoring engine is real