Orchestrate

Report an issue

Something wrong, out of date or unclear? Tell us. Corrections are prioritized over new topics. You don't need to sign in.

0 / 2000

Don't include personal or confidential company details. Reports are reviewed with AI assistance.

Get the free Joule Studio Developer certification before 31 December 2026

SAP gives one free C_JSD exam attempt until 31 December 2026. What you get, how the 24-hour practice window works, and how to plan and rehearse.

Updated Nov 10, 2026Foundational 8 minDeep 30 min
Foundational layer · 8 min read

What changed, and when

SAP is giving away one attempt at its Joule Studio Developer certification (exam code C_JSD). The offer started in October 2026 and ends on 31 December 2026. From 1 January 2027 the exam moves into SAP's normal paid certification portfolio.

This page describes the offer as of 10 November 2026, from SAP Learning's Free Joule Studio Certification FAQ, the C_JSD certification page and the campaign's terms and conditions. SAP changes these pages, so check them again before you sign up.

The deadline is tighter than it looks. You must finish SAP's practice exercises before the exam starts, the practice system is open for only 24 hours, and a recorded-video answer can take up to 20 business days to score. Someone who starts in late December has little room for anything to go wrong.

The broader picture of SAP's practical exams is in Preparing for SAP's AI certifications. The skills the exam checks are taught in Joule and Joule Studio and Joule agents and agent orchestration.

Why it matters to the business

For a team lead, this is a cheap way to find out who on the team can actually build an agent in Joule Studio, not just talk about one.

  • Cost. A normal attempt comes from an SAP Learning Hub subscription or a paid exam-only purchase. During the campaign, the attempt needs neither. The FAQ says the free attempt is the only way to take this exam until the campaign ends.
  • A real skill signal. The exam is a roleplay: an AI avatar asks the candidate to show the agents they built and answer questions about them. A pass means the person built working agents and could explain them, which is close to what a customer asks of a consultant.
  • Timing with your projects. If your company is evaluating Joule Studio for something like explaining blocked sales orders, a certified builder can tell you sooner what the tool does well and where it stops.

The risk is wasted effort, not money. A failed attempt is used up, there is no free retake, and an unused attempt expires on 31 December. Time spent on the 24-hour window without preparation is the main loss.

How SAP does it

As of 10 November 2026, the FAQ, the C_JSD page and the terms describe this offer:

Item What SAP's pages say
Who can sign up Anyone with a valid SAP Universal ID who signs up on the campaign page and accepts the terms; the FAQ names no limit by company type, role or country. The terms exclude competitors of SAP and apply export control laws
What you get One exam attempt, 24 hours of access to a Joule Studio practice system, and access to the AI roleplay tool
What you don't get SAP Learning Hub content, live sessions or extra attempts
Before the exam All practice-system exercises, which are mandatory; the learning journey Developing with Joule Studio is strongly recommended
The exam One scenario-based assessment, 2 hours, 60% to pass, with an AI avatar; or record a video instead (English only)
Your own systems Not needed: no BTP subaccount or Joule Studio subscription
Deadline Attempts are valid through 31 December 2026; unused attempts expire
Afterwards A pass is a normal SAP certification; standard renewal rules apply once the exam is in the commercial portfolio

You sign up once. The practice system's 24 hours start at your first login, according to the terms. There is no booking step: after signing up, you start the exam from the certification page.

Who should take it, and when

Take it if you will build or extend agents in Joule Studio in the next year, or you advise customers who will. A developer, an integration consultant or an aspiring forward deployed engineer all fit.

Skip it, or wait, if you only need to explain Joule Studio to buyers. SAP's positioning exams fit that job better, as described in Preparing for SAP's AI certifications.

A plan that leaves room for things to go wrong:

When What to do Why
Now to late November Work through Developing with Joule Studio and the course's Joule topics; no clock is running Learning time is free and unlimited; the practice clock is not
Before you log in to the practice system Decide which agents you will build and how you will explain each one The exam asks about your own agents
One clear day, by mid-December Log in, finish every exercise, then start the exam the same day Access ends 24 hours after the first login
No later than 30 December Treat this as your real deadline The FAQ gives no time zone for "31 December"

If you plan to answer by recorded video rather than with the AI avatar, start earlier. Video results may take up to 20 business days, and the FAQ doesn't say what happens to a review that finishes after the campaign.

Questions to ask

Ask your team, your manager or SAP Learning support:

  • Who on the team will build Joule Studio agents next year, and have they finished the learning journey yet?
  • Which day in December has each person blocked for the 24-hour window, with no customer calls?
  • Does our company network allow the roleplay tool? The scenario FAQ says to allow *.yoodli.ai and storage.googleapis.com if it is blocked.
  • Will we pay for SAP Learning Hub next year? The renewal assessment needs it.
  • Have we told candidates not to enter real customer or personal data in the practice system? The terms forbid it.
  • For SAP Learning support: does a video submitted in December but reviewed in January still count, and which time zone ends the campaign?

