Preparing for SAP's AI certifications

#What changed, and when

SAP has replaced its multiple-choice certification exams with practical exams. You no longer pick answers from a list. You do the work: build something in a real SAP system, or talk a customer through a scenario. The exam is open book, you may use AI tools, and nobody watches you through a webcam.

The rollout started in November 2025. SAP's FAQ says the first practical exams covered Solution Architects for SAP BTP, Generative AI Developers, SAP Build Developers and SAP Business Data Cloud. Further exams followed from January 2026. SAP's own pages describe the timing differently, from "in phases" to "during 2026", and run both formats in parallel through 2026, so check each certification's page before you book.

This page describes the situation as of 30 October 2026, with the Joule Studio and Solution Architect exams re-checked on 7 November 2026. Certifications are renamed and retired often. One example just happened: the Solution Architect exam for SAP BTP (P_BTPA) retired on 19 October 2026 and is replaced by an SAP Business AI Platform version (C_BAIPA).

The skills behind these exams are taught in the course's spine units. The SAP Business AI landscape explains the products. SAP Generative AI Hub and the orchestration service covers what the developer exam tests.

#Why it matters to the business

A certificate used to show that someone had studied. A practical exam is closer to showing that someone can deliver. For a manager staffing an AI project, that is more useful, but only if you know what each exam actually checks.

Three business consequences follow:

• Hiring and staffing signals changed. A recent "SAP Generative AI Developer" pass means the person completed hands-on tasks in SAP's generative AI tools within three hours. An older pass under the multiple-choice format meant they recalled facts. Both are valid certificates, so ask when and how it was earned.
• AI use is now expected, not banned. The exams allow AI assistants and documentation. They test whether a person can get a correct result with those tools under time pressure. That matches how your team works on a real project, such as building an assistant that explains blocked sales orders.
• Budget is a subscription, not a one-off fee. Attempts and yearly renewals are tied to SAP Learning Hub. A certification with no subscription behind it lapses unless the person retakes the exam each year.

#How SAP does it

SAP runs certification through SAP Learning (learning.sap.com). There are two practical formats:

Practical facts for planning, from SAP's FAQ pages:

• Existing certificates: they stay valid and need no immediate renewal. Renewal is yearly, usually through a short assessment.
• Attempts: an SAP Learning Hub subscription includes four exam attempts. An exam-only option includes two attempts and 10 hours of practice system access.
• Renewal: certifications need renewing every year. With a Learning Hub subscription, renewal is a short online assessment. Without one, the person retakes the exam.
• Free learning: the learning journeys on learning.sap.com are free, according to the SAP Learning site FAQ. Students with a verified university email can get free exam attempts through the student edition.
• Retirements: when SAP retires a certification, valid holders keep it for 12 more months, then must pass the successor or a renewal assessment.

#Which certification fits which role

As of 30 October 2026, these are the AI-related certifications we found on learning.sap.com. Codes on the pages carry a version suffix (for example C_LCNC_2601), so the exact version changes over time.

Joule also appears inside the positioning and ABAP exams.

The free Joule Studio attempt. As of 7 November 2026, SAP's Free Joule Studio Certification FAQ describes a campaign that runs from October to 31 December 2026. Anyone with an SAP Universal ID can sign up once and gets:

• one attempt at C_JSD, with no SAP Learning Hub subscription needed;
• 24 hours of access to the Joule Studio practice system;
• the AI roleplay tool used by the scenario-based exam.

The practice-system exercises are mandatory before the exam starts. A failed attempt is used up, and an unused attempt expires when the campaign ends. The Universal ID needs two different email addresses. The FAQ ties the campaign start to Joule Studio's general availability and contradicts itself on whether attempts carry into January 2027, so plan to sit the exam before 31 December. Earlier versions of SAP's pages differed on the number of free activities; the FAQ now says one attempt.

A simple decision guide:

• Someone who sells or scopes AI work: start with a positioning exam (C_BCBTP or C_BCSBS).
• Someone who builds on SAP's generative AI hub: C_AIG.
• An ABAP developer moving to clean core and AI-assisted coding: C_ABAPD.
• A builder of Joule agents: C_JSD, ideally on the free attempt before 31 December 2026.
• An architect: C_BAIPA, because P_BTPA has retired.

#Questions to ask

