RACI charts, decision rights and escalation

The first RACI chart of a payroll migration made the project lead accountable for 9 of its 10 rows, gave the go-live decision two owners and left staff communication with nobody at all. A checker run on it below finds 5 faults, and every one of them would have shown up later as a decision that waited or a job that nobody did.

You will build a chart with one owner per row, diagnose the faults first drafts share, set decision rights with thresholds so that small decisions never queue behind big ones, and adapt the chart for a team that manages its own work.

RACI names who does the work and the one person who answers for it

A RACI chartRACI chart: A table of deliverables or decisions against people or roles, marking who is responsible (does the work), accountable (owns the outcome, one per row), consulted (asked before) and informed (told after). lists the deliverables and decisions of a project as rows and the people or roles as columns, and puts one letter in each cell that matters:

• R, responsible: does the work; several people may share it.
• A, accountable: owns the outcome and answers for it; exactly one per row.
• C, consulted: asked before the work or the decision, a two-way exchange.
• I, informed: told afterwards, a one-way message.

The rule of one A per row is the point of the chart. A guide from the U.S. Office of Population Affairs puts it as success requiring only one person to be accountable, so that the buck stops there. When the owner also does the work, the cell reads A/R. Here are three rows of the payroll migration’s fixed chart:

Variants add letters rather than change the idea. RASCI adds S for people who support the work, and DACI, used for decisions, names a driver who runs the decision, one person who makes it, contributors and the informed.

Four faults show up in most first RACI charts

The payroll migration’s first chart has ten rows and six roles. The program below holds that draft and the corrected chart, and checks both against four rules: exactly one A per row, at least one R per row, no row without owners, and nobody with more than 4 of the chart’s A’s:

"""Checks two RACI charts for an invented payroll-system migration: a first draft with faults, and its fix.

R: responsible (does the work), A: accountable (owns the outcome), C: consulted (asked before, two-way),
I: informed (told after, one-way); A/R: the owner also does the work. The rules: every row has exactly one A, at least
one R, and nobody holds more than 4 of the chart's A's (an overload warning for a 10-row chart).
"""

ROLES = ["Sponsor", "Project lead", "HR lead", "IT lead", "Vendor", "Audit"]
MAX_AS = 4

DRAFT = {
    "Business requirements":  ["I", "A", "R", "C", "C", ""],
    "Data mapping":           ["", "A", "C", "R", "R", ""],
    "Data cleansing":         ["", "A", "R", "", "", ""],
    "Parallel payroll run":   ["I", "A", "R", "R", "R", "C"],
    "Controls testing":       ["", "A", "", "", "", "R"],
    "Go-live decision":       ["A", "A", "C", "C", "", "C"],
    "Staff communication":    ["", "", "", "", "", ""],
    "Vendor contract change": ["C", "A", "", "", "R", ""],
    "Cutover runbook":        ["", "A", "", "R", "R", ""],
    "Old system shutdown":    ["", "A", "", "", "", ""],
}

FIXED = {
    "Business requirements":  ["I", "C", "A/R", "C", "C", ""],
    "Data mapping":           ["", "C", "C", "A", "R", ""],
    "Data cleansing":         ["", "I", "A", "C", "R", ""],
    "Parallel payroll run":   ["I", "A", "R", "R", "R", "C"],
    "Controls testing":       ["I", "C", "C", "C", "", "A/R"],
    "Go-live decision":       ["A", "R", "C", "C", "I", "C"],
    "Staff communication":    ["I", "C", "A/R", "", "", ""],
    "Vendor contract change": ["A", "R", "", "", "C", ""],
    "Cutover runbook":        ["", "A", "C", "R", "R", ""],
    "Old system shutdown":    ["I", "C", "", "A", "R", ""],
}


def faults(chart):
    found = []
    for row, cells in chart.items():
        if not any(cells):
            found.append(f"{row}: nobody owns this row")
            continue
        accountable = [ROLES[i] for i, cell in enumerate(cells) if "A" in cell]
        if len(accountable) == 0:
            found.append(f"{row}: no A")
        elif len(accountable) > 1:
            found.append(f"{row}: {len(accountable)} A's ({', '.join(accountable)})")
        if not any("R" in cell for cell in cells):
            found.append(f"{row}: no R, so nobody does the work")
    for i, role in enumerate(ROLES):
        count = sum("A" in cells[i] for cells in chart.values())
        if count > MAX_AS:
            found.append(f"{role}: {count} A's, more than {MAX_AS}")
    return found


for title, chart in (("First draft", DRAFT), ("Fixed chart", FIXED)):
    found = faults(chart)
    print(f"{title}: {len(found)} faults")
    for line in found:
        print(f"  - {line}")
    counts = {role: sum("A" in cells[i] for cells in chart.values()) for i, role in enumerate(ROLES)}
    print("  A's per role: " + ", ".join(f"{role} {n}" for role, n in counts.items()))

First draft: 5 faults
  - Go-live decision: 2 A's (Sponsor, Project lead)
  - Go-live decision: no R, so nobody does the work
  - Staff communication: nobody owns this row
  - Old system shutdown: no R, so nobody does the work
  - Project lead: 9 A's, more than 4
  A's per role: Sponsor 1, Project lead 9, HR lead 0, IT lead 0, Vendor 0, Audit 0
Fixed chart: 0 faults
  A's per role: Sponsor 2, Project lead 2, HR lead 3, IT lead 2, Vendor 0, Audit 1

The draft fails in four different ways. The go-live decision has two A’s, so the sponsor and the lead could each wait for the other, and it has no R, so nobody prepares the decision. Staff communication has no letters at all, the row most likely to be forgotten until go-live day. The old system’s shutdown has an owner but nobody to do it. And the project lead holds 9 of the 10 A’s, so every decision queues behind one person.

