Where AI creates value in S/4HANA processes

#The 60-second version

SAP S/4HANA already automates the normal path of most business processes. An order that passes its checks flows to delivery and billing without anyone touching it. A payment with a clean reference clears on its own.

People spend their time on everything else: the order stuck on a credit block, the invoice that doesn't match its purchase order, the customer purchase order that arrives as a PDF, the planning run that throws two thousand exception messages.

That is where AI creates value in S/4HANA. Not in the happy path, which rules and configuration already handle, but in the exceptions, documents and judgment calls around it. Five patterns cover most of it:

1. Read documents that arrive from outside and turn them into SAP data.
2. Match items that should belong together, such as payments and invoices.
3. Triage exceptions: sort them, explain them, suggest the next step.
4. Explain errors, variances and figures in plain language.
5. Predict what is likely to happen, such as a late delivery.

#Why it matters to the business

Most AI programs in SAP shops start with a list of ideas and no way to rank them. The loudest idea wins. A better starting question is: where do our people spend hours on work that follows a pattern but isn't fully rule-based?

Take order-to-cash in a mid-sized distributor. Suppose 8,000 incoming payments a month need a person to find the matching invoice, at about three minutes each. That is 400 hours a month. If AI clears most of them and proposes matches for the rest, the team gets back most of that time. Faster clearing also means cleaner receivables and fewer customer calls about payments already made.

Value comes in three forms, and a good case names all three:

• Time: hours of manual handling removed or shortened.
• Cash and revenue: faster collection, fewer write-offs, less revenue leakage from billing errors.
• Risk: fewer errors, better audit trails, earlier warning of problems.

The flip side matters just as much. AI adds little where a step is already rule-based and stable, where volumes are tiny, or where the data needed isn't in SAP or anywhere else. It also adds risk where a wrong answer moves money without anyone checking.

#How SAP does it

SAP ships AI into S/4HANA in three forms, as of September 2026. The SAP Business AI landscape topic places these in the wider picture.

• Joule, SAP's assistant. In S/4HANA Cloud Public Edition, SAP Learning lists Joule's informational, navigational and transactional capabilities as base features at no additional cost.
• Embedded AI features inside S/4HANA apps. Some are base features included with the cloud ERP, such as Easy Filter, Smart Summarization and Enterprise Search. Others are premium, such as Financial Insights, Document Processing and Cash Application. Premium features consume AI Units, SAP's prepaid AI currency.
• Agents and Joule Assistants that work across steps. Several are in beta; many Joule Assistants have planned availability dates rather than current availability.

Here is how that maps to the running examples of this course. Status is as SAP published it in its 2026 release highlights and Sapphire guide.

#A decision guide: is this a good AI use case?

Run each candidate through five questions. The more "yes" answers, the stronger the case.

A use case that fails the last question needs extra care. If checking the AI takes as long as doing the work, the value disappears. If nobody checks, errors cost money.

#Questions to ask

Ask your process owners, your SAP account team or your partner:

• For this process, where do our people spend the most hours on exceptions, and how do we know?
• What does SAP already ship for this process in our edition and release? Is it GA, beta or Early Adopter Care?
• Is it a base feature or does it consume AI Units? What would a year cost at our volumes?
• What share of items will the AI handle fully, what share will a person review, and what does a wrong answer cost?
• What is today's baseline: volume, handling time, error rate, cycle time?
• Who owns the number after go-live?

#Common misconceptions

• "AI will automate the whole process." The standard process is already automated. AI works on the exceptions and the inputs around it.
• "The biggest process is the best place to start." The best place has high volume, real time per item, a visible pattern and cheap review. Size alone doesn't decide it.
• "Hours saved equals headcount saved." Freed time usually goes to backlog, faster cycle times or better controls. Say which in the business case.
• "If SAP announced it, we have it." Features differ by edition, release and region, and many start in beta.
• "Every good idea needs a custom build." Check SAP's standard first. A base feature you can switch on may cover most of the need.

#Key terms