Common misconceptions

  • "I can claim it now and take it in January." The FAQ says attempts are valid through 31 December 2026 and unused attempts expire. One answer on the same page mentions using attempts from 1 January 2027, which conflicts with this; don't rely on it.
  • "The 24 hours start when I sign up." The terms say the practice system's 24 hours start at your first login. Signing up early is safe; logging in early is not.
  • "I can skip the exercises and go straight to the exam." The FAQ makes the practice exercises mandatory before you start the exam.
  • "If I fail, I'll use the free retake." There is one attempt. A failed attempt is used up.
  • "Free means free forever." The pass itself is a normal SAP certification, but keeping it current later follows SAP's standard renewal rules, which need an active Learning Hub subscription.
  • "This is the same as the free Joule Studio runtime." The runtime offer is for select customers running agents; the certification offer is for individuals.

Key terms

All course terms, A to Z, in the glossary

  • C_JSD: the exam code for SAP Certified - Joule Studio Developer.
  • SAP Universal ID: the personal SAP account used to sign up and track results; the FAQ says it should have two different email addresses assigned.
  • Practice system: a Joule Studio environment SAP provides for 24 hours from your first login, where you do the mandatory exercises.
  • Scenario-based assessment: an exam held as a timed roleplay with an AI avatar, scored on how well your answers meet each exam objective.
  • AI roleplay tool: the tool that runs the avatar conversation; SAP's FAQ lists the network addresses it uses.
  • Recorded-video route: the non-AI alternative, where you upload a video that SAP experts score, in English only.
  • Stay Certified assessment: SAP's yearly renewal check, taken in a 90-day window before the due date, with a Learning Hub subscription.

Check yourself

Pick one answer for each question. The explanation appears after you choose.

1A developer signs up for the free C_JSD attempt in November and plans to sit the exam in the first week of January 2027. What should their lead say?

Answer: C. The FAQ says attempts are valid through 31 December 2026 and unused ones expire. The FAQ gives no time zone, so a day's margin is sensible. One FAQ answer mentions January 2027, but it conflicts with the expiry rule.

2When does the 24-hour practice window start?

Answer: C. SAP's terms say the 24 hours start at the first login. That is why candidates should finish the learning journey and plan their agents before logging in, not after.

3What does a pass on C_JSD most directly tell a manager about a person?

Answer: A. The exam is a roleplay where the avatar asks you to show the agents you built and answer questions about them. The free attempt uses SAP's practice system, so it says nothing about your own landscape.

4A candidate fails the exam on 10 December. What happens next under the campaign?

Answer: D. The campaign gives one attempt and a sign-up only once, and a failed attempt is consumed. The FAQ says the failure doesn't count against later commercial attempt limits, but those are paid.

5Your company network blocks the roleplay tool. What is the right request to IT?

Answer: A. SAP's scenario FAQ names those two addresses and suggests trying home Wi-Fi or mobile data to confirm a block. No own BTP subaccount or subscription is needed, and the camera is optional.

6A candidate prefers to record a video rather than talk to the AI avatar. What should they plan for?

Answer: C. Both FAQs read for this page say a human review of the video can take up to 20 business days, and the video route is English only. The FAQ doesn't say how a review that ends after 31 December is handled.

7Which statement about cost after a pass is correct?

Answer: C. The FAQ says passes stay valid like any SAP certification and standard rules apply once the exam is commercial. The Stay Certified FAQ says the renewal assessment needs an active Learning Hub subscription.
Deep layer · 30 min read

Mental model: three clocks, one exam

Three clocks run on this offer, and most failures come from confusing them.

  1. The campaign clock ends on 31 December 2026. Unused attempts expire.
  2. The practice clock runs for 24 hours from your first login to the practice system. The exercises are mandatory, and the exam asks about agents you built.
  3. The exam clock runs for 2 hours once you start the scenario-based assessment. Pausing freezes the avatar, not the countdown.

Everything that has no clock should happen before the first login: learning, designing your agents on paper, writing down how you'll explain them, and rehearsing out loud. Then the 24-hour window is spent building and answering, not reading.

The exam itself is closer to a design review than a test. The C_JSD page says the avatar asks you to show your agents and answer questions about them. The scenario FAQ says the AI rates each exam objective from 1 (Insufficient) to 5 (Excellent) by the meaning of your answers, not keywords. You pass by building something sensible and explaining your choices clearly, the same skill a solution design doc needs.

How it works

flowchart LR
  A[Learning journey<br/>no clock] --> B[Sign up once<br/>Universal ID, terms]
  B --> C[First login<br/>24 h clock starts]
  C --> D[All practice<br/>exercises]
  D --> E[Start exam<br/>2 h clock]
  E --> F{Route}
  F -->|AI roleplay| G[Save and view analysis]
  F -->|Video, English| H[Human review<br/>up to 20 business days]
  G --> I[Badge in profile]
  H --> I

Step by step, from the pages read on 10 November 2026:

  1. Sign up. On the campaign page, log in with your SAP Universal ID and accept the terms. The attempt is assigned automatically. The FAQ says the confirmation appears on the page; no email is sent. SAP's TechEd learning page links the campaign with a button labelled Claim your exam voucher.
  2. Learn. The C_JSD page marks the learning journey Developing with Joule Studio as required preparation; the FAQ calls it strongly recommended but not enforced. The journey covers Joule Studio's place in the SAP Business AI Platform, agents, agent extensions and n8n workflows. Its course Introducing Joule Studio is listed at 1 hour 16 minutes.
  3. Practice. Your first login to the practice system starts 24 hours of access. The FAQ says exam tasks reflect what you practise there, and all exercises must be finished before you start the exam.
  4. Start the exam. There is no scheduling. Open the C_JSD page and start the exam. The scenario FAQ says you allow microphone access, choose whether to allow the camera, and accept cookies so the buttons work. The FAQ lists two required activities during the campaign: the practical tasks in the practice system and the scenario-based assessment.
  5. Answer. In the AI roleplay, the avatar asks you to show your agents and answer questions about them. Alternatively, after starting, you can choose to record a video instead.
  6. Result. In the AI route, Save and view analysis shows your score, and if you passed you submit. The badge appears in the Certification section of your SAP Learning profile.

