All posts AI-Native Enterprise

AI use case discovery: why asking teams doesn't work (and a prioritisation matrix)

The short answer

AI use case discovery is the work of finding which processes in a company AI should change, who owns each one, and in what order to build them. Asking teams what they need is the standard method, and it rarely finds the use cases: in what we see in the field, the answer to “what do you need?” is “someone to hire”, because nobody can ask for a capability they have never seen run on their own work.

So run discovery the other way round. Collect the hiring requests and backlogs, which already map where the work is stuck. Run AI on one slice of a team’s real process, in front of the team, then ask again: the second answer is the use case. Rank it by whose knowledge it runs on and where its value sits, which tells you what to rent from a vendor and what to own.

This is written for the transformation lead in a European company of roughly EUR 250M to 2B in revenue, where no single person sees a whole process. Consultants running discovery for such a client stand in the same place, with less access to the hiring requests. Founders get one caveat: in a 40-person startup, asking works, because the founder answering sees every step.

Key takeaways

  • “Someone to hire” is the best signal you will get. The role a team wants to fill names the process, the volume and the exceptions.
  • Demonstrate, then ask. People cannot request a capability they have never seen on their own documents. Nothing gets scored before they have.
  • Rank by owned vs rented before value vs feasibility. Commodity work inside one system is a feature to buy. Your own knowledge across handoffs is where owned intelligence pays.
  • Sometimes asking is enough. Small companies, teams already using AI daily and commodity single-system needs do not need a discovery partner, ours included.

What is AI use case discovery?

AI use case discovery is the step between deciding to use AI and building anything: finding the processes where AI would change the work, naming an owner for each, and choosing the order. Xebia, a European consultancy, defines it as “the systematic process of identifying and evaluating business problems or opportunities that can be effectively solved using artificial intelligence”.

Most of the methods that ranked for these terms when we checked in October 2026 run the same way: interview the stakeholders, hold a workshop, turn what comes out into use cases, score them on value against feasibility, hand over a ranked roadmap. Data Reply runs it as “a compact discovery sprint over 2 to 4 weeks” of workshop and stakeholder interviews, and it ends in “a prioritized roadmap as a ready-to-use decision template”.

The better ones start from friction rather than ideas. Umbrex’s playbook decomposes processes to find “where decisions happen and work gets stuck” before its chapter titled “Run a High-Throughput Ideation Engine”, and Data Reply’s workshop captures “friction losses, effort, and bottlenecks”. Then the friction is turned into use cases on paper, by the people running the workshop, and scored. None of the methods cited here shows the team anything running on its own work before the use case is named; where a pilot appears, it comes after the shortlist. Data Reply’s own page names the starting problem: “Many companies lack a clear vision of how data and AI can improve internal processes”.

Why doesn’t asking your team what they need work?

Because people answer in the only unit they have ever been able to buy. The first entry on a list of observations we keep internally reads:

They do not know what is possible. Ask “what do you need?” and the answer is “someone to hire”. Until you show them what AI does on their own process, they do not see it.

The answer is rational. A department head with a bottleneck has always had one remedy the organisation would fund: a person, with a budget line, a job-description template and an approval route. “Supplier queries that arrive as PDFs get read, matched to the purchase order and routed with the relevant contract clause attached” has none of those, and nobody in the room has seen it happen on their own suppliers’ PDFs. So people describe the problem in the unit they can requisition.

The better methods ask a different question, “where is the work stuck?”, and that one gets honest answers. The trouble is the next question, “what would fix it?”, which still gets a person, or a tool the team has seen somewhere else. People can describe a problem they live with. They cannot specify a remedy they have never seen work on it.

Generic demos do not close the gap. A vendor’s demo runs on clean sample invoices; the accounts-payable lead wants to know whether it stops the payment when a supplier announces new bank details by email, and what it does with the credit note that references three invoices. Until it runs on those, the honest answer to “what could AI do here?” is “I don’t know”, and the polite one is “we need another person”.

What does “we need to hire someone” actually tell you?

Where the work is stuck, in more detail than any ideation workshop. Read the hiring request as a specification.