• Happy path: the normal flow of a process when nothing goes wrong.
• Exception: an item that leaves the happy path and needs a person, such as a blocked order.
• Unstructured data: content without fixed fields, such as a PDF purchase order or an email.
• Base AI feature: an AI feature included with the SAP product license.
• Premium AI feature: an AI feature that consumes AI Units.
• AI Units: SAP's prepaid currency for premium AI capabilities.
• Baseline: the measured state of a process before a change, so improvement can be proven.

#Check yourself

#Mental model: AI lives at the edges of the happy path

S/4HANA is a rules engine for business processes. Configuration decides how an order is priced, when a credit check blocks it, how a goods receipt posts. When every rule is satisfied, the document flows on without a person.

Human effort collects at three kinds of edges:

1. Entry edges, where data arrives from outside in a form SAP can't read directly: a customer's PDF purchase order, a supplier invoice, a payment advice in an email.
2. Exception edges, where a rule stops a document and hands it to a person: a credit block, a price variance on an invoice, an MRP exception message.
3. Judgment edges, where someone must explain or decide: why a cost center is over budget, which blocked order to release first, whether a dispute is valid.

flowchart LR
  IN["Documents from outside"] -->|Read| C["Create in SAP"]
  C --> H["Happy path: rules and configuration"]
  H --> OUT["Delivered, billed, paid, posted"]
  H -->|a rule stops it| EX["Exception worklist"]
  EX -->|Match, triage| P["Person decides"]
  P --> H
  OUT -->|Explain, predict| R["Close, reporting, planning"]

AI earns its keep at those edges. The size of the prize at each edge is roughly:

items per period × minutes per item × share of that time AI can remove

minus what it costs to review AI output and to fix the AI's mistakes. The rest of this topic makes that sentence concrete and gives you a tool to apply it.

If you worked through What an SAP FDE does, this is the "understand the business" step turned into numbers. If you placed a use case with the landscape placement tool, this topic tells you which use cases are worth placing at all.

#How it works

#Five patterns, five kinds of mechanics

Each pattern uses a different kind of AI, with a different way of failing.

Later units teach each mechanic: prediction in Unit 2, embeddings for matching in Unit 3, language models in Units 4 and 5, and document AI in Unit 12.

#Confidence thresholds decide the value

The most useful design pattern in this whole topic comes from SAP Cash Application. SAP Learning describes it this way: the model learns matching criteria from historical clearing information, proposes matches for new payments, and gives each proposal a confidence. The customer configures what happens at each confidence level. High-confidence matches can clear automatically. Middle-confidence proposals go to an accountant for review in a worklist app. Low-confidence items stay manual.

flowchart TD
  I["New item"] --> M["Model proposes an answer with a confidence"]
  M --> Q{"Confidence"}
  Q -->|high| A["Apply automatically, log it"]
  Q -->|middle| R["Person reviews the proposal"]
  Q -->|low| N["Person handles it from scratch"]
  A --> S["Sample audit: was it right?"]

The same three-way split applies to almost every S/4HANA use case, including ones that use a language model. It is what turns "the model is 90% accurate" into hours and money.

#The value equation, worked through

Go back to the payment matching example from the foundational layer: 8,000 payments a month, three minutes each by hand, so 400 hours a month today.

Suppose a pilot shows this split, with made-up but realistic numbers:

Now add the cost of mistakes. Say 0.5% of the automatic clearings are wrong (24 a month) and each takes 30 minutes to find and reverse. That is 12 hours.

Net: 400 − 110 − 12 = 278 hours a month saved, about 70% of the original effort. On top of that come the cash effects: payments clear sooner, so dunning letters don't go out to customers who already paid.

Three lessons hide in this table:

• The automatic share drives the value. Moving it from 60% to 70% saves more than making reviews faster.
• Review time must be well below manual time. If reviewing a proposal takes as long as doing the match, the middle band saves nothing.
• Error cost can erase the gain. Where one wrong answer costs hours or real money, like a wrongly released credit block, set the automatic threshold high or have no automatic band at all.