Build it yourself: plan the window and rehearse the roleplay

You will build a small tool with three commands. plan turns the time you choose for your first login into a timeline and checks it against the campaign end. check reads a dossier: a short file describing each agent you'll build, and flags what you couldn't yet explain. deck turns the dossier into rehearsal questions, and can time your spoken answers.

The questions are this course's own. They are not SAP's exam questions, which we have not seen and don't reproduce. They practise the habit the exam rewards: explaining your agent's purpose, tools and limits clearly.

flowchart LR
  P[plan --start] --> T[24-hour timeline<br/>OK or RISK]
  D[my_agents.json<br/>dossier] --> C[check]
  C --> G[READY or GAPS<br/>per agent]
  D --> K[deck --timed]
  K --> L[rehearsal log<br/>seconds per answer]

Before you start: complete Set up your computer for this course. It creates the orchestrate-course folder with its .venv. Unit 9's setup, Set up for Unit 9, is helpful but not needed: this tool uses only Python's built-in modules.

What you need

  • Your course folder from the setup topic.
  • About 30 minutes to run everything, plus your own rehearsal time.
  • Cost: free. No account is needed for this tool. The real exam needs a free SAP Universal ID.

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):

      .venv\Scripts\Activate.ps1
    • macOS / Linux:

      source .venv/bin/activate
  4. Make sure the radar folder exists (an earlier radar topic may have created it):

    • Windows (PowerShell):

      New-Item -ItemType Directory -Force radar
    • macOS / Linux:

      mkdir -p radar

Run every command 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 jsd_rehearsal.py.
  2. Paste the code below and save.
"""Plan and rehearse the free Joule Studio Developer (C_JSD) attempt.

Three commands, built-in modules only:
  plan   turns your chosen start time into a 24-hour timeline and checks it
         against the campaign end (31 December 2026)
  check  checks a dossier of the agents you built: is each one explainable?
  deck   prints rehearsal questions from the dossier (add --timed to time answers)

The rehearsal questions are this course's own, not SAP's exam content.
"""
import argparse
import csv
import json
import random
import re
import sys
from datetime import date, datetime, timedelta
from pathlib import Path

CAMPAIGN_LAST_DAY = date(2026, 12, 31)      # SAP Learning FAQ, read 2026-11-10
SAFE_FINISH = datetime(2026, 12, 30, 23, 59)  # one day early: the FAQ names no time zone
PRACTICE_HOURS = 24                          # terms: the clock starts at first login
EXAM_HOURS = 2                               # C_JSD page: 2 hours
BUFFER_HOURS = 2                             # course rule: spare time before the window closes
VIDEO_REVIEW_BUSINESS_DAYS = 20              # FAQ: video results may take up to 20 business days

REQUIRED = ["name", "business_problem", "instructions", "tools",
            "test_requests", "limitation", "design_choice"]

SAMPLE_DOSSIER = {
    "candidate": "sample learner",
    "agents": [
        {
            "name": "Order Exception Helper",
            "business_problem": "Customer service spends about 20 minutes per blocked "
                                "sales order finding out why it is blocked.",
            "instructions": "Explain why a sales order is blocked and what the next step is. "
                            "Never release a block yourself; offer to start a credit review.",
            "tools": [
                {"name": "get_sales_order", "what": "reads header, items and blocks"},
                {"name": "get_credit_exposure", "what": "reads limit and open items"},
                {"name": "request_credit_review", "what": "starts a review task for a person"},
            ],
            "test_requests": [
                "Why is order 1000002 blocked?",
                "Can order 1000003 ship this week?",
            ],
            "limitation": "Cannot see emails from the customer, so it cannot tell if a "
                          "payment promise was made.",
            "design_choice": "A review task instead of a direct release, because releasing "
                             "a credit block is a decision for the credit analyst.",
        },
        {
            "name": "PO Date Watch",
            "business_problem": "Planners learn too late that a supplier confirmed a later date.",
            "instructions": "Compare confirmed dates with production needs. Send questions "
                            "to planner@calder-pumpworks.example.",
            "tools": [
                {"name": "get_purchase_order", "what": "reads items and confirmations"},
            ],
            "test_requests": ["Which open POs are later than the production order needs?"],
            "limitation": "",
            "design_choice": "",
        },
    ],
}

EMAIL = re.compile(r"[\w.+-]+@[\w-]+\.[\w.-]+")
SECRET = re.compile(r"(sk-[A-Za-z0-9]{8,}|api[_-]?key\s*[:=]|password\s*[:=])", re.I)


def parse_when(text):
    try:
        return datetime.strptime(text, "%Y-%m-%d %H:%M")
    except ValueError:
        sys.exit(f'Could not read "{text}". Use the form "2026-12-08 18:00".')