• Was this certificate earned under the practical format or the older multiple-choice format, and in which year?
• Which exam version (the suffix after the code) matches the product release we run?
• Do we have SAP Learning Hub subscriptions for the people who must stay certified, or will their certificates lapse after a year?
• Which certifications retire in the next 12 months, and what is the successor?
• Does the person also have a portfolio of real work we can review? A certificate shows one timed performance; a portfolio shows sustained work.
• For a partner: how many of the people staffed on our project hold a current practical-format AI certification?

#Common misconceptions

• "Open book means easy." The time box is the hard part. Three hours goes quickly if you have to look up every step.
• "Using AI in the exam is cheating." SAP explicitly allows AI-supported tools. What the exam checks is whether the result is correct.
• "Old certificates are now worthless." SAP does not require existing holders to recertify. They renew through the usual assessment.
• "Certified means production-ready." The exam tests defined tasks in a prepared system. It does not test discovery, data quality or security reviews in your landscape.

#Key terms

All course terms, A to Z, in the glossary

• Practical exam: SAP's performance-based format, in which you complete tasks instead of answering multiple-choice questions.
• System-based assessment: a timed practical exam in SAP systems, graded from the work you produce.
• Scenario-based assessment: a timed roleplay with an AI avatar, or a recorded video, graded on how well you advise or pitch.
• Open book: you may use documentation, SAP Community and AI tools during the exam.
• Stay-certified assessment: the short yearly test that keeps a certificate valid; included with SAP Learning Hub.
• SAP Learning Hub: SAP's paid learning subscription that includes exam attempts, practice systems and renewals.
• Retirement: the date after which an exam can no longer be booked; valid holders get 12 more months.

#Check yourself

#Mental model: the exam grades your artifacts, not your memory

A multiple-choice exam asks "do you know?". A system-based practical exam asks "can you produce a correct result in time?". SAP's FAQ says results come from the completed tasks and the system outputs, checked automatically or with evaluation scripts.

Think of it as a test suite run against your work. If your configuration is wrong, it fails, however much you know. If it is right, it passes, whether you remembered the step or asked an AI assistant and checked the answer.

That changes how you prepare:

1. Practice producing, not reading. Do the tasks in a system with a clock running.
2. Practice checking. AI tools are allowed, so speed is not the bottleneck. Spotting a wrong suggestion is.
3. Practice your look-up path. Open book only helps if you know where the answer lives, such as the right SAP Learning lesson or help.sap.com page.

The same habits make you a better forward deployed engineer: build quickly, verify against the source, and finish on time.

#How it works

SAP runs two practical formats. Here is the flow of a system-based exam, the type used for developer certifications such as C_AIG and C_ABAPD.

flowchart LR
  B[Book on SAP Learning<br/>uses one attempt] --> S[Start the timed exam]
  S --> T[Tasks in SAP systems]
  T --> R[Open book:<br/>docs, Community, AI]
  R --> T
  T --> E[Evaluation scripts<br/>check outputs]
  E --> P{Score at or above<br/>pass mark?}
  P -->|yes| C[Certified]
  P -->|no| A[Use another attempt]

#System-based assessments

You get a time box, usually three hours on the developer pages we opened, and one activity made of tasks. You complete them in SAP systems. For the beta ABAP Cloud exam, SAP says you use your own Eclipse with ABAP Development Tools (ADT), at the highest available release. System-based exams are in English for now.

Scoring is automatic. Each certification page lists a pass score: 76% for C_AIG, 67% for the C_ABAPD beta and 83% for C_LCNC. Those are per-exam values, not one rule for all.

#Scenario-based assessments

You hold a roleplay with an AI avatar, for example pitching a solution or advising on architecture. An AI model may help assess accuracy, completeness and efficiency. If you prefer not to use the AI tool, you can upload a video instead; SAP experts score it within 10 business days. The scenario pages we opened list 2 hours and a 60% pass score, with roleplay available in about 30 languages and video in English.

#Logistics

Each certification page lists what you need before you book:

• An SAP Universal ID with a secondary email address.
• An SAP Learning Hub subscription that includes certification attempts. Each booking uses one attempt.
• A computer that passes SAP's Technical Readiness Checklist, linked from each certification page.