#Where AI is the wrong tool

An FDE's credibility comes as much from saying "not AI" as from building AI. Push back when:

• A rule would do. If the logic fits in a condition ("block if credit exposure exceeds limit"), configure it. Rules are cheaper, explainable and don't drift.
• The step is rare. Twenty items a month at five minutes each is under two hours. No AI project pays for that.
• Nothing to learn from. Prediction and matching need history. A new process with no history needs a person first.
• The data isn't there. If the answer depends on phone calls nobody records, no model will find it.
• The process is broken. If orders block because master data is wrong, fix the master data. AI would just triage the same errors forever.

When you evaluate an SAP feature, ask whether it is rule-based or learned. SAP Learning lists Situation Handling, for detecting and managing issues, among the 2602 release innovations next to AI features. Both kinds can be the right answer; they just fail, cost and change differently.

#Build it yourself: a value map for S/4HANA use cases

You will build a small program that turns a list of AI ideas into a ranked value map. For each idea it works out the hours at stake per year, the hours AI could save, what that is worth, and how feasible it looks. Then it sorts the ideas into four boxes: Pilot now, Fix data and controls first, Quick win only if cheap and Park.

It runs on made-up example data out of the box, so you need no account. Later you replace the examples with your own numbers in a spreadsheet file. An optional step reads real sales orders from SAP's free sandbox to show how a measured number replaces a guess.

flowchart LR
  A["Examples or your CSV file"] --> B["value_map.py"]
  S["SAP sandbox, optional"] -.->|blocked-order share| B
  B --> C["Ranked table"]
  B --> D["Quadrant chart text"]
  D --> E["mermaid.live picture"]

Before you start: complete Set up your computer for this course. It installs Python, creates your orchestrate-course folder with its .venv virtual environment, stores your SAP sandbox key in .env and sets up Git. This walkthrough doesn't repeat those steps.

#What you need

• The course setup above. Nothing else for Steps 1 to 5.
• For the optional Step 6: your free SAP Business Accelerator Hub key in .env, as SAP_API_KEY. It's free.
• About 45 minutes the first time, plus time to collect your own numbers.

#Step 1: Open your course folder and turn on the environment

1. Open VS Code, choose File > Open Folder and open your orchestrate-course folder.

2. Open the terminal inside VS Code with Terminal > New Terminal.

3. Turn on the virtual environment:

   • Windows (PowerShell):

     Copy

     .venv\Scripts\Activate.ps1

   • macOS / Linux:

     Copy

     source .venv/bin/activate

4. Check that the prompt now starts with (.venv).

5. Move into the Unit 1 folder, creating it if it doesn't exist yet. The command is the same on all systems:

   Copy

   mkdir unit01
   cd unit01

   If mkdir says the folder already exists, that's fine; just run cd unit01.

#Step 2: Save the script

1. In VS Code's file list, right-click the unit01 folder and choose New File.
2. Name it value_map.py.
3. Copy the whole script below (the Copy button appears when you hover over it), paste it into the file and save with Ctrl+S (Windows, Linux) or Cmd+S (macOS).

"""Size and rank AI use cases across SAP S/4HANA processes.

How to run (from the folder that holds this file):
  python value_map.py                  rank the built-in example use cases
  python value_map.py --csv FILE       rank your own use cases from a CSV file
  python value_map.py --template       write use_cases.csv to fill in with your own numbers
  python value_map.py --rate 45        change the loaded cost of one hour of work (default 60)
  python value_map.py --mermaid        also print a quadrant chart for mermaid.live
  python value_map.py --sap            measure the blocked-order share in the SAP sandbox
                                       (needs SAP_API_KEY) and use it for the first use case

Every number in the examples is made up. Replace them with numbers you measured.
"""
import csv
import os
import statistics
import sys

try:  # read keys from a .env file if you set one up (see "Set up your computer")
    from dotenv import load_dotenv
    load_dotenv()
except ImportError:
    pass