def add_business_days(day, n):
    """Count Monday to Friday only; public holidays are not known here."""
    while n > 0:
        day += timedelta(days=1)
        if day.weekday() < 5:
            n -= 1
    return day


def cmd_plan(args):
    today = date.fromisoformat(args.today) if args.today else date.today()
    start = parse_when(args.start)
    window_end = start + timedelta(hours=PRACTICE_HOURS)
    latest_exam = window_end - timedelta(hours=EXAM_HOURS + BUFFER_HOURS)
    print(f"Today: {today}   Campaign last day: {CAMPAIGN_LAST_DAY} "
          f"({(CAMPAIGN_LAST_DAY - today).days} days left)")
    print()
    print("Before the clock (no time limit):")
    print("  - finish the learning journey and list the agents you will build")
    print("  - write your dossier and rehearse with: deck --sample or deck <file>")
    print()
    print("Your 24-hour window (your local time):")
    print(f"  {start:%a %Y-%m-%d %H:%M}  first login to the practice system: clock starts")
    print(f"  {start + timedelta(hours=8):%a %Y-%m-%d %H:%M}  aim to finish all practice exercises")
    print(f"  {latest_exam:%a %Y-%m-%d %H:%M}  latest exam start "
          f"({EXAM_HOURS} h exam + {BUFFER_HOURS} h spare)")
    print(f"  {window_end:%a %Y-%m-%d %H:%M}  practice system access ends")
    print()
    problems = []
    if start.date() < today:
        problems.append("The start time is in the past.")
    if window_end > SAFE_FINISH:
        problems.append(f"The window ends after {SAFE_FINISH:%Y-%m-%d %H:%M}. The FAQ names "
                        "no time zone for 31 December, so finish a day early.")
    video_result = add_business_days(latest_exam.date(), VIDEO_REVIEW_BUSINESS_DAYS)
    print(f"If you choose the recorded-video route, results may take until about "
          f"{video_result} (20 business days, holidays not counted).")
    if video_result > CAMPAIGN_LAST_DAY:
        print("NOTE  That is after the campaign. The FAQ doesn't say how a late review is "
              "handled; prefer the AI roleplay, or sit the exam earlier.")
    print()
    if problems:
        print("RISK")
        for p in problems:
            print(f"  - {p}")
        return 1
    print("OK  The plan fits inside the campaign.")
    return 0


def load_dossier(args):
    if args.sample:
        return SAMPLE_DOSSIER
    if not args.file:
        sys.exit("Give a dossier file, or use --sample.")
    try:
        return json.loads(Path(args.file).read_text(encoding="utf-8"))
    except FileNotFoundError:
        sys.exit(f"File not found: {args.file}")
    except json.JSONDecodeError as err:
        sys.exit(f"{args.file} is not valid JSON (line {err.lineno}): {err.msg}")


def check_agent(agent):
    gaps = []
    for field in REQUIRED:
        value = agent.get(field)
        if value in (None, "", []):
            gaps.append(f"missing {field}")
    tools = agent.get("tools") or []
    for tool in tools:
        if not tool.get("what"):
            gaps.append(f"tool {tool.get('name', '?')} has no 'what'")
    if len(agent.get("test_requests") or []) < 2:
        gaps.append("fewer than 2 test_requests")
    text = json.dumps(agent)
    if EMAIL.search(text):
        gaps.append("contains an email address (the terms say: no personal data)")
    if SECRET.search(text):
        gaps.append("looks like it contains a key or password")
    return gaps


def cmd_check(args):
    dossier = load_dossier(args)
    agents = dossier.get("agents") or []
    if not agents:
        print("No agents in the dossier. Add at least one under \"agents\".")
        return 1
    ready = 0
    for agent in agents:
        gaps = check_agent(agent)
        name = agent.get("name", "(no name)")
        if gaps:
            print(f"GAPS   {name}")
            for g in gaps:
                print(f"         - {g}")
        else:
            ready += 1
            print(f"READY  {name}")
    print(f"\n{ready} of {len(agents)} agents ready to explain.")
    return 0 if ready == len(agents) else 1


def build_deck(dossier):
    cards = []
    for a in dossier.get("agents") or []:
        n = a.get("name", "your agent")
        cards.append(f"What business problem does {n} solve, and how would you show it helped?")
        for req in (a.get("test_requests") or [])[:2]:
            cards.append(f"Walk through what {n} does with this request: {req}")
        for tool in a.get("tools") or []:
            cards.append(f"Why does {n} have the tool {tool.get('name')}? "
                         "What goes wrong without it?")
        if a.get("limitation"):
            cards.append(f"What can't {n} do yet, and what would you add next?")
        if a.get("design_choice"):
            cards.append(f"Which design choice in {n} would you defend, and why?")
    cards.append("How do your agents stay within the signed-in user's permissions?")
    cards.append("Where would a person approve before your agent changes data?")
    return cards