SAP's Learning Hub FAQ says a subscription includes four attempts. An exam-only option includes two attempts and 10 hours of practice system access. An earlier US listing on SAP's training shop showed one attempt at USD 236 and described webcam-proctored exams. That page redirected when we re-checked on 30 October 2026, so we could not confirm any price. Confirm the current offer for your country.

#Renewal and retirement

Certificates need renewing every year. With Learning Hub, renewal is a short non-proctored assessment, taken within a 90-day renewal window. Without it, you retake the exam. For selected certifications, SAP offers a practical AI-roleplay renewal; otherwise the existing short assessment applies.

When SAP retires an exam, valid holders keep their certificate for 12 more months from the retirement date. To stay certified after that, they pass the successor or the mandatory renewal assessment. SAP emails reminders two weeks before expiry and the day before.

#Build it yourself: a timed, auto-graded practice lab

You will build a small practice lab that works the way a system-based exam does. It gives you five tasks, starts a clock, and grades your answer files with a script, then compares your score with a pass mark. The tasks use orchestration concepts that SAP's learning journey for C_AIG covers: prompt templates, modules, data masking and content filtering.

This lab is not the SAP exam and does not copy its content. It copies the format, so you can rehearse the habit that matters: produce a file, check it against official documentation, and finish within the time box.

flowchart LR
  S["Run with --start"] --> T[TASKS.md<br/>clock starts]
  T --> Y[You write answer files<br/>using the docs]
  Y --> G[Grade]
  G --> R[PASS / FAIL per task<br/>score vs pass mark<br/>time used]
  R -->|fix| Y

Before you start: complete Set up your computer for this course. It creates your orchestrate-course folder with its .venv. This lab uses only Python's built-in modules, so there is nothing new to install. It helps to have read SAP Generative AI Hub and the orchestration service first.

#What you need

• Your course folder from Set up your computer for this course.
• About 45 minutes for a full timed run, or 5 minutes to see the sample answers graded.
• Cost: free. No account is needed.
• A browser to read SAP's documentation while you work.

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

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

2. Open a terminal: Terminal > New Terminal.

3. If the prompt doesn't start with (.venv), turn it on:

   • Windows (PowerShell):

     Copy

     .venv\Scripts\Activate.ps1

   • macOS / Linux:

     Copy

     source .venv/bin/activate

4. Create a folder for this topic:

   • Windows (PowerShell):

     Copy

     New-Item -ItemType Directory -Force radar

   • macOS / Linux:

     Copy

     mkdir -p radar

Run every command in this topic from the course folder, not from inside radar.

#Step 2: Save the script

1. In VS Code's file list, right-click radar, choose New File and name it cert_lab.py.
2. Paste the code below and save.

"""cert_lab.py: a timed, auto-graded practice lab in the style of SAP's practical exams.

This is NOT the SAP exam and does not reproduce its content. It copies the format:
a time box, tasks that produce files, and a script that checks the files.

Run from your course folder:
  python radar/cert_lab.py --start      create radar/answers/TASKS.md and start the clock
  python radar/cert_lab.py              grade your answers
  python radar/cert_lab.py --sample     write worked answers, then grade them
  python radar/cert_lab.py --minutes 60 --pass-mark 76   change the time box or pass mark
"""
import argparse
import json
import re
import time
from pathlib import Path

HERE = Path(__file__).resolve().parent
ANSWERS = HERE / "answers"
STATE = HERE / "lab_state.json"

# Orchestration modules as SAP Learning's "Introduction to Orchestration" lesson names them.
MODULES = ["grounding", "templating", "data_masking", "input_filtering",
           "model_configuration", "output_filtering"]
FILTER_CATEGORIES = {"hate", "violence", "sexual", "self_harm"}
TRUSTED_DOCS = ("help.sap.com", "learning.sap.com", "developers.sap.com",
                "api.sap.com", "github.com/SAP", "sap.github.io")