HOURLY_COST = 60.0        # loaded cost of one hour of work, in your currency
ORDERS_PER_MONTH = 10000  # used only with --sap: your company's sales orders per month

COLUMNS = ["process", "use_case", "items_per_month", "minutes_per_item",
           "ai_share", "data_readiness", "risk_if_wrong", "sap_standard"]

# Made-up examples, one or more per end-to-end process.
# ai_share: share of the handling time AI could realistically remove (0 to 1).
# data_readiness: 1 (data scattered or missing) to 5 (clean, in SAP, accessible).
# risk_if_wrong: 1 (a person reviews everything anyway) to 5 (money moves on its own).
# sap_standard: yes, partly, no or unknown. Check it; don't guess.
EXAMPLES = [
    ["order-to-cash", "Triage blocked sales orders", 1200, 12, 0.5, 4, 3, "unknown"],
    ["order-to-cash", "Create sales orders from customer PO files", 3000, 6, 0.6, 4, 2, "yes"],
    ["order-to-cash", "Match incoming payments to open invoices", 8000, 3, 0.7, 5, 3, "yes"],
    ["procure-to-pay", "Resolve three-way match exceptions", 900, 20, 0.4, 3, 4, "unknown"],
    ["plan-to-produce", "Review MRP exception messages", 2500, 4, 0.3, 3, 3, "partly"],
    ["record-to-report", "Explain cost center variances at month-end", 150, 45, 0.4, 3, 2, "partly"],
    ["hire-to-retire", "Answer employee policy questions", 600, 10, 0.5, 2, 2, "partly"],
]


def to_rows(raw_rows: list) -> list:
    """Turn raw values (from the examples or a CSV) into typed dictionaries."""
    rows = []
    for raw in raw_rows:
        r = dict(zip(COLUMNS, raw)) if isinstance(raw, list) else dict(raw)
        try:
            r["items_per_month"] = float(r["items_per_month"])
            r["minutes_per_item"] = float(r["minutes_per_item"])
            r["ai_share"] = float(r["ai_share"])
            r["data_readiness"] = float(r["data_readiness"])
            r["risk_if_wrong"] = float(r["risk_if_wrong"])
        except (KeyError, ValueError) as err:
            sys.exit(f"Bad row {raw}: {err}. Check the column names and that numbers are numbers.")
        r["sap_standard"] = str(r.get("sap_standard", "unknown")).strip().lower()
        rows.append(r)
    return rows


def size(r: dict, rate: float) -> dict:
    """Add hours at stake, hours AI could save, value and a feasibility score."""
    r["hours_per_year"] = r["items_per_month"] * 12 * r["minutes_per_item"] / 60
    r["hours_saved"] = r["hours_per_year"] * r["ai_share"]
    r["value"] = r["hours_saved"] * rate
    # Feasibility starts from data readiness and drops as the cost of a wrong answer rises.
    r["feasibility"] = max(1.0, min(5.0, r["data_readiness"] - 0.5 * (r["risk_if_wrong"] - 1)))
    return r


def place(r: dict, value_cut: float) -> str:
    """Put a use case in one of four boxes and say what to do next."""
    high_value = r["value"] >= value_cut
    feasible = r["feasibility"] >= 3
    if high_value and feasible:
        box = "Pilot now"
    elif high_value:
        box = "Fix data and controls first"
    elif feasible:
        box = "Quick win only if cheap"
    else:
        box = "Park"
    if r["sap_standard"] in ("yes", "partly"):
        box += " (evaluate SAP standard first)"
    elif r["sap_standard"] == "unknown":
        box += " (check SAP standard)"
    return box