Ask the person to write the job description they would post. It will name the tasks (chasing, matching, re-keying, checking, drafting), the systems the new hire would sit between, the documents, the volume, and the exceptions that make the job hard to give to a junior: a use case brief, written by the person who knows the work, before anyone mentioned AI.

A generic example, not a client case. A customer-service lead asks for two more people “to handle complaints”. The job description says the new hires would read the complaint email, find the order in the ERP, check delivery status on the logistics portal, look up whether the customer’s framework agreement has special terms, and draft a reply for a supervisor, who must approve any credit above a set amount. Four sources, one approval, one rule that lives in a contract: a specific chain of reads followed by one judgement, and you can show AI doing the reads on last month’s complaints.

So stop collecting AI ideas, and collect these instead:

  • Open requisitions, and headcount requests refused in the last budget round.
  • Backlogs and queues that grow at month end or quarter end.
  • Overtime that lands on the same team at the same point in every cycle.
  • Work that waits when one person is on holiday.
  • Spreadsheets that exist only to carry information from one system to another.

Each is a place where the organisation has already admitted, in its own budget language, that work is stuck.

Reading the request is not the same as refusing it. Sometimes the hire is still right, and the job description tells you what that person, or the system beside them, will spend the day on. Teams that learn their headcount requests are being mined for automation targets stop writing them honestly.

How do you identify AI use cases in your company?

Show first, ask second. Pick one signal from the list above whose owner will give you real material, run AI on a slice of it in front of the team, and ask again. The framework table below sets out the stages and their exit conditions.

The nearest idea among the ranking pages we checked is Optimizely’s discovery template, which maps the workflow as it actually runs today. That is the right starting material, but its public summary ends at a written problem statement: “That problem statement becomes the foundation for your next AI agent.” Nothing has run, so nobody in the room has changed their mind about what is possible.

Agentic use cases come out of the same process. An agent takes several steps and acts, usually across systems, so the agents worth building tend to land in the matrix’s right-hand column; an agent that works inside one system is usually a vendor feature. Whether one works depends less on the model than on the context it reads, such as exception rules and the reasons behind past decisions, so the first agent you build should sit on a context engine you own.

How do you run an AI use case discovery workshop?

Run it as a demonstration session. The input is real material from one team’s process, and the output is something running on that material.

A half-day format for one team and one process:

  1. Before the session. A small engineering team takes a sample under agreed data terms and gets AI running on it: an export of the team’s material, shown in a copy of the tools it uses, with no write access to live systems.
  2. The process as it runs. The team walks through it as it happens today, workarounds included.
  3. The system on their cases. It runs live on the team’s own material, including the cases the team expects it to fail on. It will fail on some, which is useful.
  4. The question again. What would you stop doing? What waits for whom? Once people have watched it read their own documents, the answers get specific: if it can draft that, the real problem is the approval that waits three days for the regional manager. That is the use case.
  5. The close. One use case in the template, with a named owner, a baseline or a plan to get one, and a first step that is a build.

A demonstration is not a pilot. It is built to change the answer in the room, on a sample, with nothing written back to a live system; a pilot is built to prove a number on real systems, and the pilot gates apply to it. A demonstration still costs engineering days before anything is agreed, which is why the signals stage narrows to one or two processes, not a demonstration per department. Nor is it a platform bootcamp: Palantir’s AIP Bootcamp page lists “Develop initial use cases in the software” among its aims, which is why what Palantir AIP and Foundry cost treats the bootcamp as the lock-in step. A demonstration’s output and its code stay with the company, and there is no platform licence it has to keep paying for afterwards.

Ideation workshopDemonstration session
InputIdeas from the people in the room, often prompted by the host’s library of use casesReal material from one team’s process: documents, cases, exceptions
The question askedWhere could AI help us?What did it get wrong, and what would you do with it?
OutputA prioritised list or roadmap, delivered as a documentOne thing running on the process, and a second, better answer

Many results for “AI use case discovery workshop” are marketplace listings and integrator offers tied to a platform: on AWS Marketplace, a GenAI strategy workshop sold by Mactores lists “Explore Amazon Bedrock Use Cases” among its contents. WWT deserves a fair reading. Its half-day session is “not a vendor pitch, but a prioritized set of opportunities you own, grounded in your own teams’ input”, an honest offer that still starts from what the room can imagine and ends in “A prioritized shortlist of use cases, with at least one ready to advance to a pilot or proof of concept”. The pilot comes after the naming.