def cmd_deck(args):
    dossier = load_dossier(args)
    cards = build_deck(dossier)
    rng = random.Random(args.seed)
    rng.shuffle(cards)
    cards = cards[:args.n]
    print(f"Rehearsal deck: {len(cards)} questions (seed {args.seed}). Course questions, not SAP's.\n")
    if not args.timed:
        for i, q in enumerate(cards, 1):
            print(f"{i}. {q}")
        return 0
    log = Path(args.log)
    new = not log.exists()
    with log.open("a", newline="", encoding="utf-8") as fh:
        writer = csv.writer(fh)
        if new:
            writer.writerow(["when", "question", "seconds"])
        for i, q in enumerate(cards, 1):
            print(f"{i}. {q}")
            input("   Press Enter, then answer out loud. Press Enter again when done.")
            t0 = datetime.now()
            input()
            secs = round((datetime.now() - t0).total_seconds())
            flag = "  (over 2 minutes: shorten it)" if secs > 120 else ""
            print(f"   {secs} s{flag}\n")
            writer.writerow([datetime.now().isoformat(timespec="seconds"), q, secs])
    print(f"Times saved to {log}")
    return 0


def main():
    p = argparse.ArgumentParser(description=__doc__,
                                formatter_class=argparse.RawDescriptionHelpFormatter)
    sub = p.add_subparsers(dest="cmd", required=True)
    pl = sub.add_parser("plan", help="timeline for the 24-hour window")
    pl.add_argument("--start", required=True, help='first login, e.g. "2026-12-08 18:00"')
    pl.add_argument("--today", help="pretend today is YYYY-MM-DD (for testing)")
    for name in ("check", "deck"):
        sp = sub.add_parser(name)
        sp.add_argument("file", nargs="?", help="your dossier JSON file")
        sp.add_argument("--sample", action="store_true", help="use the built-in Calder dossier")
        if name == "deck":
            sp.add_argument("--n", type=int, default=8, help="number of questions")
            sp.add_argument("--seed", type=int, default=42)
            sp.add_argument("--timed", action="store_true")
            sp.add_argument("--log", default="radar/jsd_rehearsal_log.csv")
    args = p.parse_args()
    handler = {"plan": cmd_plan, "check": cmd_check, "deck": cmd_deck}[args.cmd]
    sys.exit(handler(args))


if __name__ == "__main__":
    main()

Step 3: Plan your 24-hour window

Pick the time you'll first log in to the practice system. Use a day with nothing else in it. Run plan with that time, written as "YYYY-MM-DD HH:MM" in your local time. The --today option pins today's date so your output matches the one below; leave it out for real planning.

  • Windows (PowerShell):

    python radar/jsd_rehearsal.py plan --start "2026-11-28 09:00" --today 2026-11-10
  • macOS / Linux:

    python3 radar/jsd_rehearsal.py plan --start "2026-11-28 09:00" --today 2026-11-10

Success looks like this:

Today: 2026-11-10   Campaign last day: 2026-12-31 (51 days left)

Before the clock (no time limit):
  - finish the learning journey and list the agents you will build
  - write your dossier and rehearse with: deck --sample or deck <file>

Your 24-hour window (your local time):
  Sat 2026-11-28 09:00  first login to the practice system: clock starts
  Sat 2026-11-28 17:00  aim to finish all practice exercises
  Sun 2026-11-29 05:00  latest exam start (2 h exam + 2 h spare)
  Sun 2026-11-29 09:00  practice system access ends

If you choose the recorded-video route, results may take until about 2026-12-25 (20 business days, holidays not counted).

OK  The plan fits inside the campaign.

Now try a late plan to see the warning:

python radar/jsd_rehearsal.py plan --start "2026-12-30 18:00" --today 2026-11-10
...
If you choose the recorded-video route, results may take until about 2027-01-28 (20 business days, holidays not counted).
NOTE  That is after the campaign. The FAQ doesn't say how a late review is handled; prefer the AI roleplay, or sit the exam earlier.

RISK
  - The window ends after 2026-12-30 23:59. The FAQ names no time zone for 31 December, so finish a day early.

The "latest exam start" line assumes you want the practice system open while you show your agents in the exam. The 8-hour target for the exercises and the 2 spare hours are this course's planning rules, not SAP's.

Step 4: Check the sample dossier

The tool has a built-in dossier for two agents at Calder Pumpworks, the course's fictional pump maker. Run:

python radar/jsd_rehearsal.py check --sample
READY  Order Exception Helper
GAPS   PO Date Watch
         - missing limitation
         - missing design_choice
         - fewer than 2 test_requests
         - contains an email address (the terms say: no personal data)

1 of 2 agents ready to explain.

The second agent is incomplete on purpose. Its gaps are the questions you would struggle with in the exam: what can't it do, and why is it built this way? The email check matters too: SAP's terms say you must not enter personal data in the practice system, so keep names and addresses out of agent instructions and test data.

Step 5: Write your own dossier

  1. In VS Code, create radar/my_agents.json.
  2. Paste this skeleton and fill it in for each agent you'll build in the practice system:
{
  "candidate": "your first name only",
  "agents": [
    {
      "name": "Order Exception Helper",
      "business_problem": "Who has the problem, and what it costs today",
      "instructions": "What the agent must and must not do, in two or three sentences",
      "tools": [
        {"name": "get_sales_order", "what": "what this tool reads or does"}
      ],
      "test_requests": ["First request you will demo", "Second request you will demo"],
      "limitation": "One thing it cannot do yet",
      "design_choice": "One decision you made, and why"
    }
  ]
}
  1. Check it:
python radar/jsd_rehearsal.py check radar/my_agents.json

An agent is READY when every field is filled, every tool says what it does, it has at least two test requests, and nothing looks like an email address, key or password.

Step 6: Rehearse out loud