def measure_blocked_share(top: int = 200) -> float:
    """Read sales orders from the SAP sandbox and return the share that is blocked."""
    import requests  # imported here so the rest runs without it

    key = os.environ.get("SAP_API_KEY")
    if not key:
        sys.exit("SAP_API_KEY is not set. Add it to .env (see Set up your computer), or drop --sap.")
    base = "https://sandbox.api.sap.com/s4hanacloud/sap/opu/odata/sap/API_SALES_ORDER_SRV"
    params = {"$top": str(top), "$select": "SalesOrder,DeliveryBlockReason,HeaderBillingBlockReason",
              "$format": "json"}
    try:
        resp = requests.get(f"{base}/A_SalesOrder", params=params, timeout=30,
                            headers={"APIKey": key, "Accept": "application/json"})
    except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
        sys.exit("Could not reach sandbox.api.sap.com. Your network or a proxy may block it. "
                 "Try another network, or run without --sap.")
    if resp.status_code in (401, 403):
        sys.exit(f"SAP refused the request (HTTP {resp.status_code}). Copy your key again.")
    resp.raise_for_status()
    orders = resp.json()["d"]["results"]
    blocked = [o for o in orders if o.get("DeliveryBlockReason") or o.get("HeaderBillingBlockReason")]
    share = len(blocked) / len(orders) if orders else 0.0
    print(f"SAP sandbox: {len(blocked)} of {len(orders)} sales orders have a delivery or billing block "
          f"({share:.1%}).")
    return share


def mermaid(rows: list, value_cut: float) -> str:
    """A quadrant chart: value (x) against feasibility (y), both scaled to 0..1.

    The median value and a feasibility of 3 are the middle lines, so the boxes match the table.
    """
    top = max(r["value"] for r in rows) or 1

    def x_of(value: float) -> float:
        if value >= value_cut:
            return 0.55 + 0.4 * (value - value_cut) / ((top - value_cut) or 1)
        return 0.05 + 0.4 * value / (value_cut or 1)

    def y_of(feasibility: float) -> float:
        if feasibility >= 3:
            return 0.55 + 0.4 * (feasibility - 3) / 2
        return 0.05 + 0.4 * (feasibility - 1) / 2

    lines = ["quadrantChart", "  title AI use cases: value vs feasibility",
             "  x-axis Low value --> High value", "  y-axis Hard to do --> Ready to do",
             "  quadrant-1 Pilot now", "  quadrant-2 Quick win only if cheap",
             "  quadrant-3 Park", "  quadrant-4 Fix data and controls first"]
    for r in rows:
        name = r["use_case"].replace(":", " ")[:40]
        x = round(x_of(r["value"]), 2)
        y = round(y_of(r["feasibility"]), 2)
        lines.append(f"  {name}: [{x}, {y}]")
    return "\n".join(lines)


def main() -> None:
    args = sys.argv[1:]
    rate = HOURLY_COST
    if "--rate" in args:
        try:
            rate = float(args[args.index("--rate") + 1])
        except (IndexError, ValueError):
            sys.exit("Put a number after --rate, for example: --rate 45")

    if "--template" in args:
        with open("use_cases.csv", "w", newline="", encoding="utf-8") as f:
            writer = csv.writer(f)
            writer.writerow(COLUMNS)
            writer.writerows(EXAMPLES)
        print("Wrote use_cases.csv. Edit it, then run: python value_map.py --csv use_cases.csv")
        return

    if "--csv" in args:
        try:
            path = args[args.index("--csv") + 1]
            with open(path, newline="", encoding="utf-8-sig") as f:
                raw, source = list(csv.DictReader(f)), path
        except IndexError:
            sys.exit("Put a file name after --csv, for example: --csv use_cases.csv")
        except FileNotFoundError:
            sys.exit(f"No file named {path} here. Run with --template first to create one.")
    else:
        raw, source = [list(row) for row in EXAMPLES], "built-in examples (made-up numbers)"

    rows = to_rows(raw)
    if not rows:
        sys.exit("No use cases found. Add at least one row under the header.")

    if "--sap" in args:
        share = measure_blocked_share()
        rows[0]["items_per_month"] = ORDERS_PER_MONTH * share
        print(f"Using {rows[0]['items_per_month']:.0f} blocked orders a month for "
              f"'{rows[0]['use_case']}' ({ORDERS_PER_MONTH} orders x {share:.1%}).\n")

    rows = [size(r, rate) for r in rows]
    value_cut = statistics.median(r["value"] for r in rows)
    rows.sort(key=lambda r: (r["value"] * r["feasibility"]), reverse=True)

    print(f"Source: {source}. Hourly cost: {rate:g}.\n")
    print(f"{'#':<3}{'Process':<18}{'Use case':<46}{'Hours/yr':>9}{'Saved':>8}"
          f"{'Value':>10}{'Feas.':>6}  Next step")
    for i, r in enumerate(rows, 1):
        print(f"{i:<3}{r['process'][:17]:<18}{r['use_case'][:45]:<46}{r['hours_per_year']:>9,.0f}"
              f"{r['hours_saved']:>8,.0f}{r['value']:>10,.0f}{r['feasibility']:>6.1f}  "
              f"{place(r, value_cut)}")
    total = sum(r["value"] for r in rows)
    print(f"\nTotal value at stake if every estimate holds: {total:,.0f} per year.")
    print("Treat this as a ranking of where to look, not a business case.")

    if "--mermaid" in args:
        print("\n" + mermaid(rows, value_cut))