TASKS = [
    {"file": "prompt_template.json", "points": 25, "brief":
     "Write a prompt template as a JSON list of messages, each with 'role' and 'content'. "
     "Include one system message. The user message must use the placeholders {{?order}} "
     "and {{?reason}}, and must not hard-code an order number."},
    {"file": "pipeline.json", "points": 25, "brief":
     "Customer emails contain names and may contain abusive text. Write a JSON list of the "
     "orchestration modules to enable, in the order the request passes through them. Include "
     "both mandatory modules, data masking, and filtering of the input and of the output."},
    {"file": "masking.json", "points": 15, "brief":
     "The reply must greet the customer by name. Write {\"method\": ...} choosing "
     "\"anonymization\" or \"pseudonymization\"."},
    {"file": "filter.json", "points": 15, "brief":
     "Write the Azure Content Safety categories as keys (hate, violence, sexual, self_harm) "
     "and give each the severity threshold SAP uses when you set none."},
    {"file": "verification_log.md", "points": 20, "brief":
     "Open book: for each answer above, note the official page you used to check it. "
     "At least three lines with a URL from an SAP documentation or learning site."},
]

SAMPLE = {
    "prompt_template.json": json.dumps([
        {"role": "system", "content": "You explain blocked sales orders to order clerks in under 60 words."},
        {"role": "user", "content": "Sales order {{?order}} is blocked. Block reason: {{?reason}}. Explain why and the next step."},
    ], indent=2),
    "pipeline.json": json.dumps(["templating", "data_masking", "input_filtering",
                                 "model_configuration", "output_filtering"], indent=2),
    "masking.json": json.dumps({"method": "pseudonymization"}, indent=2),
    "filter.json": json.dumps({"hate": 2, "violence": 2, "sexual": 2, "self_harm": 2}, indent=2),
    "verification_log.md": (
        "- prompt_template, pipeline, masking, filter: https://learning.sap.com/courses/prd-genai-orchestration/prd-orch-intro\n"
        "- exam format: https://learning.sap.com/helpcenter/certification-support/certification-practical-exam\n"
        "- skills the exam covers: https://learning.sap.com/certifications/sap-certified-associate-sap-generative-ai-developer\n"),
}


def load_json(path):
    try:
        return json.loads(path.read_text(encoding="utf-8")), None
    except FileNotFoundError:
        return None, "file not found"
    except json.JSONDecodeError as e:
        return None, f"not valid JSON (line {e.lineno}): {e.msg}"


def check_prompt_template(path):
    data, err = load_json(path)
    if err:
        return False, err
    if not isinstance(data, list) or not all(isinstance(m, dict) for m in data):
        return False, "expected a JSON list of message objects"
    roles = [m.get("role") for m in data]
    if any(r not in ("system", "user", "assistant") for r in roles):
        return False, f"unknown role in {roles}"
    if roles.count("system") != 1:
        return False, "need exactly one system message"
    user_text = " ".join(m.get("content", "") for m in data if m.get("role") == "user")
    for name in ("order", "reason"):
        if not re.search(r"\{\{\s*\?" + name + r"\s*\}\}", user_text):
            return False, "user message is missing the placeholder {{?" + name + "}}"
    if re.search(r"\b\d{6,10}\b", user_text):
        return False, "user message hard-codes a number that looks like an order number"
    return True, "template is valid"


def check_pipeline(path):
    data, err = load_json(path)
    if err:
        return False, err
    if not isinstance(data, list):
        return False, "expected a JSON list of module names"
    unknown = [m for m in data if m not in MODULES]
    if unknown:
        return False, f"unknown module names {unknown}; use names from: {', '.join(MODULES)}"
    missing = sorted({"templating", "model_configuration", "data_masking",
                      "input_filtering", "output_filtering"} - set(data))
    if missing:
        return False, f"missing modules: {missing}"
    model = data.index("model_configuration")
    before = [m for m in ("grounding", "templating", "data_masking", "input_filtering") if m in data]
    if any(data.index(m) > model for m in before):
        return False, "every input-side module must run before model_configuration"
    if data.index("output_filtering") < model:
        return False, "output_filtering checks the model's answer, so it runs after model_configuration"
    return True, "modules and order are correct"


def check_masking(path):
    data, err = load_json(path)
    if err:
        return False, err
    method = str((data or {}).get("method", "")).lower()
    if method == "pseudonymization":
        return True, "reversible masking lets the reply use the real name"
    if method == "anonymization":
        return False, "anonymization cannot be reversed, so the reply cannot greet by name"
    return False, "method must be 'anonymization' or 'pseudonymization'"