Print a deck from the sample first, to see the shape:

python radar/jsd_rehearsal.py deck --sample
Rehearsal deck: 8 questions (seed 42). Course questions, not SAP's.

1. Which design choice in Order Exception Helper would you defend, and why?
2. What can't Order Exception Helper do yet, and what would you add next?
3. Walk through what Order Exception Helper does with this request: Can order 1000003 ship this week?
4. Walk through what PO Date Watch does with this request: Which open POs are later than the production order needs?
5. Where would a person approve before your agent changes data?
6. Why does Order Exception Helper have the tool request_credit_review? What goes wrong without it?
7. How do your agents stay within the signed-in user's permissions?
8. What business problem does PO Date Watch solve, and how would you show it helped?

With the same seed you get the same order. Use --seed 7 (any number) for a new order.

Then rehearse with your own dossier and the timer. Press Enter, answer out loud, press Enter when done:

python radar/jsd_rehearsal.py deck radar/my_agents.json --timed
1. What business problem does Order Exception Helper solve, and how would you show it helped?
   Press Enter, then answer out loud. Press Enter again when done.
   74 s
...
Times saved to radar/jsd_rehearsal_log.csv

Your times will differ. An answer over 2 minutes is flagged; that limit is a course habit, not an SAP rule. Open the CSV in a spreadsheet to see whether your answers get shorter across rehearsals.

Step 7: Save your work in Git

git add radar/jsd_rehearsal.py radar/my_agents.json
git commit -m "Add C_JSD plan and rehearsal dossier"

Leave jsd_rehearsal_log.csv out of Git if you'd rather not publish your timings.

What each part of the script does

Part What it does
Constants at the top The campaign's last day, the 24-hour window, the 2-hour exam and the 20-business-day video review, from SAP's pages read on 10 November 2026; the one-day margin and 2 spare hours are course rules
add_business_days Counts Monday to Friday to estimate the video result date; it doesn't know public holidays
cmd_plan Builds the timeline from your first login, flags a start in the past or a window ending after 30 December
SAMPLE_DOSSIER Two fictional Calder agents, one complete and one with gaps
check_agent Looks for empty fields, tools without a description, fewer than two test requests, email addresses and anything that looks like a key
build_deck Turns each agent's fields into questions, plus two questions on permissions and approval that apply to every agent
cmd_deck Shuffles with a fixed seed, prints the questions, and with --timed records seconds per answer to a CSV

If something goes wrong

What you see What it means What to do
python: command not found or 'python' is not recognized Python isn't on your path, or .venv is off Turn on .venv (Step 1); on macOS/Linux try python3
can't open file ... radar/jsd_rehearsal.py Wrong folder, or a different file name Run from orchestrate-course; check the name
ModuleNotFoundError Something other than a built-in module is imported The script uses built-ins only; copy it again exactly
Could not read "Dec 5" The start time isn't in the expected form Use "2026-12-05 09:00", with quotes
is not valid JSON (line 7) A missing comma, quote or bracket in your dossier Fix the line named; VS Code underlines JSON errors in red
File not found: radar/my_agents.json The dossier isn't where the command looks Check the file name and that you are in the course folder
The roleplay won't load on exam day A company network or proxy blocks it Allow *.yoodli.ai and storage.googleapis.com, or use another network (SAP's scenario FAQ)

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

The SAP way: the offer in detail

As of 10 November 2026, from the pages listed in this topic's sources.

The exam (C_JSD)

  • Format: one scenario-based assessment, 2 hours, 60% pass score.
  • Languages: the roleplay runs in English, Spanish, Italian, French, Japanese and more; the C_JSD page links a longer list, and the scenario FAQ says 22 languages. The video route is English only.
  • Steps on the page: check your computer with SAP's Technical Readiness Checklist; build agents in the hands-on environment after the learning journey; start the exam, where the avatar asks you to show your agents and answer questions.
  • Skills listed: AI-assisted development, Knowledge Graph integration and interaction, and artificial intelligence, for the developer role on SAP Business Technology Platform.
  • Advice on the page: complete all practice exercises and read the exam guidance in full; SAP says skipping instructions is a common reason learners don't pass.

The campaign

  • Window: October 2026 to 31 December 2026. The FAQ says the start depended on Joule Studio's general availability, which SAP describes as phased (see Joule and Joule Studio).
  • Eligibility: anyone with a valid SAP Universal ID who signs up and accepts the terms. The terms add that competitors of SAP may not use the service and that export control laws apply.
  • Included: one attempt, 24 hours of the practice system, and the AI roleplay tool. Commercial attempts are not accepted for this exam during the campaign.
  • Not needed: your own BTP subaccount or Joule Studio subscription.
  • Failed attempts: consumed, and they don't count against commercial attempt limits later.
  • After 31 December: the exam becomes a standard commercial certification through Learning Hub or purchased attempts.

The practice system terms

The terms describe the practice system as a preliminary version of a cloud service, with no support and no productive use. Credentials belong to one person and can't be shared. You must not enter personal data, and SAP deletes your data when the term ends. So don't spend effort building anything you need to keep: keep your design notes and dossier in your own repository.

Renewal

The FAQ says standard Stay Certified rules apply once the exam is commercial. SAP's Stay Certified FAQ says the renewal assessment opens 90 days before the due date, can be an AI roleplay or a quiz, and needs an active Learning Hub subscription. A missed due date means taking the full exam again.