if __name__ == "__main__":
    main()

#Step 3: Run it on the examples

1. In the terminal, with (.venv) showing and inside unit01, run:

   Copy

   python value_map.py

   On macOS or Linux, use python3 if python isn't found.

2. You should see this table. The numbers are the made-up examples, so yours will match exactly:

Source: built-in examples (made-up numbers). Hourly cost: 60.

#  Process           Use case                                       Hours/yr   Saved     Value Feas.  Next step
1  order-to-cash     Match incoming payments to open invoices          4,800   3,360   201,600   4.0  Pilot now (evaluate SAP standard first)
2  order-to-cash     Create sales orders from customer PO files        3,600   2,160   129,600   3.5  Pilot now (evaluate SAP standard first)
3  order-to-cash     Triage blocked sales orders                       2,880   1,440    86,400   3.0  Pilot now (check SAP standard)
4  procure-to-pay    Resolve three-way match exceptions                3,600   1,440    86,400   1.5  Fix data and controls first (check SAP standard)
5  record-to-report  Explain cost center variances at month-end        1,350     540    32,400   2.5  Park (evaluate SAP standard first)
6  plan-to-produce   Review MRP exception messages                     2,000     600    36,000   2.0  Park (evaluate SAP standard first)
7  hire-to-retire    Answer employee policy questions                  1,200     600    36,000   1.5  Park (evaluate SAP standard first)

Total value at stake if every estimate holds: 608,400 per year.
Treat this as a ranking of where to look, not a business case.

How to read it:

• Hours/yr is items per month × 12 × minutes per item ÷ 60: the time people spend today.
• Saved is the share of that time AI could remove.
• Value is saved hours × the hourly cost. It's in whatever currency your hourly cost is in.
• Feas. (feasibility) runs from 1 to 5. It starts at your data readiness score and drops half a point for every step of risk above 1.
• Rows are sorted by value × feasibility, so a slightly smaller but much easier case can rank higher. That is why row 5 is above row 6.
• Next step puts each case in a box. "High value" means at or above the median value of your list; "feasible" means 3 or more.

Notice row 4. Three-way match exceptions have as much value as blocked orders, but low data readiness and high risk push them into Fix data and controls first. That is a common real-world result: the value is real, but the first project is data and process work, not AI.

#Step 4: See the quadrant chart

1. Run:

   Copy

   python value_map.py --mermaid

2. Below the table you now get a block starting with quadrantChart:

quadrantChart
  title AI use cases: value vs feasibility
  x-axis Low value --> High value
  y-axis Hard to do --> Ready to do
  quadrant-1 Pilot now
  quadrant-2 Quick win only if cheap
  quadrant-3 Park
  quadrant-4 Fix data and controls first
  Match incoming payments to open invoices: [0.95, 0.75]
  Create sales orders from customer PO fil: [0.7, 0.65]
  Triage blocked sales orders: [0.55, 0.55]
  Resolve three-way match exceptions: [0.55, 0.15]
  Explain cost center variances at month-e: [0.2, 0.35]
  Review MRP exception messages: [0.22, 0.25]
  Answer employee policy questions: [0.22, 0.15]

