# The 45 minutes that show who can quietly kill your AI project

> A RACI matrix and a power/interest map show who approves the work, who will use it and who can block it before a line of code is written.

Original: https://fdetimes.net/en/guides/raci-stakeholder-map-before-coding/

On an AI project at a client, two people are easily mistaken for one. The first signs off the budget. The second decides whether what you build gets used.

Truong Phung makes the point in his FDE playbook on DEV Community: the executive sponsor signs the cheque, but the line-of-business (LoB) owner decides whether your work actually gets *used*.

Consider the cost of confusing the two. By week six the prototype works, and nobody opens it. Two small documents prevent that outcome: a RACI matrix and a stakeholder map. Together they take about 45 minutes, ideally straight after the kick-off meeting.

The guide below works through a hypothetical project. Open a laptop and follow along, swapping in the people and tasks from your own project.

## What will you build, and what do you need?

Imagine you are an FDE sent to the claims-processing department of an insurance company. Your job is to build an AI assistant that summarises claim files for staff.

On the client side there is an operations director (the sponsor), a claims manager (the business owner), a data engineer, the security team and a team lead who runs the group of claims handlers.

By the end you will have a CSV file holding the RACI matrix, a short Python script to check it, and a power/interest map with an action sentence in each quadrant. You need Python 3, an editor and a list of everyone you met or heard named at the kick-off.

## Step 1 (10 minutes): list the tasks before you think about people

Lucid recommends putting the project deliverables in the left-hand column, in order of completion, and only then filling in the roles across the top row. The order matters. Start from a list of people and you will invent work for each of them instead of seeing what the project actually needs.

```csv
task,FDE,Ops_director,Claims_manager,Client_data_eng,Security,Team_lead
Get access to sample data,,,,,,
Agree eval criteria,,,,,,
Build prototype,,,,,,
Data security review,,,,,,
Pilot with one team,,,,,,
Operations handover,,,,,,
```

**Check:** read the left column from top to bottom. If each task cannot start until the one above it is done, the order is right. If no row covers eval or handover, the list is incomplete.

## Step 2 (10 minutes): one A per row

TeamGantt describes the Accountable person as the one who delegates the work and gives final approval before it counts as done. The core rule is that each task has only one such person, so decisions are clear. An analysis in CIO puts it more bluntly: several As make decisions slow and contentious.

```csv
task,FDE,Ops_director,Claims_manager,Client_data_eng,Security,Team_lead
Get access to sample data,C,I,A,R,C,
Agree eval criteria,R,I,A,C,,C
Build prototype,R,,A,C,,I
Data security review,C,I,,C,A,
Pilot with one team,R,I,A,,,C
Operations handover,C,I,A,R,,C
```

Look at the "Agree eval criteria" row. The A is the claims manager, not the FDE, because it is their team that will live with the definition of "an acceptable summary" every day. The FDE is the R: you do the work, they nod it through.

**Key point:** Each task needs exactly one final yes; two people saying yes means nobody has.

## Step 3 (5 minutes): let a script do the checking

In a long matrix the eye misses mistakes. The script below is deliberately simple: it only counts the letters in each row, against R and C limits you set yourself.

```python
import csv, sys

MAX_R, MAX_C = 2, 3  # chosen limits, adjust per project

with open(sys.argv[1], newline="") as f:
    for row in csv.DictReader(f):
        cells = [v.strip() for k, v in row.items() if k != "task"]
        a, r, c = cells.count("A"), cells.count("R"), cells.count("C")
        if a != 1:
            print(f"[ERROR] {row['task']}: {a} people A")
        if r == 0 or r > MAX_R:
            print(f"[WARNING] {row['task']}: {r} people R")
        if c > MAX_C:
            print(f"[WARNING] {row['task']}: {c} people C")
```

```bash
python3 check_raci.py raci.csv
```

**Check:** a run with no `[ERROR]` lines passes. The R and C warnings are worth a second look too. Lucid notes that too many Responsible people slow the process down, and that the fix is to split the task or remove people. CIO warns that too many Cs in the loop drag the whole project down with them. Keep both the C and the I lists short.

## Step 4 (10 minutes): score stakeholders honestly