A workshop’s output is shaped by what its host sells: a platform’s workshop finds use cases for the platform, and a consultancy’s sprint ends in the roadmap it is paid to produce. Ours is shaped too. We build context engines, so our sessions lean toward use cases where a company’s own knowledge crosses handoffs. Ask any host, us included, what the session is built to find.

What should an AI use case discovery framework include?

Five stages, each with an exit condition, and the one most frameworks skip comes third: nothing gets scored until it has been shown running on the team’s own process.

StageWhat you collect or doWhat comes outExit condition
1. SignalsHiring requests, refused headcount, backlogs, overtime, work that waits for one personStuck work, each with a named process ownerThe owner agrees to give one slice of real material
2. SliceA few weeks of real cases from one process, exceptions included: an export of the team’s material, shown in a copy of the tools it uses, with no write access to live systemsA sample the team recognises as its own workProcessing terms signed, model provider named; in Germany, the works council, where there is one, informed
3. DemonstrationAI run on the slice, in front of the teamThe team’s reaction, and the cases it fails onThe team has seen it run on its own cases
4. Second answerAsk again what they needUse cases named by the people who do the workEach has an owner and a baseline, or a way to get one
5. RankingThe template and the owned vs rented matrixOne use case to build first, and a buy listA first step that is a build, with a date

Two things are missing on purpose. There is no ideation stage, because the second answer replaces it, and no roadmap at the end: a roadmap of use cases nobody has seen running is a list of guesses in a nicer format.

AI use case discovery template: what to capture for each use case

One row per use case, with these nine fields as columns, is the whole register. The example is generic, not a client case: it follows the complaints example above to a verdict.

FieldWhat to writeGeneric example
Use caseOne sentence, in the team’s words, written after the demonstrationDraft complaint replies with the order, delivery status and contract terms attached
Came fromThe hiring request, backlog or queue that pointed hereA request for two more customer-service staff
Process ownerA named person who runs the process today. No owner, no use caseHead of customer service
Shown running on our own process?Yes or no, with the date and the slice. A “no” stops the row hereYes, on last month’s complaints
Baseline metric known?The number today, or how and when you will get itHandling time is known; rework is not yet measured
Where the knowledge livesSystems, documents, and the people who hold the rulesERP, the logistics portal, framework contracts, two senior supervisors
Where the value sitsInside one system, or across which handoffsAcross the ERP, the logistics provider, the contracts and the supervisor’s approval
Owned or rentedRent, Rent and revisit, Own and extend later, or Own first (see the matrix)Own first
First stepA build step with a date, not a meetingMeasure rework on last quarter’s complaints and agree the target with the head of customer service, then run it in parallel on new complaints for two weeks

The baseline does not need to be solved in discovery, only known or scheduled: the number agreed before the build is the next gate, which why enterprise AI pilots fail covers. The two “where” fields feed the matrix and are the easiest to get wrong from a desk. Ask the people: the rule that decides most complaints is often in a supervisor’s head, not in the ERP.

AI use case prioritization matrix: owned vs rented

The prioritisation matrices that rank for the term use some version of the same axes. GetWidget’s framework scores value, feasibility, data readiness and risk, then plots “a 2x2 matrix of business value against technical feasibility”. SysArt’s template offers “Decision dimensions for business value, feasibility, urgency, and risk” and says it is “designed for situations where there are already multiple candidate use cases”. Umbrex’s playbook lists “9.5 Build/buy/partner hypotheses” in its table of contents as one sub-item under feasibility.

Value against feasibility answers how much and how hard. Some of these frameworks fold build vs buy into feasibility, as a question of model choice: GetWidget scores an off-the-shelf API path higher on feasibility than a model built from scratch. None of these frameworks asks whose knowledge the use case runs on. That question says what kind of work the use case is, which decides whether you should build it at all: an email-drafting feature and a credit decision can score the same, and one of them is a feature you already pay for. So place each use case on two other axes first:

  • Where the value sits. Inside one system, or across the handoffs between systems or teams.
  • Whose knowledge it runs on. Commodity, meaning the rules it needs are public or the vendor’s, or yours, meaning your exceptions, rules and history.