3. Select everything from quadrantChart to the last line and copy it.
4. Open mermaid.live in your browser, delete the example in the Code panel on the left, and paste. The chart appears on the right.
5. To save the picture, use the Actions menu on that site to download it as PNG or SVG. (Menu names on third-party sites can change; look for a download or export option.)

The chart's middle lines match the table: the median value across, and a feasibility of 3 up. Positions within a box are approximate; the table holds the exact numbers.

#Step 5: Put in your own use cases

1. Create a template file:

   Copy

   python value_map.py --template

   You should see Wrote use_cases.csv. Edit it, then run: python value_map.py --csv use_cases.csv.

2. Open use_cases.csv in Excel, Google Sheets or VS Code. Keep the first row (the column names) exactly as it is.

3. Replace the example rows with your own ideas, one per row. What each column means:

4. Save it as CSV. In Excel, choose File > Save As and pick CSV UTF-8 (Comma delimited). Keep the name use_cases.csv.

5. Run the tool on your file:

   Copy

   python value_map.py --csv use_cases.csv

6. To use your company's hourly cost instead of 60, add --rate and a number:

   Copy

   python value_map.py --csv use_cases.csv --rate 45

#Step 6 (optional): Replace a guess with a measurement

The first row of the examples guesses the number of blocked orders. This step measures a blocked share from real API data in the SAP sandbox and uses it instead. It reads the same Sales Order API you used in the blocked orders prototype.

1. Make sure your .env file in the course folder holds SAP_API_KEY. The script reads it with load_dotenv(). Because you run the script from unit01, and load_dotenv() searches the script's folder and then the folders above it, it finds the file one level up.

2. Near the top of the script, set ORDERS_PER_MONTH to your company's monthly sales order count, or leave it at 10000 for practice. Save.

3. Run:

   Copy

   python value_map.py --sap

4. You should see two extra lines before the table, something like this (the sandbox is shared demo data, so your numbers will differ):

SAP sandbox: 6 of 200 sales orders have a delivery or billing block (3.0%).
Using 300 blocked orders a month for 'Triage blocked sales orders' (10000 orders x 3.0%).

5. If it says 0 of 200, that is a valid result: the sample of demo orders has no blocks. The blocked-orders row then has no volume and drops to the bottom.

#What each part of the script does

#If something goes wrong

#Why the tool is built this way

• It separates value from feasibility. Mixing them into one score hides the most useful result: high value that isn't ready yet.
• It always asks about the SAP standard. Every box gets "evaluate SAP standard first" or "check SAP standard" unless you entered no. Checking is cheap; building twice isn't.
• It prints a warning, not a business case. The ranking tells you where to spend a week measuring. The business case comes after the measurement.

#The SAP way

Your value map says where to look. This section is how you find out what SAP already ships there, as of September 2026, and what it costs.

#Step 1: Look it up in SAP's own catalogs

SAP Learning points to two tools in the SAP Discovery Center:

• The SAP Business AI Feature Catalog lists AI features with their use cases, value and metrics, and shows release status.
• The SAP Business AI Feature Estimator ("My AI Feature Estimates") estimates how many AI Units a feature would need, so you can budget before you switch it on.

Also read SAP's quarterly Business AI release highlights on SAP News. The Q1 and Q2 2026 posts list each new feature with its product and status (GA, beta or SAP Early Adopter Care), and often a benefit figure SAP measured or expects.

#Step 2: Know the three commercial tiers

For S/4HANA Cloud Public Edition, SAP Learning's course on SAP Business AI for S/4HANA Cloud describes:

Base features are the cheapest possible pilot: switch them on, train users, measure. Premium features need an AI Unit estimate per use case, which is where your value map's volumes come in.

#Step 3: Map features to your use cases

Here is what SAP had published for the course's running examples by September 2026. Status is as stated in the source at the time; check it again before you rely on it.