Two offers that are easy to mix up

SAP's TechEd learning page lists the free C_JSD voucher next to separate TechEd attendee benefits (25% off an SAP Certification exam and Learning Hub access, 18 August to 31 December 2026), which need a promo code from TechEd registration. And SAP's 27 October 2026 release makes the Joule Studio runtime free through December 2026 for select customers. None of the three depends on the others.

Build vs. SAP: how to prepare

Preparation Use it for Limits
SAP's learning journey Developing with Joule Studio The product itself: agents, agent extensions, n8n workflows No clock, but it doesn't rehearse explaining your own work
SAP's practice system Building the agents you will present; mandatory exercises 24 hours from first login, preliminary, no support, data deleted
The course's Joule-shaped assistant lab Understanding skills, agents and routing before the clock starts Local Python, not Joule Studio's screens
This topic's jsd_rehearsal.py Planning the window and rehearsing explanations out loud Course questions, not SAP's; no scoring of answer quality
SAP's roleplay practice Getting used to the avatar and its language menu Part of the campaign's tool access; check the FAQ for how to open it

Architecture view

The exam happens in SAP's practice system, not in your landscape, so this view is about the agents you'll explain. Examiners and customers ask the same questions of both.

Where it sits. A Joule Studio agent lives on SAP BTP. Users reach it through Joule in the SAP application they're using. It calls released APIs in S/4HANA through destinations, as the Joule and Joule Studio topic's diagram shows. In the practice system, SAP has set up these pieces for you; in a customer project, each one is a design decision.

Non-functional requirements worth naming in your answers:

Requirement Typical target What breaks if missed
Identity Every call runs as the signed-in user The agent can see or change what the user may not
Human approval A person confirms any change to SAP data A wrong answer becomes a wrong posting
Answer quality A small set of test requests with expected answers You can't show the agent works, in the exam or the project
Cost Calls per request estimated before go-live Agent actions appear on the bill unplanned after the free terms end
Data No personal data in prompts or test data unless approved A privacy finding, and in the practice system a breach of the terms

Integration and identity. Requests come in through Joule, which knows the user from the shared identity tenant. Tools reach SAP through destinations that carry that user, so SAP's own authorization checks decide. Writes should start a task for a person, as the Order Exception Helper's request_credit_review does. The full reasoning is in Agent permissions and SAP authorizations.

The decision to record. In the short form from Writing a solution design doc:

  • Context: a candidate has one attempt and 24 hours of practice system, and the exam asks about their own agents.
  • Options: A, build one agent per exercise and explain each briefly; B, build the exercises, then shape one agent around a process you know and prepare it in depth; C, build as much as possible and improvise the explanations.
  • Decision: B. Do every exercise, since they're mandatory, and prepare one agent you can explain end to end, from the business problem to its limits.
  • Consequences: less breadth in the practice system; clear answers about purpose, tools, approval and limits, which are what the roleplay asks about.

What a design review will ask (and, in some form, the avatar may too):

  1. What problem does this agent solve, and how would you show it helped?
  2. Which user does each tool call act as?
  3. Where does a person approve before data changes?
  4. What happens when a tool returns an error or nothing at all?
  5. What can't this agent do yet?

Production concerns

This page is about an exam, so the concerns are about the candidate's data and devices.

  • Personal and customer data. The terms forbid personal data in the practice system. Use fictional data such as Calder's, and never paste real customer documents.
  • Credentials. Your Universal ID is personal, and the practice system credentials can't be shared. A team can't pool one sign-up.
  • Recordings. A video answer is a file on your laptop with your voice and screen. The FAQ asks for .mp4 under 1,000 MB. Delete it after your result if company policy requires.
  • Network. Corporate proxies can block the roleplay tool. Test from the same network you'll use on exam day.
  • Cost after the campaign. Budget Learning Hub for renewal next year, or accept that the certificate lapses.

Pitfalls

  • Logging in to look around. The 24 hours start at first login. Explore with the learning journey instead.
  • Leaving the exercises for later. They're mandatory before the exam, and the clock is running.
  • Building without a story. An agent that works but that you can't explain scores poorly in a roleplay.
  • Planning for 31 December. No time zone is stated, and a network problem on the last day has no fix. Treat 30 December as the deadline, and earlier for the video route.
  • Trusting one FAQ answer. The retake answer and the expiry rule conflict. Plan for the stricter one.
  • Real data in test requests. Customer names, emails or real order data in prompts break the terms and are a bad habit for projects.
  • Confusing the offers. The free runtime for select customers and the TechEd discount are not this certification offer.

Exercise: a dated plan and a ready dossier

You will produce the two files you'll take into the 24-hour window. They also go in your portfolio repository as evidence of how you prepare for a design review.

Before you start: finish Build it yourself, Steps 1 to 6.

  1. Open the Free Joule Studio Certification FAQ and the C_JSD page. Note today's date and anything that differs from this topic.
  2. Choose your first-login time and run plan without --today. Change the time until the result says OK.
  3. Create radar/jsd_plan.md with three sections: Facts checked (the date and any differences from step 1), My window (the timeline from plan) and Blockers (network, laptop, calendar).
  4. Fill in radar/my_agents.json for one agent built around a Calder process you know, for example blocked sales orders.
  5. Run check radar/my_agents.json until the agent shows READY.
  6. Rehearse with deck radar/my_agents.json --timed twice, with --seed 1 and --seed 2.
  7. Commit radar/jsd_plan.md and radar/my_agents.json to Git.