The fix moves each A to the person closest to the outcome: the HR lead owns requirements, cleansing and staff communication, the IT lead owns mapping and the shutdown, audit owns controls testing as A/R, and the sponsor owns the go-live decision and the vendor contract. The lead keeps two A’s and is R where a decision needs preparing. The fixed chart passes every rule, with no role above 3 A’s.

Decision rights and thresholds stop decisions from waiting

A RACI chart says who owns a decision, but not how big a decision each owner may take alone. That is the job of decision rightsdecision rights: The written limits that say how big a decision each level may take alone, for example by extra cost and by how far a milestone moves, and where a larger decision goes instead., written as thresholds: the impact up to which each level decides and the point at which it must pass the decision up. PMI’s 2026 examination outline includes “outline governance escalation paths and thresholds” in its first business-environment task. The program below routes six decisions of the migration by the charter’s thresholds, by the larger of each decision’s cost and its slip in weeks:

"""Routes six invented decisions of the payroll migration to the level that may take them, by their impact.

The thresholds are the charter's decision rights: the project lead decides up to 50 thousand of extra cost when no
milestone moves; the sponsor decides up to 1 million or a milestone moving by up to 2 weeks; anything larger goes to
the steering committee. Each decision is routed by the larger of its two impacts.
"""

LEVELS = [
    ("Project lead", 50_000, 0),
    ("Sponsor", 1_000_000, 2),
    ("Steering committee", float("inf"), float("inf")),
]

DECISIONS = [
    ("Extra test environment for two weeks", 30_000, 0),
    ("Contractor for data cleansing", 120_000, 0),
    ("Vendor change: a new tax report", 400_000, 1),
    ("Go-live moved for audit's tests", 0, 4),
    ("Switch to a different payroll vendor", 2_500_000, 8),
    ("Rename two report columns", 0, 0),
]


def route(cost, weeks):
    for level, max_cost, max_weeks in LEVELS:
        if cost <= max_cost and weeks <= max_weeks:
            return level
    raise ValueError("no level")


print(f"{'Decision':<38}{'Extra cost':>11}{'Weeks':>6}  Decided by")
for name, cost, weeks in DECISIONS:
    print(f"{name:<38}{cost:>11,}{weeks:>6}  {route(cost, weeks)}")
tally = {}
for _, cost, weeks in DECISIONS:
    level = route(cost, weeks)
    tally[level] = tally.get(level, 0) + 1
print("Decisions per level: " + ", ".join(f"{level} {tally.get(level, 0)}" for level, _, _ in LEVELS))

Decision                               Extra cost Weeks  Decided by
Extra test environment for two weeks       30,000     0  Project lead
Contractor for data cleansing             120,000     0  Sponsor
Vendor change: a new tax report           400,000     1  Sponsor
Go-live moved for audit's tests                 0     4  Steering committee
Switch to a different payroll vendor    2,500,000     8  Steering committee
Rename two report columns                       0     0  Project lead
Decisions per level: Project lead 2, Sponsor 2, Steering committee 2

Each level takes two of the six decisions. The contractor costs 120 thousand with no slip, more than the lead’s 50 thousand, so it goes to the sponsor; moving go-live by 4 weeks costs nothing extra, but its slip exceeds the sponsor’s 2 weeks, so it goes to the steering committee. Step through how two of these decisions travel:

Every decision, whoever takes it, goes into a decision logdecision log: A record of a project's decisions: what was decided, by whom, when, the options considered and where the full record is kept.: what was decided, by whom, when, the options considered and where the record lives. A log stops settled questions from being reopened and shows a new member why the project looks the way it does.

In an agile team, RACI covers the edges, not the Sprint

The 2020 Scrum Guide describes a Scrum Team as self-managing: its members “internally decide who does what, when, and how”. A chart that assigns Sprint tasks to a manager contradicts that, so in a Scrum team RACI moves to the edges of the team, the decisions that involve people outside it. The guide also makes the Product Owner accountable for managing the Product Backlog, and one person, not a committee, which is the one-A rule in Scrum’s own words.

So a chart for agile work has fewer rows, and every row is a decision that crosses the team’s boundary: a release, a contract, a compliance check. Inside the Sprint the team needs no chart, because its members decide together.

Practise: owners, faults and thresholds

New charts and new decisions follow, from a hospital, a school and a software team. A hint is there before you answer, and a question you miss comes back once at the end:

Interview questions

Warm-up (fresher to 2–5 years): how do responsible and accountable differ in a RACI chart?

Responsible people do the work of a row, and there may be several of them. The accountable person owns the outcome and answers for it, and there is exactly one per row, so that someone always decides and nobody can wait for someone else. When the owner also does the work, the cell is marked A/R. Consulted people are asked before the work or the decision, a two-way exchange, while informed people are only told afterwards. A row with an A and no R has an owner but nobody to do the job; a row with two A’s has two people who can each wait for the other.

Two harder questions follow, about two directors who both want the A and a committee that every decision waits for. Settle your answer before you open each first step:

Key takeaways

• A RACI chart gives every deliverable or decision people who do the work, exactly one accountable owner, and the people to consult beforehand and inform afterwards.
• First drafts fail in the same ways, two A’s, no R, empty rows and one person overloaded, and a short checker finds them all before they turn into stalled decisions.
• Decision rights with thresholds say how big a decision each level may take, so small decisions are made at once and every decision is recorded in a log.
• In agile teams RACI covers only the decisions that cross the team’s boundary, because the Developers decide among themselves who does what in the Sprint.