From magazine topic to project implementation
Relevant service and technical pages for this post
Monday morning, 8:45 a.m. There are twelve initiatives on the portfolio call agenda, all marked with a red exclamation. The business unit wants a process change live before the next audit. IT wants to replace an obsolete interface because it regularly causes disruptions. And „while were at it“, a new reporting solution should be created as well.
After 30 minutes the decisive moment occurs: no one disputes that everything is somehow important. The group is hung up on a different question: By what criteria do we decide — so that the decision still holds next week? This is precisely where it becomes clear whether you prioritize your project portfolio or whether in the end the loudest demand and the next gut feeling prevail.
The less helpful reaction is common: each initiative is discussed individually, apples are compared to pears, and in the end there is an order that hardly anyone can explain. The better reaction appears unspectacular: a small evaluation grid that makes benefit, risk and dependencies visible enough that decisions become repeatable — even when people change or new requirements appear at short notice.
This article provides a practical grid without tool mandates and without method debates. The perspective remains deliberately operational: What does this mean for operations, data, interfaces, implementation risks and the cooperation between IT, the business unit and project management?
Why portfolio prioritization seldom fails because of strategy, but because of everyday operations
In organizations with established processes, demand for changes to business software is almost always higher than delivery capacity. Even when budget exists, test windows in the business unit are often missing, available administrators for rollouts are scarce, stable data for migrations is lacking, or simply the opportunity to absorb multiple productive changes in parallel. Prioritization is therefore less a position paper than constraint management.
A usable evaluation grid must achieve three things at once:
- Comparability: Initiatives are evaluated against the same criteria.
- Traceability: You can explain why a project ranks high — without slide acrobatics.
- Manageability: Preparation must not create more effort than the decision saves.
A look at established portfolio practice confirms this requirement exactly: scorecards with criteria on alignment, expected benefit/return, risks and explicitly also dependencies are considered common practice.[Source] The practical conclusion: dependencies do not belong in the „technical corner“, but are core to the portfolio view, because they determine sequences, deadlines and operational windows.
Prioritizing the project portfolio with a matrix: consciously separate benefit, risk and dependencies
Many prioritization models fail because they try to compress everything into a single metric. A two-step logic that reflects the reality of IT landscapes is more practical:
- Scoring for benefit and risk (comparable, fast, repeatable).
- Portfolio logic for dependencies and capacity limits (not to be „subtracted away“, but to be decided).
This separation matches a practicable approach: first criteria are combined and weighted; afterwards the ranking is deliberately adjusted according to additional aspects such as scheduling or functional dependencies and constraints — instead of forcing dependencies into a single criterion.[Source] The practical benefit: in stage two you can clearly state „Project B must come before Project A“ without bending the model or retroactively changing the evaluation.
Scales that limit discussions rather than prolong them
For an entry-level matrix, scales from 0 to 5 are sufficient. That is coarse enough to avoid endless debates, and fine enough to show differences. What matters is not the math but the definitions: each level needs a short description so that a „4“ does not mean something different depending on the person.
The criteria: what you should actually evaluate (and how to make it tangible)
In the B2B environment, benefit is rarely just „more revenue“, and risk is rarely just „too expensive“. Portfolio decisions often hinge on process throughput times, data quality, stability, auditability, integration capability and operational effort. The matrix below is built so that feature projects and modernization initiatives become comparable — without having to artificially sell modernization as a „feature“.
Proposal: 8 criteria (0–5 points) plus dependencies as a separate block
| Criterion | What is assessed? | Typical evidence/signals | Scale note (0–5) |
|---|---|---|---|
| Process benefit | Relief/improvement in the core process (time, errors, media discontinuities) | Measurable wait times, manual steps, follow-up queries, SLA violations | 0 = barely noticeable, 5 = a clear bottleneck is eliminated |
| Operational risk reduction | Fewer outages, fewer incidents, improved support | Incident clusters, unstable jobs, manual workarounds, on-call load | 0 = no impact, 5 = critical instability is addressed |
| Security/Compliance | Reduction of security or audit risks | End-of-life announcements, missing patches, audit findings, unclear permissions | 0 = not an issue, 5 = relevant risk/deadline/audit point |
| Data and integration value | Improvement of data quality, interfaces, reporting capability | Duplicate-record costs, Excel exports, inconsistent master data, fragile interfaces | 0 = local, 5 = noticeable leverage across multiple systems |
| Strategic fit | Does the initiative align with the roadmap and target architecture? | Product/service strategy, platform decisions, standardization initiatives | 0 = contradicts, 5 = directly contributes |
| Deliverability (complexity) | How well can the initiative be delivered with existing capabilities? | Number of interfaces, data migration, testing effort, availability of key users | 0 = currently hardly deliverable, 5 = clearly defined and testable |
| Time Criticality | Consequences of a delay (deadline, season, contractual/audit window) | Deadlines, planned releases, product deprecations, regulatory dates | 0 = no deadline, 5 = strict deadline |
| Effort range/uncertainty | How large is the uncertainty in effort and scope? | Unclear requirements, missing system knowledge, unknown data situation | 0 = very uncertain, 5 = well understood and estimable |
Two details save a noticeable amount of time in practice:
- Availability is not the same as effort. A small but hard-to-test initiative can be riskier than a larger, clearly delimited package.
- Effort range/uncertainty is deliberately phrased positively. You are not rating „how expensive“, but „how well understood“. That creates an incentive for thorough preparatory work instead of wishful thinking.
Handle dependencies rigorously: score first, then determine order
Dependencies are the most common reason for „That can’t be done now“ in portfolio rounds — and at the same time the part that is least often documented. In IT landscapes, dependencies are typically:
- Technical (interfaces, data models, authentication/SSO, version levels),
- Organizational (key-user availability, trainings, acceptance milestones),
- External (vendor deprecations, service provider slots, platform migrations).
That dependencies are a central checkpoint is explicitly reflected in portfolio standards as well: When reviewing portfolio components, in addition to priority, scope, expected return and risks, dependencies are also named as a criterion.[Source] For day-to-day work this means: Anyone who only looks at dependencies „sometime“ merely postpones the actual decision — often into the go-live phase, when it becomes expensive.
A dependency register you actually maintain (3 fields)
Instead of complex network diagrams, a minimal register per initiative works for many portfolios:
- Blocker: What must be finished beforehand, otherwise the initiative cannot be sensibly tested or operated?
- Enabler: What does this initiative make possible (downstream projects)?
- Coupled releases: What must be rolled out together (e.g. API + portal, data model + report)?
This creates a language that is tangible even for non-developers: „If we don’t stabilize the interface first, we cannot reliably populate the new reporting.“ That is a delivery condition, not an opinion.
Constructed scenario: 25 minutes, three projects, one decision that holds
The added value of this approach is not „a pretty ranking.“ It creates clear cut interfaces: pre-phases, coupled releases and deliberate Stop/Go decisions. That relieves operations and business units because fewer half-finished workstreams run in parallel.
Weighting and thresholds: How the matrix stays fair
Almost every organization has the same concern: „Then Security always wins“ or „Then the business always wins.“ Both happen when criteria stand side by side without weighting or when there are no threshold rules.
A weighting starting point that has proven effective (and remains easily adjustable)
- Value (process benefit, data/integration, strategic fit): together 50%
- Risk/Protection (operational risk reduction, security/compliance, time criticality): together 35%
- Deliverability (delivery capability, effort range/uncertainty): together 15%
This way you prioritize value without sidelining risks, and you avoid penalizing extreme uncertainty so severely that no one reports initiatives as „unclear.“ A PMI-aligned representation assigns priority mainly to the drivers Business Alignment, Value and Risk.[Quelle] The limitation is clear: such representations do not provide „correct percentages“ for your organization. The conclusion is nevertheless practical: if risk is missing from the model, it will later surface as an incident, hotfix or escalation in operations.
Three threshold rules that noticeably shorten discussions
- Must-do for clear deadlines (decommissioning, audit, contractual requirements) – but only with documented evidence, not as a label.
- Stop/Go for very low effort certainty: first a pre-phase, then reassessment.
- WIP-Limit (Work in Progress = limit concurrently started initiatives): maximum X parallel initiatives per team/component, otherwise lead times and error rates increase.
The process in operations: 7 steps you can actually fit into the calendar
- Clarify intake (15 minutes per initiative): title, objective, affected processes, affected systems, rough scope.
- Collect minimal facts: Which metric, which event or which risk substantiates the need?
- Prepare scoring: Two people assess independently in advance (IT + business unit), then a short reconciliation.
- Portfolio review: Explain scores in the call, do not invent them on the spot. Differences are justified and recorded.
- Check dependencies: Make blockers/enablers/coupled releases visible, deliberately adjust sequencing.
- Align capacity and operational windows: Test capacity, deployment frequency, training, peak times, parallel operation.
- Document the decision: Top list + waiting list + stop/go pre-phases, each with responsible parties and the next review date.
Step 6 is the reality check that many models underestimate: an initiative can make sense from a business or technical perspective and still not start if the test team is in a release wave or if parallel operation would double the support load. That is not a „failure“ of the framework, but the consequence of operations and delivery capacity.
Typical misreactions in the portfolio call — and the better response
Poor reaction 1: „We ll do a bit of everything“
That sounds accommodating, but it leads to parallel partial implementations, unclear acceptances and increased integration effort. In operation this appears as a higher need for hotfixes, more support tickets and maintenance windows that become hard to plan.
Better response: Slice initiatives so each package is testable and operable. If that is not possible, it is a signal: either dependencies are unclear or an architectural decision is missing (e.g. interface strategy, identity concept, data ownership).
Poor reaction 2: Dependencies are dismissed as „details“
Especially in custom enterprise software, interfaces, data models and permissions are often the hidden drivers of time and risk. Ignoring dependencies shifts risk into the final phase: data migration, UAT (User Acceptance Testing = acceptance tests by business users) and go-live become hectic because the „last 10%“ suddenly touch system boundaries.
Better response: Treat dependencies early as delivery conditions: what must be in place beforehand so tests, training and rollout can be executed cleanly? That question determines schedule and operational risk.
Poor reaction 3: Risk is discussed only qualitatively
That creates a deceptive calm — until a deprecation hits or a security vulnerability forces operations to bring forward unplanned work. A simple risk scoring does not have to be complicated: risk is often structured by impact and factors such as likelihood, exposure or existing controls. PMI describes practical matrices and total-score approaches that support prioritization.[Quelle]
Limit: A score does not replace an in-depth risk analysis for critical systems. Practical consequence: Use the framework as an early-warning system: a high risk score should trigger a targeted deep dive (security review, architecture check, migration concept) — not automatically a large project with unclear scope.
Why modernization need not get lost in the framework
Portfolio rounds easily tip into ‚features first‘. That is understandable: features are visible and easy to communicate. Modernization is often invisible — until it is missing. The grid above makes modernization visible through concrete effects:
- Operational risk reduction: fewer incidents, fewer manual workarounds, more stable jobs/batch processing.
- Security/Compliance: patchability, traceable access, audit trails, decommissioning.
- Data and integration value: more stable interfaces, fewer data breaks, a better basis for reporting.
That way a ‚technical‘ initiative can receive a high score without rhetorical contortions. At the same time, the deliverability assessment prevents starting modernization as an endless program: if effort certainty is low, a preparatory phase is prioritized (system inventory, interface mapping, data profiling). That is usually easier for decision-makers to accept than a blanket ‚We’re modernizing now‘.
Clear limits: What a simple evaluation grid cannot accomplish
A grid is a tool for comparability — not an oracle. You should state three limits openly so the model is not overloaded:
- Strategic goal conflicts are not resolved by a score: if cost reduction and aggressive scaling are intended in parallel, roadmap, budget logic and decision paths must be clarified.
- Dependencies are never complete: in evolved system landscapes hidden couplings often surface only during testing. The grid can, however, help make this uncertainty visible (low effort certainty) and legitimize preparatory phases.
- Capacity is multidimensional: development may be available, but test, operations or the business domain may not be. Without a capacity check every prioritization remains theoretical.
If you accept these limits, the grid remains robust: it does not produce pseudo-precision, but a common language for decisions.
The concluding point: A prioritization is only good if it still holds tomorrow
Anyone who wants to prioritize a project portfolio needs less methodology and more repeatability. A lean evaluation grid delivers exactly that: benefit and risk become comparable, dependencies are treated as real delivery conditions, and decisions can be justified — even under pressure. The most important step is not perfect weighting, but the discipline to evaluate every initiative with the same criteria and to visibly document deviations.
Once the grid is in place, portfolio rounds usually become shorter. And the actual work shifts back where it belongs: into clearly defined, testable delivery packages with manageable risks.
Sources and further information
The key technical assertions were editorially contextualized based on the following external sources.
- The new PMI standard for portfolio management (www.pmi.org)
Portfolio scorecards use criteria such as expected benefit/return, risks and dependencies; dependencies are an explicit component of portfolio evaluation. - Practical tip: How prioritization can be carried out (www.finanzen.bremen.de)
A practical prioritization is often carried out in two stages: first assess/weight, then deliberately adjust the ranking based on dependencies and constraints. - Prioritization (www.projectmanagement.com)
Priority is determined in a PMI-aligned presentation primarily by Business Alignment, Value and Risk; scoring models aggregate criteria into a ranking. - Integrating risk analysis and prioritization (www.pmi.org)
Risk can be evaluated in a prioritization matrix in a structured way and combined into a total score to support decisions.
Project portfolio management is also important for this topic. The article places these aspects into a clear context and shows what matters in day-to-day practice.
Discuss a project or modernization initiative with Net-Base.
Next step
When the topic becomes an actual project, architecture, existing systems and operations should be considered together from the outset.
We support not only with individual issues, but also when source snippets, legacy topics, or portal ideas are to be turned into a robust enterprise project.
- Current state, target state and technical risks are assessed jointly.
- REST, data access, portals and rollout are not deferred to a later stage as secondary consequences.
- You can see early on which path is economically and operationally viable.