def check_filter(path):
    data, err = load_json(path)
    if err:
        return False, err
    if not isinstance(data, dict) or set(data) != FILTER_CATEGORIES:
        return False, f"keys must be exactly: {', '.join(sorted(FILTER_CATEGORIES))}"
    if any(v not in (0, 2, 4, 6) for v in data.values()):
        return False, "thresholds must be on the documented scale 0, 2, 4, 6"
    if any(v != 2 for v in data.values()):
        return False, "valid scale, but not the default SAP applies when you set none"
    return True, "categories and default threshold are correct"


def check_log(path):
    if not path.exists():
        return False, "file not found"
    lines = [l for l in path.read_text(encoding="utf-8").splitlines()
             if "https://" in l and any(d in l for d in TRUSTED_DOCS)]
    if len(lines) < 3:
        return False, f"found {len(lines)} line(s) citing official SAP pages; need 3"
    return True, f"{len(lines)} official sources cited"


CHECKS = {"prompt_template.json": check_prompt_template, "pipeline.json": check_pipeline,
          "masking.json": check_masking, "filter.json": check_filter,
          "verification_log.md": check_log}


def start():
    ANSWERS.mkdir(exist_ok=True)
    lines = ["# Practice lab tasks", ""]
    for i, t in enumerate(TASKS, 1):
        lines += [f"## Task {i}: answers/{t['file']} ({t['points']} points)", "", t["brief"], ""]
    (ANSWERS / "TASKS.md").write_text("\n".join(lines), encoding="utf-8")
    STATE.write_text(json.dumps({"started": time.time()}), encoding="utf-8")
    print("Created radar/answers/TASKS.md. The clock is running.")
    print("Grade any time with: python radar/cert_lab.py")


def grade(minutes, pass_mark):
    total = earned = 0
    for i, t in enumerate(TASKS, 1):
        ok, why = CHECKS[t["file"]](ANSWERS / t["file"])
        total += t["points"]
        earned += t["points"] if ok else 0
        print(f"Task {i} {t['file']:<22} {'PASS' if ok else 'FAIL'}  {why}")
    score = round(100 * earned / total)
    print(f"\nScore: {score}% (pass mark {pass_mark}%) -> {'PASSED' if score >= pass_mark else 'NOT YET'}")
    if STATE.exists():
        used = (time.time() - json.loads(STATE.read_text())["started"]) / 60
        note = "within" if used <= minutes else "OVER"
        print(f"Time used: {used:.0f} of {minutes} minutes ({note} the time box)")
    else:
        print("No clock running. Start one with: python radar/cert_lab.py --start")


def main():
    p = argparse.ArgumentParser(description="Timed, auto-graded practice lab")
    p.add_argument("--start", action="store_true", help="create task files and start the clock")
    p.add_argument("--sample", action="store_true", help="write worked answers, then grade them")
    p.add_argument("--minutes", type=int, default=45, help="time box in minutes (default 45)")
    p.add_argument("--pass-mark", type=int, default=76, help="pass mark in percent (default 76)")
    a = p.parse_args()
    if a.start:
        start()
        return
    if a.sample:
        ANSWERS.mkdir(exist_ok=True)
        for name, text in SAMPLE.items():
            (ANSWERS / name).write_text(text, encoding="utf-8")
        print("Wrote worked answers to radar/answers.\n")
    grade(a.minutes, a.pass_mark)


if __name__ == "__main__":
    main()

#Step 3: See the grader work on sample answers

Run the script with --sample. It writes worked answers into radar/answers and grades them, so you can see what a full pass looks like.

python radar/cert_lab.py --sample

On Windows, use the same command in PowerShell. You should see:

Wrote worked answers to radar/answers.

Task 1 prompt_template.json   PASS  template is valid
Task 2 pipeline.json          PASS  modules and order are correct
Task 3 masking.json           PASS  reversible masking lets the reply use the real name
Task 4 filter.json            PASS  categories and default threshold are correct
Task 5 verification_log.md    PASS  3 official sources cited

Score: 100% (pass mark 76%) -> PASSED
No clock running. Start one with: python radar/cert_lab.py --start

Open the files in radar/answers and read them. Each one is a small, checkable artifact, like the output of an exam task.

#Step 4: Start a timed attempt

1. Delete the sample answers so you start clean:

   • Windows (PowerShell):

     Copy

     Remove-Item -Recurse -Force radar\answers

   • macOS / Linux:

     Copy

     rm -rf radar/answers