Value inside one systemValue across handoffs between systems or teams
Commodity knowledge (the rules are public or the vendor’s)Rent. Buy the feature already in your stack: first drafts of routine emails in the mail client, search across the document library, transcription of calls in the phone system.Rent and revisit. Buy an integration or document-capture product for standard transfers, such as invoices from an inbox into the ERP. Revisit when the handoff starts to depend on your own rules: the credit note that references three invoices is where invoice capture moves down a row.
Your knowledge (your exceptions, rules and history)Own and extend later. The knowledge is yours but the value is contained, such as quoting rules for configured products in one system. Keep the rules somewhere you own, so the next handoff can use them; a vendor’s agent in that system may be enough for now.Own first. A supplier claim that needs the contract, the goods receipt and the quality report; a delivery-date change agreed between sales, planning and the customer’s terms. This is where the context engine gets built, and where the first agent sits on it.

Two questions place a use case. If it ran perfectly, which systems would it read from and write to, and does a person carry information between them today? One system and no carrier puts it on the left; anything more, on the right. Where are the rules it needs written down? In a standard, a public template or the vendor’s manual: commodity. In your contracts, your exception log or a supervisor’s head: yours.

We think the right-hand column is where a mid-cap’s processes lose the most, and no single vendor’s product covers it; nobody owns the handoffs makes that case. The bottom row is where the knowledge is worth owning: its rules, exceptions and history are what any model reads, so keep them somewhere you own, whichever model you rent. Check the placements against your own cases rather than our labels.

Value against feasibility is still the right second question: inside each quadrant, order by value and effort as usual. Then two decisions follow: whether to layer AI on the existing workflow or redesign it (rearchitect vs layer), and who should build it (build vs buy vs embed).

How do you identify and prioritize AI use cases in a European mid-cap?

The same way as anywhere, with two differences at EUR 250M to 2B in revenue: nobody sees the whole process, and real data should not move until the processing terms are signed and, in Germany, the works council, where there is one, has been informed.

Order-to-cash crosses sales, credit, logistics and the service desk, and each answers the discovery question from its own desk. At this size the hiring request matters more, because it is often the only place the cross-team cost of a process gets written down.

Then the data. The discovery methods cited here treat data as a question for the build: availability, quality, compliance sensitivity. None of them, in what they publish, says what terms must be in place before a team’s real data leaves it for the discovery itself. Showing AI on a team’s real process moves real data before any build contract exists. If it includes personal data, and supplier contacts, customer emails and complaint histories all do, the outside team is usually a processor, and the EDPB’s guide for small businesses says that relationship “must be governed by a contract in which the processing operations and means to process personal data are documented”. The provider of the model the demonstration calls is then usually a sub-processor, and the same guide says a sub-processor “can only be appointed if the controller, or joint controller, authorises it in a written form”: name the model provider, and where it runs, in the terms. Sign them before the demonstration, or choose a first slice with little personal data in it.

In Germany, where the company has a works council, inform it early. Section 90(1) of the Works Constitution Act requires the employer to inform it in due time of plans concerning “working procedures and operations including the use of artificial intelligence”, and section 87(1) no. 6 gives it a co-determination right over “the introduction and use of technical devices designed to monitor the behaviour or performance of the employees”, which a system reading a team’s emails and case history can fall under. A demonstration on the team’s own process is also the clearest thing to show a works council: it sees what the system does to the work. Austria, Switzerland, Italy and the Nordic countries have their own rules. Take the specifics to counsel; this is not legal advice.

When is asking enough, and when is a discovery partner the wrong answer?

Asking works when the person answering has already seen AI run on their own work, or when the use case is commodity. Three cases:

  • Small companies. The founder sees the whole process and often builds the fix. Ask, and start.
  • Teams already using AI every day. They have seen it on their own documents, so their requests are specific. Take them at their word.
  • Commodity needs inside one system. The vendor already sells the answer. If discovery produces mostly Rent items, buy the features in the stack you already pay for; you do not need forward-deployed engineers for that, ours included.

