How to Decide What Gets Funded When the Budget Covers Half Your Ideas

Two expensive things happen in every prioritization meeting.

A good initiative loses to a weaker one, because someone had a sharper deck or a bigger title.

And a doomed project limps along for another year, quietly eating budget and engineering capacity, before everyone admits what half the room already knew.

If you’ve sat at the top of a portfolio, you’ve likely seen both. Probably this quarter.

The problem is rarely a lack of ideas. It’s that most organizations don’t have an honest, shared way to compare them.

Scorecards appear. Everything earns a one to five on impact, effort, and strategic fit to generate a list of 20 priorities that are all deemed urgent. And everyone quietly tunes the weights until their own project lands on top.

I got tired of watching good capital get allocated by persuasion instead of impact, and of repeatedly explaining to Suzan why her request did not magically become number one just because she asked again with a calendar invite.

So I built a framework to make tradeoffs visible, structured, and easier to defend. And I turned it into an AI-enabled tool called Decision Lens.

The idea is simple.

Reduce every initiative to one number:

Read it over a fixed window, three years for example. Above 1.0 an initiative returns more than it cost. Below 1.0 it does not.

It does not make the answer perfect, but it makes the debate concrete, testable, and harder to game.

The ranked list, best return first, is where those tradeoffs actually get made. It is the decision surface, with the reasoning behind each rank, the gaps it depends on, and the watch-outs a click away on every row.

Everything sits in real dollars, so there are no fake weights to negotiate. Two people who agree on the inputs get the same ranking.

The probability of success measures delivery risk, the odds you ship what you scoped at the cost you entered. Whether the idea is worth doing isn’t part of it, since the benefit already carries that. It comes from the things that drive it, whether you’ve done work like this before, how clean the scope is, how many dependencies, whether the team is in place, whether the technology is proven or still untested, and whether sign-off sits outside your control. Where historical data exists, the tool calculates it from past projects and augments that with AI rather than leaving you to guess. What looks like a hunch is really track record.

And if there is a disagreement, AI can break the stalemate by pulling comparable projects, benchmarks, and historical outcomes, so the debate starts from evidence instead of whoever blinks first.

Every estimate has an owner. Funded work gets checked later against the benefit and odds it claimed. Inflate your numbers, and you are borrowing credibility from the next cycle.

The intake that captures those inputs is AI-assisted. It estimates impact and asks the questions you would have forgotten, so every initiative arrives described on the same inputs. That shared basis is what makes comparing one against another valid in the first place.

Risk does not automatically kill an initiative. It changes the score. A risky bet can still win, but it has to clear a higher bar.

Cost is the whole bill, not the part that’s easy to count. Labor hours, opex, capex, licenses, the run cost after launch. Leave a chunk out and the ratio flatters the project, so everything that the work consumes goes in.

Speed counts too. The framework only counts the years of benefit that land inside the decision window, so a project that takes eighteen months to pay off scores lower than one that creates value now.

Foundational work is handled the same way. Platforms, data, and infrastructure matter, but they do not jump the queue just because someone calls them “strategic.” They are pulled up by the funded initiatives that depend on them. That avoids the enterprise classic of spending a fortune on “the platform first” while everyone politely avoids naming the business outcome.

The AI does not decide what wins. It estimates the inputs, the benefit, the cost, the odds, by pulling comparables instead of guessing on a whiteboard. The formula does the ranking, and the ranking is plain arithmetic, for two reasons.

It’s reproducible. Same inputs, same order, every time, for anyone who opens the file. An AI that ranked would drift when you reran it or reworded the prompt, and a priority list that moves when nothing real has changed is not one a board will trust.

And it’s visible. The reason a project sits where it does is the arithmetic that put it there, so a disagreement always lands on one number someone entered. You point at it. I’d put the benefit at two million, you’d say one. That is a short argument with a winner.

Any input can be overridden by hand, when you know something the estimate doesn’t. The override runs through the same arithmetic, so it isn’t a thumb on the scale. It’s a visible number with your name on it, checked against reality later like every other input.

Resources are limited, and people are not interchangeable. Each initiative carries the specific roles and skills it needs, and the planner ranks against the headcount you actually have. When the plan outruns the team, it maps the gap to the exact roles to hire, telling a genuinely missing skill apart from simply needing more of a role you already employ.

The harder half is reconciling the new plan against work already underway, and that is built in too. In-flight work consumes capacity first, since those people are already committed, and a reclaim-and-shift view surfaces the initiatives now outranked by higher-return work waiting on capacity, showing how many hours you would free by pausing them. The question of what to stop to make room gets answered with the return gap, not an opinion.

The ranking decides what and why. Execution carries when and who, so the high-level plan connects down to the real work two ways. A recommended-versus-actual roadmap tracks live progress against the plan in your work-tracking system, and a timeline builder lets you drag prioritized initiatives onto a roadmap, break them into tasks, and push them to your delivery backlog as epics. One source sets priority. The other runs the work.

Approval is the start of that handoff, not the end. A decision moves from approved to in progress to shipped, a strategic commitment can be pinned so it holds its place across cycles even when newer work outscores it, and every initiative keeps a history timeline, so the question of why something is still a priority is always answerable.

You leave the review with a ranked list, a clear funding line, and a defensible reason behind every call.

The loudest voice stops winning by default.

Risk changes where something ranks, not whether it gets considered.

And the dead project gets challenged using the same math that funded it, instead of becoming a twelve month team building exercise in denial.

The framework is live at decisionlens.space.

Drop in two competing initiatives and watch the tradeoff resolve into a number.