Now for the second sheet. Give each person two scores from 1 to 5: their power over the project and their interest in it. With 3 as the dividing line you get the four familiar quadrants: Manage Closely (high power, high interest), Keep Satisfied (high power, low interest), Keep Informed and Monitor.

```text
Person             Power     Interest  Quadrant
Ops director           5         2      Keep Satisfied
Claims manager         4         5      Manage Closely
Security               4         3      Manage Closely
Team lead              2         5      Keep Informed  (!)
Client data eng        2         3      Keep Informed
```

Rock offers a simple test: if every name lands in Manage Closely, you have not scored honestly, and the map is useless.

In the example, the operations director has the most power but follows the detail least. Recording that is not a slight. It tells you how to communicate with them.

The `(!)` next to the team lead is the most important part of this step. An AI assistant that summarises claim files goes straight to the heart of their team's work. Truong Phung warns that people who feel threatened can quietly obstruct a project until it dies, without you ever noticing. Mark such people on the map.

## Step 5 (7 minutes): turn each quadrant into an action sentence

Rock argues that specificity is what turns the map from a poster into a plan. Each quadrant therefore needs a sentence with a frequency, a channel and an owner. For Keep Satisfied, Rock's advice is short updates, no surprises, and not too much contact.

```text
Keep Satisfied | Ops director | 5-line email every Friday | FDE sends
Manage Closely | Claims manager | 30-minute meeting twice a week | FDE chairs
Keep Informed  | Team lead | sit with the claims team one session a week,
                 invite input on the eval set | FDE + Claims manager
```

The team lead's sentence is the lever for the whole plan. Inviting them to shape the eval set turns someone who might feel threatened into someone who helps define quality.

## Step 6 (3 minutes): name a champion and get sign-off

Truong Phung advises identifying an internal owner in week 1, bringing them into the work from week 2, and leaving them able to run it themselves when the project ends.

If no such person can be found, that is a sign to consider walking away. In this example the natural champion is the claims manager, who holds the A in five of the six rows.

The last step is to send both sheets to the client. Lucid stresses that the matrix should be approved before the project begins so that everyone is aligned. The power/interest map is better kept within your own team: nobody likes reading that they have been placed in "Monitor".

## What are the most common mistakes?

One common mistake is for the FDE to take the A on tasks that belong to the client's business. It looks proactive, but in practice you are shouldering a decision you have no authority to make.

Another is treating the sponsor and the business owner as the same person simply because both attended the kick-off. The last is finishing the documents and filing them away: the matrix only has value if it is reopened at every change of phase, such as the move from prototype to pilot.

## How do you put this skill on a CV and in interviews?

Take the hypothetical insurance project above. A typical "before" CV line reads: "Coordinated with multiple client stakeholders." That is true of every engineer and proves nothing.

The "after" version describes exactly what you just did: "Built a RACI matrix and stakeholder map for an AI assistant project with six client-side parties; identified the internal owner in week 1 and handed over so they could run it themselves." The reader sees at once that you know who decides, who uses the product and who needs to be brought on board.

In an interview, if asked about a project that nearly failed, talk about the person you marked `(!)` and the action sentence you wrote for them.

Code runs on your machine, but at a client a project survives only when the right people say yes to it. Spending 45 minutes finding out who they are is the cheapest investment in the whole project.

**Try this week:**

- Take your current project, list six tasks in order of completion and run the script to count the As, Rs and Cs in each row
- Score power and interest for every stakeholder you can name; if they all land in Manage Closely, score again
- Send the matrix to the project's business owner with one question: which row is wrong?

## Sources

- [What Is a RACI Chart? A Complete Guide to Roles, Responsibilities, & Examples (TeamGantt)](https://www.teamgantt.com/blog/raci-chart-definition-tips-and-example)

- [The RACI matrix: Your blueprint for project success (CIO)](https://www.cio.com/article/287088/project-management-what-is-raci-and-how-does-it-improve-clarity.html)

- [How the RACI matrix will streamline your project lifecycle (Lucid)](https://lucid.co/agile/raci/raci-matrix-tutorial)

- [Stakeholder Map: How to Build One in 4 Steps (Rock)](https://rock.so/blog/stakeholder-map)

- [The Forward-Deployed Engineer Playbook (DEV Community, Truong Phung)](https://dev.to/truongpx396/the-forward-deployed-engineer-playbook-23d9)