The method is also the wrong tool for an inventory of the AI already in use, for a governance register: that catalogues what exists rather than finding what should. And if you already have use cases demonstrated on your own process, with owners and baselines, skip discovery and go straight to the delivery decision.

A partner earns its cost in the remaining case, the Own first quadrant: the valuable work crosses teams and systems, nobody inside sees it whole, and the knowledge it runs on is your own. Asking will never find it, because nobody in the company has seen anything like it running on their process. It is also where who builds it decides who keeps it; what it takes to own your intelligence covers that question.

FAQ

What is AI use case discovery? AI use case discovery is finding which processes AI should change, who owns each one, and in what order to build them. Most methods interview stakeholders, turn their ideas or pain points into use cases on paper and score them on value against feasibility. A better method collects hiring requests and backlogs, runs AI on one slice of a team’s real process in front of the team, and treats the answer people give afterwards as the use case.

Why doesn’t asking employees what they need surface AI use cases? Because people describe a bottleneck in the only unit they have ever been able to request: headcount. Asked “what do you need?”, they answer “someone to hire”. They can describe the problem they live with, but nobody can specify a remedy they have never seen run on their own documents and exceptions, so until they see it on their own process, they do not know what is possible.

How do you identify AI use cases in your company? Start where the organisation has already admitted work is stuck: open requisitions, refused headcount, growing backlogs and month-end overtime. Take one slice of that process, run AI on it in front of the team that owns it, and ask again what they need. The second answer is the use case; give it a named owner and a baseline before you rank it.

How do you run an AI use case discovery workshop? Run it as a demonstration, not an ideation session. Beforehand, engineers get AI running on an export of one team’s real material under agreed data terms, with no write access to live systems. In the session the team walks through the process, watches the system work on its own cases, brings the cases it expects the system to fail on, and is then asked again what it needs. It closes with one use case, a named owner and a first step that is a build.

What should an AI use case discovery template include? For each use case: the hiring request or backlog it came from, a named process owner, whether it has been shown running on your own process, whether a baseline metric exists, where the knowledge lives, where the value sits, an owned or rented verdict, and a first step. Nothing is scored before it has been demonstrated on the team’s own cases.

What is an AI use case prioritization matrix? A grid that ranks candidate use cases before you fund them. Most plot business value against feasibility. An owned vs rented matrix asks whether a use case runs on commodity knowledge or on your own rules, exceptions and history, and whether its value sits inside one system or across handoffs between systems and teams. Commodity work inside one system is a feature to buy. Your own knowledge across handoffs is where owned intelligence is worth building first.

How do you identify agentic AI use cases? The same way as any other: start from where work is stuck, show AI running on the team’s own process, then ask again. Agentic use cases take several steps and act across systems, so the ones worth building tend to sit at the handoffs. Whether an agent works depends mostly on the company context it reads from, so build that context somewhere you own before you build the agent.

Do you need a partner for AI use case discovery? Not always. In a small company the founder sees the whole process, teams already using AI daily can name their own use cases, and commodity needs inside one system are best met by the feature your vendor already sells. A partner earns its cost when the valuable work crosses teams and systems, nobody sees it whole, and the knowledge it runs on is your own.



Nucleo is an AI-native transformation company for European mid-caps. Our forward-deployed engineers start from where your work is stuck, show what AI does on your own process, then build the context engine your company runs on, model-agnostic and in your estate, and put the first agent into production on top of it. See how an engagement works, or write to us with the hiring request that keeps coming back.

Sources: Xebia, AI use case discovery; Data Reply, data and AI use case discovery; Umbrex, AI use case discovery and prioritization playbook; Optimizely, AI use case discovery template; AWS Marketplace, GenAI Strategy Immersion Workshop by Mactores; WWT, Gen AI Use Case Discovery Workshop; Palantir, AIP Bootcamp; GetWidget, AI use case prioritization framework; SysArt, AI use case prioritization matrix; EDPB, data controller and data processor; German Works Constitution Act, sections 87 and 90.

The future belongs to those who see it before it is obvious, and build it while everyone else is still out there scouting for the best AI tools.