Notice what is missing: the value map's three-way match exceptions and MRP exception review have no clear match in these sources. That doesn't mean SAP has nothing; it means you have to check your release. It may also be your custom-build opportunity.

#How the standard features are built, and what to copy

Two SAP designs from these sources are worth copying into anything you build:

• Sales orders from unstructured data keep a person in charge of the gaps. In scope item 4X9, as SAP Learning describes it, a sales representative uploads a PDF or image purchase order in the Create Sales Orders - Automatic Extraction app. The system extracts the data and proposes values, for example the sold-to party. The representative reviews it, completes missing mandatory fields and then simulates or creates the order. Automated email intake needs extra setup: SAP Learning lists an SAP Intelligent RPA account and a desktop agent among the prerequisites.
• Cash Application routes by confidence. Proposals clear automatically, go to review or stay manual depending on configured confidence levels, exactly the pattern from "How it works".

Both are "Read" and "Match" patterns with human review. If you build your own, keep the same shape.

#Build vs. SAP

#Production concerns

• Baseline first. Measure volume, handling time, error rate and cycle time before go-live, from system data where possible. Without a baseline, nobody can prove the value you promised.
• Authorizations. An AI that reads or changes S/4HANA data must respect the user's SAP authorizations. A triage assistant must not show a credit analyst orders from a company code they can't see. Unit 11 covers this.
• Error cost and thresholds. Decide per use case what may happen automatically. Start with no automatic band for anything that moves money, and widen it only on evidence.
• Cost tracking. Premium features consume AI Units; custom builds consume model and platform costs. Track cost per item handled next to hours saved, or the value map drifts away from reality.
• Clean core. Custom AI belongs in side-by-side extensions using released APIs, not in modifications to SAP standard. Units 6 and 13 cover the patterns.
• Change management. Hours saved only count if people change how they work. Plan who uses the freed time, and for what.
• Status drift. Beta features change. Re-check the status of every SAP feature in your map each quarter, alongside SAP's release highlights.

#Pitfalls

• Counting the happy path. Sizing AI on total order volume instead of the exceptions inflates value tenfold. Size only the items people touch.
• Ignoring review time. "The AI proposes, a person approves" saves nothing if approval takes as long as doing it.
• Hours as headcount. Promising headcount reductions from hours saved sets up the project to fail its business case. Name where the time goes.
• Taking vendor percentages as your numbers. SAP's stated effects, like any vendor's, come from its own measurements. Your data, process and volumes decide your result.
• Skipping "not AI". Some high-value rows are data-quality or process problems. Solve those without AI and say so.
• Estimating once. A value map is a living list. Re-run it when you measure, when SAP ships something new, or when volumes change.

#Exercise: your first value map

Build a value map for five real or realistic use cases and check the SAP standard for each.

1. Run python value_map.py --template in your unit01 folder.

2. Replace the rows in use_cases.csv with five use cases from a process you know. If you have no company data, keep the course examples and change the numbers to what you think is realistic.

3. For each row, look up the SAP standard in the SAP Business AI Feature Catalog or the latest release highlights. Set sap_standard to yes, partly, no or unknown, and write the feature name, status, date and link in a file named value_map_notes.md.

4. Run python value_map.py --csv use_cases.csv --mermaid. Paste the chart text into mermaid.live and save the picture as value_map.png in unit01.

5. In value_map_notes.md, write three sentences: which use case you would pilot first, which number in its row you are least sure of, and how you would measure it.

6. Save your work in Git from the course folder:

   Copy

   git add unit01/value_map.py unit01/use_cases.csv unit01/value_map_notes.md unit01/value_map.png
   git commit -m "Add Unit 1 value map"

Done when: python value_map.py --csv use_cases.csv prints five ranked rows, every row has a checked sap_standard value with a dated link in your notes, and git log shows the commit. Keep this map: Unit 8 turns its top row's numbers into success metrics, and the opportunity assessment in Unit 14 starts from it.

#Check yourself