2. Start the clock:

   Copy

   python radar/cert_lab.py --start

   You should see:

   Copy

   Created radar/answers/TASKS.md. The clock is running.
   Grade any time with: python radar/cert_lab.py

3. Open radar/answers/TASKS.md. It lists five tasks with their points.

#Step 5: Do the tasks, open book

1. For each task, create the named file in radar/answers (right-click answers, New File).
2. Look up anything you are unsure about. SAP Learning's Introduction to Orchestration lesson answers Tasks 1 to 4.
3. You may ask an AI assistant. If you do, check its answer against the SAP page before you save it.
4. In verification_log.md, write one line per answer with the URL of the official page you used.

#Step 6: Grade, fix, grade again

python radar/cert_lab.py

A partly right attempt looks like this:

Task 1 prompt_template.json   PASS  template is valid
Task 2 pipeline.json          FAIL  every input-side module must run before model_configuration
Task 3 masking.json           FAIL  anonymization cannot be reversed, so the reply cannot greet by name
Task 4 filter.json            PASS  categories and default threshold are correct
Task 5 verification_log.md    PASS  3 official sources cited

Score: 60% (pass mark 76%) -> NOT YET
Time used: 31 of 45 minutes (within the time box)

Read each FAIL message, fix the file, and grade again. Every task shows FAIL file not found until you create its file; that is the expected "empty" result straight after --start.

To rehearse the real time pressure, shorten the box: python radar/cert_lab.py --minutes 30. To practise against a different exam's pass mark, use --pass-mark 67, for example.

#Step 7: Save your work in Git

git add radar/cert_lab.py
git commit -m "Add certification practice lab"

Keep radar/answers out of Git if you plan to share the lab with others, so they do their own attempt.

#What each part of the script does

#If something goes wrong

There is no API key in this lab, so key problems can't occur here.

#The SAP way: the certifications in detail

As of 30 October 2026 (C_JSD and C_BAIPA re-read on 7 November 2026), this is what the SAP Learning pages say about the exams most relevant to AI builders.

#SAP Generative AI Developer (C_AIG)

• Format: system-based, one activity, 3 hours, 76% pass score, English.
• What it validates: solving business problems with SAP's generative AI hub, including prompt engineering, prompt development, template management and workflow orchestration in SAP AI Launchpad.
• Preparation: the learning journey Solving Business Problems using SAP's Generative AI Hub, which includes a practice system. It covers LLMs in SAP, managing models, prompt templates and the prompt registry, and grounding.
• Course mapping: Units 5 and 7 cover the same ground: prompt and context engineering, the orchestration service and grounding on SAP data.

#Backend Developer - ABAP Cloud (C_ABAPD), beta practical

• Format: system-based beta, 3 hours, 67%, English, in your own Eclipse with ADT.
• What it validates: core ABAP and building applications with the ABAP RESTful Application Programming Model (RAP), plus using Joule for Developers to generate, explain and optimize code.
• Course mapping: ABAP Cloud and RAP for AI builders and coding agents for SAP developers.

#Positioning exams (C_BCBTP and C_BCSBS)

• Format: scenario-based roleplay, 2 hours, 60%.
• C_BCBTP is described as entry level and covers the SAP Business AI Platform. Its learning journey, Positioning SAP Business AI Platform, lists Discovering the Autonomous Enterprise as a prerequisite.
• C_BCSBS covers the Autonomous Enterprise strategy, including the difference between Joule agents and Joule assistants.
• Course mapping: the SAP Business AI landscape and Joule and Joule Studio.

#Joule Studio Developer (C_JSD)

• Format (as of 7 November 2026): one scenario-based assessment, 2 hours, 60%. In an AI avatar roleplay you present the agents you built and answer questions about them. The roleplay runs in English, Spanish, Italian, French, Japanese and 25 more languages; the video alternative is English only.
• Preparation: the learning journey Developing with Joule Studio, the hands-on practice environment, and SAP's Technical Readiness Checklist. Build real agents before the exam, because the roleplay asks about your own work.
• Free attempt: one attempt, 24 hours of practice system and the roleplay tool, through 31 December 2026, per the campaign FAQ. The practice-system exercises must be finished before you can start the exam.
• Course mapping: Joule and Joule Studio and Joule agents and agent orchestration.

#Solution Architect: P_BTPA to C_BAIPA