Done when plan prints OK for your chosen time, check prints READY for every agent in your dossier, and your rehearsal log shows two runs with no answer over 120 seconds.

Check yourself

Pick one answer for each question. The explanation appears after you choose.

1Why does this topic insist on finishing the learning journey before your first login to the practice system?

Answer: C. The terms start the 24 hours at first login, while the learning journey has no time limit. Moving all unclocked work before that login leaves the window for the mandatory exercises and the exam.

2In the script, what does check_agent flag when an agent's instructions include planner@calder-pumpworks.example?

Answer: D. check_agent runs an email pattern over the whole agent and reports any match. The pattern can't tell a fictional address from a real one, which is deliberate: the habit is to keep addresses out of agent instructions.

3You plan your first login for 30 December at 18:00. What does plan report, and why?

Answer: B. The window ends on 31 December at 18:00, after the 30 December 23:59 safe finish the script uses. The FAQ names no time zone, so the course keeps a day's margin.

4The FAQ says you may use attempts "starting January 1, 2027" and also that unused attempts expire on 31 December. What should you do?

Answer: A. The two answers conflict, so the safe plan follows the expiry rule. The terms only say the term lasts until the end date SAP announces, so they don't settle it either.

5Why does the deck ask "Where would a person approve before your agent changes data?" for every dossier?

Answer: D. The deck's questions are the course's own, not SAP's. Approval before data changes is a standing design rule in the course, and the Architecture view lists it as a question any review will raise.

6A teammate wants to share one sign-up so two people can practise. What is the problem?

Answer: B. SAP's terms say access credentials are assigned to one individual and can't be shared or reassigned. Each person signs up once with their own Universal ID.

7On exam day the roleplay won't load on the office network but works on a phone hotspot. What is the likely cause and fix?

Answer: A. SAP's scenario FAQ suggests trying another network to confirm a block and asking IT to allow those two addresses. The camera is optional, so it wouldn't stop the tool from loading.

Sources

  • Free Joule Studio Certification FAQs (SAP Learning) — read 2026-11-10; campaign October to 31 December 2026, start subject to Joule Studio GA; anyone with an SAP Universal ID, no restriction by company type, role or geography; sign up once; one attempt, 24 hours of practice system, AI roleplay tool; no Learning Hub needed and commercial attempts not accepted; all practice exercises mandatory before the exam; no own BTP subaccount needed; non-AI video route English only, results up to 20 business days; unused attempts expire; failed attempt consumed, doesn't count against commercial limits; commercial portfolio from 1 January 2027; standard stay-certified rules then apply; retake answer contradicts the expiry
  • SAP Certified - Joule Studio Developer (C_JSD) (SAP Learning) — read 2026-11-10; one scenario-based activity, 2 hours, 60%; roleplay in English, Spanish, Italian, French, Japanese and more, video English only; steps: technical readiness, build agents in the hands-on environment, AI avatar asks you to show your agents; learning journey Developing with Joule Studio marked required; Free voucher label
  • Joule Studio Developer Certification Terms and Conditions (SAP Learning) — read 2026-11-10; 24 hours of practice system from first login; no personal data in the system; credentials for one person, not transferable; competitors of SAP excluded; preliminary version without support; data deleted after the term
  • SAP Certification practical exams: scenario-based assessment FAQs (SAP Learning) — read 2026-11-10; start from the certification page; microphone required, camera optional; AI rates each exam objective from 1 Insufficient to 5 Excellent on meaning, not keywords; Save and view analysis; pausing stops the roleplay but not the countdown; video reviewed in up to 20 business days; firewall: allow *.yoodli.ai and storage.googleapis.com
  • Staying certified assessment options - FAQs (SAP Learning) — read 2026-11-10; 90-day window before the due date; AI roleplay or quiz; active SAP Learning Hub subscription required; a missed due date means retaking the full exam
  • SAP TechEd learning page (SAP Learning) — read 2026-11-10; 'Your Joule Studio Developer Certification is on us!', no cost through 31 December 2026, Claim your exam voucher button; separate TechEd attendee benefits (25% off an exam, Learning Hub access) 18 August to 31 December 2026
  • Developing with Joule Studio (SAP Learning journey) — read 2026-11-10; covers Joule Studio's place in the SAP Business AI Platform, agents, agent extensions and n8n workflows; prerequisite Understanding AI; role developer
  • Introducing Joule Studio (SAP Learning course) — read 2026-11-10; beginner, 1 h 16 min, 4 units: SAP Business AI Platform, Joule Studio, AI agents in Joule Studio, n8n workflows; part of Developing with Joule Studio
  • SAP Empowers AI Developers to Build What Matters and Turn Intent into Autonomous Execution (SAP News, 27 October 2026) — read 2026-11-10; Joule Studio runtime free through December 2026 for select customers (a separate offer); no mention of certification

Sign in to track your progress

We'll email you a one-time sign-in link. No password needed.

or

Tell us a little about you

Optional, every field. It helps us pitch answers to your questions at the right level and decide which topics to write next. It is never shown publicly, and you can change or clear it anytime from the account menu.

SAP areas you work in