Qualifying and Prioritising Use Cases

The idea in one minute#

A workshop will produce twenty ideas. Most organisations then start the most exciting three, which are usually the hardest three. A use-case scorecard replaces excitement with three scores: value — what it is worth; feasibility — whether it can be built with the data, systems and skills that exist; and risk — what happens when it is wrong.

Two steps, in this order. Qualify: remove ideas that fail a hard test — no owner, no data, not legal, not an AI problem. Prioritise: rank what is left, and choose a first project that is valuable and easy, because the first project’s real job is to prove the organisation can ship one.

The output is a portfolio on one page: do now, do next, prepare for, drop. The reasons for “drop” are written down, so the same idea does not return every quarter.

A picture#

flowchart LR
  I[":i-message-square: <b>20 ideas</b><br/><small>from workshops and requests</small>"] --> G[":i-funnel: <b>Qualify</b><br/><small>owner? data? legal? AI-shaped?</small>"]
  G -->|"fails a gate"| X[":i-archive: <b>Dropped, with a reason</b>"]
  G --> S[":i-list-checks: <b>Score</b><br/><small>value · feasibility · risk</small>"]
  S --> Q1[":i-zap: <b>Do now</b><br/><small>high value, high feasibility</small>"]
  S --> Q2[":i-clock: <b>Do next</b><br/><small>high value, needs groundwork</small>"]
  S --> Q3[":i-wrench: <b>Quick wins</b><br/><small>modest value, easy</small>"]
  S --> Q4[":i-ban: <b>Not now</b><br/><small>low value or high risk</small>"]
  class I neutral
  class G,S queue
  class X,Q4 warn
  class Q1 compute
  class Q2,Q3 memory

How it really works#

Step 1 — qualify with five gates#

Each gate is yes or no. An idea that fails one is parked until the answer changes.

Expect half the list to stop here. That is the gate working.

Step 2 — score what remains#

Score each of three dimensions from 1 to 5 using written anchors, so that two people scoring the same idea land close together.

Value — what is it worth each year?

Feasibility — can we build and run it with what we have?

Risk — how bad is a wrong output, and can it be caught?

Risk works against the idea, so the priority score subtracts it:

priority = value × feasibility ÷ risk

The formula matters less than the conversation it forces. When the head of claims scores value 5 and the data owner scores feasibility 2, you have learned something no slide would have told you.

Where the value comes from#

Value claims are easy to inflate. Sort each one into a type and apply the matching discount.

“Time saved” deserves suspicion. Twenty minutes saved for each of a thousand people is not 333 hours of benefit unless something changes — fewer people, more output, a faster service. Ask the sponsor what will be different, and write the answer into the business case.

Common use-case families#

Knowing the families speeds up scoring, because each has a typical profile.

A sensible first portfolio is two items from the top half of that table, chosen because they are useful and because they force the organisation to build the shared pieces — the gateway, the evaluation practice, the approval path — that everything later will need.

Choosing the first project#

The first project is special. Besides its own value, it has to prove that the organisation can take an AI system through security, legal and operations into production. Choose one that is:

• Internal, so that mistakes are caught by colleagues rather than customers.
• Assisting a person, at autonomy level 0 or 1.
• Backed by an impatient sponsor with a number they care about.
• Deliverable in about three months.
• Reusable — its plumbing serves the second and third projects.

Do not start with the chief executive’s favourite agent idea. Start with the one that will actually launch, and use it to earn the right to do the ambitious one.

Presenting the portfolio#

One page, four boxes, every dropped idea listed with its reason.

DO NOW (this quarter)               DO NEXT (after groundwork)
 Claims document extraction          Customer status assistant
 Policy knowledge assistant            — needs identity integration

QUICK WINS (small, easy)            NOT NOW
 Email triage for claims inbox       Autonomous claim settlement — risk 5, legal gate
                                     Fraud prediction — classical ML, different team
                                     Voice agent — no baseline, no owner

Code#

A scorecard you can run in the workshop. It applies the gates, scores what passes and prints the portfolio. The ideas and scores are examples.

// usecases.go — gate, score and rank a list of use-case ideas.
package main

import (
	"fmt"
	"sort"
)

type idea struct {
	name                         string
	owner, baseline, data, legal bool
	aiShaped                     bool
	value, feasibility, risk     float64 // 1–5 each
}

func gate(i idea) string {
	switch {
	case !i.owner:
		return "no sponsor"
	case !i.baseline:
		return "no baseline number — back to discovery"
	case !i.data:
		return "data missing — data project first"
	case !i.legal:
		return "not permitted as described"
	case !i.aiShaped:
		return "rules or a report solve it"
	}
	return ""
}

func bucket(i idea) string {
	switch {
	case i.risk >= 4:
		return "NOT NOW (risk)"
	case i.value >= 4 && i.feasibility >= 4:
		return "DO NOW"
	case i.value >= 4:
		return "DO NEXT"
	case i.feasibility >= 4:
		return "QUICK WIN"
	}
	return "NOT NOW"
}

func main() {
	ideas := []idea{
		{"claims document extraction", true, true, true, true, true, 5, 4, 2},
		{"policy knowledge assistant", true, true, true, true, true, 4, 5, 1},
		{"customer status assistant", true, true, true, true, true, 4, 3, 3},
		{"email triage for claims inbox", true, true, true, true, true, 2, 5, 1},
		{"autonomous claim settlement", true, true, true, false, true, 5, 2, 5},
		{"fraud prediction", true, true, true, true, false, 5, 3, 3},
		{"voice agent for call centre", false, false, true, true, true, 4, 2, 4},
		{"agent that renegotiates supplier terms", true, true, true, true, true, 4, 2, 4},
	}

	var passed []idea
	fmt.Println("gates:")
	for _, i := range ideas {
		if why := gate(i); why != "" {
			fmt.Printf("  dropped  %-40s %s\n", i.name, why)
			continue
		}
		passed = append(passed, i)
	}

	score := func(i idea) float64 { return i.value * i.feasibility / i.risk }
	sort.Slice(passed, func(a, b int) bool { return score(passed[a]) > score(passed[b]) })

	fmt.Println("\nranked:")
	for _, i := range passed {
		fmt.Printf("  %5.1f  %-40s V%.0f F%.0f R%.0f  %s\n",
			score(i), i.name, i.value, i.feasibility, i.risk, bucket(i))
	}
}

The knowledge assistant outranks the higher-value extraction project because it is nearly risk-free and easy. That is the scorecard telling you which one to ship first — and which one to fund next with the credibility it earns.

Remember this#

• Qualify before you prioritise: owner, problem, data, permitted, AI-shaped.
• Three scores with written anchors: value, feasibility, risk.
• Distrust “time saved” until someone says what will be different.
• The first project must be internal, assistive, sponsored, short and reusable.
• Write down why each idea was dropped.

Try it#

1. Run usecases.go. Change the risk of “customer status assistant” to 2. Where does it move, and what control would justify that lower score?
2. List ten AI ideas for an organisation you know. Run the five gates by hand. How many survive?
3. For the top survivor, sort its claimed value into the five types. How much of it is “time saved”, and what would have to change for that to be real?

Check yourself#

1. What are the five gates, and what happens to an idea that fails one?
2. Why does the priority formula divide by risk?
3. Why is the highest-value idea often the wrong first project?
4. A sponsor says the project saves 20 minutes a day for 2,000 staff. What is your next question?