P_BTPA was a scenario-based, advanced exam. Its page, as we read it on 10 October, said it retires on 19 October 2026 and that valid holders move to SAP Business AI Platform Solution Architect (C_BAIPA) on 20 October 2026; that page returned an error on 30 October.

The C_BAIPA page is public. As read on 7 November 2026 it lists one scenario-based assessment, 2 hours and a 60% pass score, for seasoned professionals who connect business strategy with technical delivery. It names integration strategies, technical architecture, application design and solution governance as the areas covered, without weights. There are no formal prerequisites, but each attempt comes from a Learning Hub subscription that includes certification attempts, and the recommended preparation is the learning journey Becoming an SAP Business AI Platform Solution Architect. The C_BAIPA page itself does not mention P_BTPA.

#Licensing notes

• Learning journeys on learning.sap.com are free. Certification attempts, premium practice systems and renewals need SAP Learning Hub or an exam-only purchase. The exception, until 31 December 2026, is the free C_JSD attempt described above.
• SAP PartnerEdge members can use a partner edition of Learning Hub.
• The Learning Hub price is per user per year and is listed on the SAP Store or available from SAP; we did not find it on the pages opened.

#Certification vs. portfolio

A certificate and a portfolio prove different things. Most FDE candidates benefit from both.

Rule of thumb: get the certificate that matches the role you're applying for, and bring one portfolio project that shows the work around it. The course's portfolio projects are listed under Portfolio projects in the curriculum.

#Exam-day concerns

These play the role of production concerns: what can go wrong on the day.

• Technical readiness. Run SAP's Technical Readiness Checklist days before, on the same computer and network. For C_ABAPD, update Eclipse and ADT first, because SAP asks for the highest available release.
• AI suggestions are not answers. A system-based exam scores outputs. An AI assistant that invents a parameter name costs you the task. Check every suggestion against the documentation before you apply it, the same discipline as testing AI applications.
• Bookmarks beat search. Before the exam, bookmark the learning journey lessons and help.sap.com pages you'll need. Searching from scratch eats the time box.
• Data hygiene. Even in a practice system, don't paste real customer data into an external AI tool. Use the same rules as in data security and PII.
• Version drift. The exam targets one product release. If your project system is on a different release, screens and options may differ. Check the version suffix on the exam page.
• Attempts are finite. Each booking uses one attempt. Practise with a clock until you finish with time to spare before you book.

#Pitfalls

• Studying for recall. Flashcards and question dumps prepare you for a multiple-choice format that SAP is phasing out.
• Trusting third-party "exam guides". Many sites still describe the old multiple-choice format, or invent question banks. Use the certification page on learning.sap.com as the source of truth.
• Ignoring retirement dates. Booking an exam days before it retires wastes preparation time; check the page for a retirement notice first.
• Letting it lapse. Without Learning Hub, the yearly renewal is a full retake. Put the expiry date in your calendar.
• Practising without a clock. You may know every step and still fail on time.
• Treating the pass mark as universal. It varies by exam (60%, 67%, 76%, 83% on the pages we opened).

#Exercise: a personal certification plan with a practice score

You will pick the certification that fits your role, map it to course topics, and record a timed practice score. The plan goes in your portfolio repository, where the portfolio projects build on it.

Before you start: finish Build it yourself above, at least Steps 3 to 6.

1. Open learning.sap.com, choose the certification that fits your role from the table in "Which certification fits which role", and open its page.
2. Write down the exam code, format, time, pass score, language and any retirement notice.
3. In your course folder, create radar/cert_plan.md.
4. Add a section Exam facts with what you wrote down in step 2, and the date you checked.
5. Add a section Skills map: list each skill the page says it validates, and next to each one the course topic that teaches it.
6. Run a full timed attempt of the practice lab with that exam's pass mark, for example python radar/cert_lab.py --start, then python radar/cert_lab.py --minutes 45 --pass-mark 76.
7. Add a section Practice score with your score and the time used.
8. Add a section Next steps: which topics you will redo and the date you plan to book.
9. Commit the plan: git add radar/cert_plan.md and git commit -m "Add certification plan".

Done when radar/cert_plan.md lists the exam's facts with the date checked, maps every validated skill to a course topic, and records one timed practice score at or above the exam's pass mark.

#Check yourself