SAP Community - SAP Build Apps

Unlocking the Power of SAP Build (SAP Build Bootcamp for Partners)

2025-10-09T07:22:45.050000+02:00

On September 18th, we conducted a session focused on the new SAP Build and how it can be an element of transformation enabeling innovation, automation, and extensibility. From a packed agenda, expert Q&A and networking; the participants had first-hand views on how the new SAP Build (and assets like Joule, ABAP RAP, and BTP AI Core) can be used as a differentiator and how organizations can leverage them to build and extend SAP solutions.

Agenda highlights & session recap:

Welcome & Introduction // SAP Build engagement- Speaker: Luis Felipe Lanz (SAP)

[Link to presentation]

The Road to Clean Core - Speaker: Daniel Alamo (SAP)

[Link to presentation]

The New SAP Build and Joule Studio - Speaker: Alejandra Gómez y Oswaldo Seara (SAP)

[Link to presentation]

ABAP RAP (RESTful Application Programming) - Speaker: Daniel Álamo (SAP)

[Link to presentation]

SAP BTP AI Core and AI Capabilities - Speaker: Fernando Terry (SAP)

[Link to presentation]

Key Takeaways

SAP Build Is Empowering a New Era of Business-Led Development
ABAP RAP: The Future of Extensibility, Built on Clean Core Principles
Joule Studio: AI with SAP context and Purpose
Framework Guidance: Building with Governance and Agility in Mind

What’s Next?
Here’s how to keep the momentum going:
- 💬Contact your SAP BTP Customer Success Manager
- 🎓Visit SAP Discovery Center Missions on BTP

Frontend Strategies for SAP Sales Cloud V2: An Architect’s Perspective on Modern UI Extensions

2025-10-24T17:00:09.113000+02:00

Introduction

As an SAP architect, I’m sharing my perspective on choosing the right frontend technologies and design strategies for SAP Sales Cloud V2. Selecting the appropriate frontend is not just about framework preference—it impacts user experience, integration, maintainability, performance, scalability, and adherence to SAP’s design principles.

While SAP Fiori provides a standardized and proven design framework, Sales Cloud V2 introduces a modern, non-Fiori-based UI. In this article, I’ll provide guidance on balancing Fiori compliance, lightweight frontend frameworks like React, seamless backend integration, performance, and scalability, along with best practices for extensions, mashups, and side-by-side scenarios with S/4HANA.

Understanding SAP Sales Cloud V2's UI

SAP Sales Cloud V2 introduces a modern, intuitive UI designed to enhance user experience and productivity. Unlike traditional SAP Fiori applications, V2's UI is not strictly Fiori-based. It leverages contemporary design principles to provide a seamless and engaging user interface.

For a visual overview of SAP Sales Cloud V2 UI.

Frontend Development Considerations

1. Aligning with SAP Fiori Design Principles

SAP Fiori offers a set of design principles aimed at creating consistent and user-friendly interfaces. While V2's UI is not Fiori-based, developers can still adhere to Fiori's design guidelines to ensure a cohesive user experience. Key considerations include:

Consistency: Maintaining uniform design elements across applications.
Efficiency: Optimizing workflows to reduce user effort.
Intuitiveness: Designing interfaces that are easy to understand and navigate.
Performance: Ensuring fast rendering and responsiveness.
Scalability: Designing the frontend to handle growing user loads and data volumes efficiently.

2. Choosing the Right Frontend Technology

The choice of frontend technology should align with the application's requirements and the desired user experience. Consider:

Fiori Elements (CAP / UI5): Ideal for OData-based applications requiring standardized Fiori UI patterns. Leveraging SAP BTP CAP best practices, Fiori Elements provide:
- Metadata-driven UI generation (List Report, Object Page, Analytical List Page)
- Out-of-the-box CRUD operations
- Automatic audit log and change history of business object tracking.In CAP, with simple annotations and minimal effort, audit logging tracks user and system actions for compliance, while change history tracking records the actual data changes in business objects — capturing before and after field values for complete business transparency.
- Attachment management support
- Event-driven integration through SAP Event Mesh
- Extensibility for custom fields and actions
- Built-in navigation, filtering, and sorting features
- Validations and field-level rules defined in CDS models are automatically enforced, ensuring consistent data integrity across UI and backend.
- Support for multitenancy, authentication, and authorization using SAP BTP XSUAA.
- Integration with OData v4, REST, and messaging-based endpoints.
- Note: If Fiori Elements annotations do not fully meet business requirements, teams should agree with business stakeholders to address those scenarios using custom UI extensions. This is not a limitation of CAP or Fiori Elements but reflects a custom requirement beyond the framework’s standardized scope.
UI5 Web Components for React: Use Fiori-compliant components within a React app to combine flexibility with consistency.
Documentation
React with Custom Components: For applications requiring highly customized UI aligned with Sales Cloud V2 look & feel.
UI5 Freestyle (SAPUI5): For deep integration with SAP backend and traditional Fiori look & feel.

When to Choose Fiori Elements for Sales Cloud V2

Backend services are OData-based
Standard UI patterns like List Report, Object Page, or Analytical List Page meet requirements
Minimal custom UI is needed
Out-of-the-box features (CRUD, attachments, audit/change history) are beneficial
Strict adherence to Fiori design guidelines is required
Faster delivery and lower TCO is a priority
Extensibility for custom fields and actions is needed

Balancing Look & Feel vs Out-of-the-Box Fiori

When integrating with backend services, consider:

Use Fiori Elements: When OData backend, standard UI patterns suffice, and business prioritizes rapid delivery, TCO, and built-in CAP features.
Use Custom / Lightweight Frontend: When business requires UI to match Sales Cloud V2 look & feel, heavy customization, or mashups.
Hybrid Approach: Combine CAP Fiori Elements for standard functionality with custom/lightweight frontends for specialized UI requirements.

Comparison Matrix

Aspect Fiori Elements Freestyle/UI5 Apps

Development Effort	Low – uses templates and OData annotations; minimal coding required	High – requires custom coding, UI5 expertise
User Experience Consistency	High – standard SAP Fiori UX is automatically applied	Variable – depends on developer adherence to guidelines
Flexibility / Customization	Limited – constrained by templates; complex interactions harder to implement	High – complete control over UI, personas, workflows, and visualizations
Time-to-Market	Faster – rapid deployment using standard templates	Slower – longer development cycles for custom design
Maintenance & Upgrades	Easier – standard templates simplify future upgrades	More complex – custom components may require refactoring
Performance & Best Practices	Optimized – built-in SAP performance standards	Dependent on developer implementation
Use Case Suitability	Standard CRUD apps, analytical or reporting apps, apps requiring consistent SAP UX	Highly specialized apps, innovative UX, unique workflows, complex integrations
TCO Impact	Lower – reduces overall Total Cost of Ownership	Higher – more development and maintenance effort

Guidelines / Recommendations

Follow SAP Standard Fiori Elements wherever possible to ensure consistency, rapid deployment, and reduced TCO.
Adopt low-code/no-code approaches (Fiori Elements, annotations, SAP Business Application Studio templates) to accelerate development and reduce complexity.
Follow central architecture and management directions:
- Align with global architecture standards and SAP Best Practices.
- Ensure compliance with governance, security, and upgrade strategies.
Use Freestyle/UI5 Apps only when necessary:
- For highly customized workflows, innovative UX, or complex integrations that cannot be achieved using standard templates.
Prioritize maintainability and scalability:
- Prefer standard templates and components to simplify future enhancements and upgrades.
Ensure consistent and high-quality user experience across applications.

Backend Integration Considerations

OData Services: Standard SAP protocol for frontend-backend communication
GraphQL: Flexible alternative to OData
REST APIs: For external service integration

Choose the backend service type that aligns with your frontend framework to ensure seamless integration, optimal performance, and scalability.

Extensions, Mashups, and SAP Build Apps

SAP Sales Cloud V2 supports extensions and mashups to enhance functionality:

Sales Cloud Extensions: Built on SAP BTP to extend V2 capabilities
Mashups: Embed external apps or services into Sales Cloud interface

Mashup-Based HTML UI

Work List: Mashup as work center feature
Detail View: Display detailed info in context
Quick View: Summarized data for fast access

Extensibility Using SAP Build Apps

SAP Build Apps enables no-code/low-code apps for all form factors. Extensions can be embedded in Sales Cloud V2.

Included for tenants with 100+ users
Additional licensing required for fewer than 100 users

References for Mashups and SAP Build Apps

Recommendations

Use Fiori Elements (CAP/UI5) for OData-based apps with standard UI patterns and built-in features (CRUD, attachments, audit)
Use React / custom frontend to match Sales Cloud V2 look & feel when business requires visual consistency or heavy customization
Use UI5 Freestyle for deep SAP backend integration and traditional Fiori UX
Consider hybrid approaches combining Fiori Elements and custom/lightweight frontends
Extensions and mashups should prioritize performance, consistency, security
Side-by-side scenarios with S/4HANA: maintain SAP UI5 for OData backend integration
Backend service type (OData, REST, GraphQL) influences frontend choice and integration approach

References

Key Takeaways

Choosing the frontend technology for SAP Sales Cloud V2 requires balancing look & feel, performance, scalability, and integration capabilities.
For Fiori-compliant UI, Fiori Elements (CAP/UI5) or UI5 Freestyle are preferred for OData-based apps.
For customized, lightweight UI aligned with Sales Cloud V2, use React or other modern frameworks.
CAP Fiori Elements provide out-of-the-box advantages: CRUD, attachments, audit/change history, navigation, filtering, and extensibility.
Hybrid approaches can combine standard Fiori Elements with custom frontends for specialized UX needs.
Backend service type (OData, REST, GraphQL) influences frontend technology choice.
Extensions and mashups should prioritize consistency, performance, and security.
Side-by-side scenarios (Sales Cloud V2 & S/4HANA) benefit from using SAP UI5 technologies for OData backend integration.

SAP TechEd2025-XP264- Explore how to run cloud-native applications on SAP BTP, Kyma runtime

2025-10-29T10:33:13.323000+01:00

Description

A sneak preview of the material for the SAP TechEd 2025 session catalog number XP264 - Explore how to run cloud-native applications on SAP BTP, Kyma runtime.

Day-2 Operations: Management, Maintenance, Monitoring, and Optimization
Technical connectivity to public and private (on-premise) systems

The repository with the session material has been public since Monday, November 3rd.

See you there in Bangalore!

Overview

This session introduces attendees to Day-2 operations with SAP BTP, Kyma runtime - a managed kubernetes environment to help connect and extend enterprise applications in the cloud-native world.

In a nutshell, SAP BTP, Kyma Runtime (SKR) is a managed k8s runtime environment with a kubernetes cluster based on Gardener and a set of building blocks called Kyma modules.

Each instance of SAP BTP Kyma runtime environment is a single k8s gardener cluster with its own set of kyma modules.
Subsequently, all these clusters are managed by a central Kyma Control Plane (KCP) that orchestrates the lifecycle of

the underlying hyperscaler project,
the Gardener Cluster,
and the Kyma modules.

During the session you will learn

how to operate applications with SAP BTP, Kyma runtime and discover the power of smooth integration with cloud applications and on-premise systems using the advanced connectivity features.
to explore operational best practices from mastering troubleshooting techniques and intelligent root-cause analysis to event-driven autoscaling that adapts to your business needs in real time.
about BTP multitenant applications with SAP BTP, Kyma runtime.

Requirements

The requirements to follow the exercises in this repository are...

Important

You must be able to fork the repository and activate the github actions at the fork. This is mandatory for this session!
Thus, you may need a GitHub user.
If you haven't got one yet, please sign-up on GitHub before the workshop or at the very beginning of the session.

Important

The session content is provided exclusively on the SAP-Samples github, and many excercises have been implemented as CI/CD Github Actions worflows (GHA).

Security is paramount. With the Github Action IDP-delegated flow, there is no more need to provide kubernetes and btp credentials when using github actions.

✅The Github Action workflows acting as the OIDC provider.
✅All the kubernetets environments in the landscape are configured to trust GitHub’s token identity provider. They come with the pre-configured OIDC applications leveraging the built-in Gardener OIDC shoot extension.
✅SAP Cloud Identity Services acting as a platform IDP on the BTP side of the house has been federated with the Github actions OIDC Provider
✅As a result, the very short-lived credentials are being fetched and rotated automatically on the behalf of the repository user for both kubernetes and btp platform operations.
The good news is you may run the GHA-based exercises directly, from your forked repository, in a browser on the provided teched laptop.

Disclaimer

Personal devices should not be used for this session. Hands-on session participants will be using Windows laptops provided by the organizers.

What to expect from this session?

👉Run and take time to inspect the results of the built-in automations. Ask questions. And if you feel like doing, go ahead and create your own variants as well.
👉The recommendation is, however, to go with the flow of the exercises, inspect the results, ask questions and leave the rest for the homework.
For all other exercises which may require a terminal use, you may use the built-in VSCode terminal window.
As this is a Day-2 operation brief, the entire cloud landscape has been pre-configured with a number of shared components, for instance:
- 🔗SAP Cloud Identity Services (SAP IAS)
- 🔗SAP Cloud Logging
- 🔗SAP HANA Cloud
- 🔗ArgoCDaaS
- 🔗SAP BTP Connectivity services - Destination service, Connectivity service, Cloud Connector, Connectivity Proxy and Transparent Proxy
- 🔗S4/HANA On-premise (private cloud) with the Cloud Connector in the private network.
All of the SAP Kyma environments have been configured to the same template (via terraform automation).
Last but not least, you will be able to play with a pre-deployed SAP Build multi-tenant application deployed to one of the kyma clusters.
Have fun!

XP264 now travels to Bangalore on Nov 26,2025 (Day 2)

Info/Links for TechEd Community Talk CT1293 - SAP Build Control Tower

2025-10-31T11:42:47.838000+01:00

This post is to provide additional reference information and links related to my community talk CT1293 - Get control of the control tower feature in SAP Build solutions. See you there.

Control Tower Layout

Here's is the current picture of the Control Tower.

I think the layout is simple and clean, though it has evolved with additional tiles over the last 2 years and I don't think it's so clear how everything is inter-related. Here is my annotated version with a few notes.

My notes:

Environments, introduced relatively recently with the public environment deprecated, seems to me the central most-important tile on the page
Destinations and API keys are strongly connected to environments
The first 3 tiles are related to transport: The first defines whether the tenant is dev/qa/prod for the sake of transport, and the governance rules (next 2 tiles) in part add an extra layer of approval for transport operations. The rules also affect simply creating a project.

More information on the Control Tower: https://help.sap.com/docs/build-service/build-service-guide/managing-control-tower?locale=en-US

Permissions

There are many layers of permissions within SAP Build. Here they are from highest to lowest level.

IAS

Identity Authentication Service (IAS), or perhaps now just Cloud Identity Service, is the very first level and at the most basic level lets you create new users.

I just want to point out one helpful feature are groups. I can set up a group and then assign that group role connections. When I have a new user I just add them to the group and they inherent all the role collections.

Here are groups in IAS.

Here I assign a group to a role collection. Note that SAP BTP does not have a dropdown of groups so you have to simply type in the name of the group.

YOu can do the same with attributes, for example, assign a role collection based on job function or home country.

More information: https://help.sap.com/docs/cloud-identity-services/cloud-identity-services/landing-page?locale=en-US

Tenants

Once you have a user in IAS, you can assign that user to a tenant and NOT assign them to other tenants. You can look in the Users page to see which users have access to the current tenant.

More information: https://help.sap.com/docs/btp/sap-business-technology-platform/business-users?locale=en-US

Roles

Once a user has access to the tenant in some way, you determine what they can do on that tenant by assigning them roles, not directly, but through role collections, which are sets of roles that loosely map to a persona (e.g., admin, developer, business user, super user).

Here's more information on the specific roles/role collections related to the low-code tools of SAP Build:

SAP Build Apps: https://help.sap.com/docs/build-apps/service-guide/configuring-user-roles?locale=en-US&q=role
SAP Build Process Automation: https://help.sap.com/docs/build-process-automation/sap-build-process-automation/authorizations?locale=en-US&q=role
SAP Build Work Zone: https://help.sap.com/docs/build-work-zone-standard-edition/sap-build-work-zone-standard-edition/about-roles-and-role-assignments?locale=en-US&q=role

Design-Time Authorizations

These authorizations are done on the project level, some know as collaboration authorizations, so you can work with others on specific projects.

For information on the meaning of each role, see https://help.sap.com/docs/build-service/build-service-guide/managing-project-members?locale=en-US.

Runtime Automarizations

Runtime authorizations are the authorizations you have within environments. Environments are separate areas for deploying projects, and each environment can be set up to allow different users to do different activities (e.g., view, deploy, add users).

For information on the meaning of each role, see https://help.sap.com/docs/build-service/build-service-guide/share-environment.

Governance Rules

Governance rules let you set up a process to be executed so managers can approve or reject whether another user can create a project or transport a project.

If you enable rules for either creation or transport, you are automatically given into the lobby an out-of-the-box process and action. You must deploy the process before the rules can take effect (the action is automatically published). Before deploying, you can modify the process -- you really must since it the process automatically gives the requestor the right to approve his own project.

For more information, see https://help.sap.com/docs/build-service/build-service-guide/governance?locale=en-US&q=governance+rules.

Transport

Transport allows you to create formal processes for moving projects from one tenant to another tenant, generally from DEV > QA > PROD. The transport does not deploy projects but simply moves the design-time projects from one SAP Build installation to another. You can only transport a released version.

You will have to install Cloud Transport Manager Service, and add the Content Agent Service on every tenant to which you want to transport content.

Once you have everything setup and execute a transport from the SAP Build lobby, the package goes to CTMS, where someone with the import role will need to approve the transport.

For more information on setting up transport, see https://community.sap.com/t5/application-development-and-automation-blog-posts/transporting-content-in-sap-build-apps-sap-cloud-transport-management/ba-p/13737478.

For more information on how to transport and prerequisites, see https://help.sap.com/docs/build/sap-build-core/transport-project?locale=en-US&q=transport.

What tools and practices enable advanced app development and SAP integration?

2025-11-06T14:04:12.604000+01:00

I recommend to access our Developing with SAP Build – From Apps to Automation learning journey.

Completing this learning journey will empower you to build advanced applications, automate processes, manage user access, and monitor performance effectively within the SAP ecosystem. These skills are in high demand, positioning you to make a significant impact in your organization and advance your career.

Start your learning journey today and unlock the full potential of SAP technologies. By mastering these advanced capabilities, you will be well-equipped to drive innovation, improve efficiency, and deliver measurable business value.

Goals

Get started with SAP: Building the basics
Develop your expertise: Skill deepening learning
Excel in your expertise: Advanced specialization learning

Prerequisites

Please post you question related to the digital learning Journey in the Q&A area.

Our SAP Learning Experts will get back to you as soon as possible!
We are here to support you.

I appreciate your feedback and we will make sure to continue sharing interesting topics.

Kind regards
Margit

Driving Extensibility, Innovation and Automation with SAP Build's Clean Core

2025-11-21T13:53:48.961000+01:00

Below you'll find a summary of what was discussed during our latest Clean Core webinar, led by NTT Data, looking into ways to extend SAP environments and accelerate innovation through SAP Build's Clean Core methodology.

🗓Agenda Highlights and session recap 🗓

Current context: The importance of Clean Core in SAP S/4HANA modernization
A Clean Core strategy keeps the SAP S/4HANA system free from heavy customizations that complicate upgrades. By reducing technical debt and streamlining updates, organizations gain more stability and agility. This approach lays the foundation for continuous innovation and smooth cloud adoption.
Overview of SAP’s Side-by-Side extensibility strategy: Pro-Code and Low-Code/No-Code
SAP's side-by-side extensibility allows organizations to innovate without modifying the core system. It offers both pro-code development for complex scenarios and low-code/no-code tools for business users. This ensures fast, secure innovation while keeping extensions isolated and easy to maintain.
Tools and frameworks for Pro-Code and Low-Code/No-Code developers
SAP BTP provides a unified set of tools supporting both professional developers and low-code/no-code creators. Pro-code users access advanced IDEs and SDKs, while business users work with visual development tools. Together, these frameworks accelerate development, enhance collaboration, and ensure secure, scalable extensions.
Main components: Build Apps, Build Process Automation, and Build Work Zone
The SAP Build suite includes three main elements that empower users across the organization. Build Apps enables rapid app creation, Build Process Automation streamlines workflows, and Build Work Zone centralizes access to applications and information. Combined, they create a cohesive digital workplace experience.
Basic principles of SAP Build Apps
SAP Build Apps focuses on visual, intuitive development to make app creation accessible to more users. It provides drag-and-drop tools, pre-built templates, and seamless integration with SAP and non-SAP systems. With cloud-native deployment and Fiori-aligned design, it supports user-friendly, governed, enterprise-ready innovation.

You can find in the link below the slides shared during the presentation with all of the content presented today by NTT Data.

Link to presentation

⁉️Still curious about clean core? ⁉️

✅Contact your BTP Customer Success Manager for further discussion

✅ Visit SAP Discovery Center Missions on BTP

Survey-driven Customer Feedback with Service Cloud V2 + SAP Build Apps

2025-11-26T07:00:17.236000+01:00

When a case is completed, send a Build Apps survey by email -> customer responses automatically update the V2 case.

Overview

Collecting feedback right after a case is closed or completed is one of the most effective ways to measure customer satisfaction and act on low scores quickly. In this setup :

Service Cloud V2 detects when a case moves into the completed status.
Automatically send an email to the customer containing a survey built in SAP Build Apps.
The customer opens the survey, submits a rating and optional comments and he is saves the survey.
Integration maps the submission back to Service Cloud V2 and updates the original case with survey fields.
This approach gives you a lightweight, mobile-friendly survey experience (Build Apps) and ties responses directly to the case in V2 for reporting, SLAs, and automated follow-up.
Short story / user scenario
Silla from “FastNet” support resolves a broadband outage and marks the case completed.
Immediately the system triggers a short email: “How was your support experience?”
The customer opens the link, gives 4/5 and a short comment. Within minutes the case in Service Cloud V2 shows the information
Survey rating = 4,Survey comments = "Good, but response time could be quicker".
A business rule checks for low scores (e.g., ≤ 3) and creates a follow-up task(manually or automatically) if needed.
Prerequisites (checklist)

Architecture Diagram

Implementation — Step by step

Step 1 - Create survey screen in SAP Build Apps
a. Create a simple app/page with:

b. Configure the page to accept query string:?caseId=<case-Id>

Step 2 — Add fields to Service Cloud V2 Case

Add custom fields to hold survey data as example

ZSurveyRating(Integer)
ZSurveycomments (string / long text)
ZSurveySatisfiedRating(string)

Step 3 — Create the HTML email template in SAP Service Cloud V2

Create an email template used for case closure notification that includes the survey link with a case identifier.

Example template body

Replace displayId with the actual placeholder your SAP Service Cloud V2.

Step 4 — Autoflow rule : Trigger email when case is completed

Use V2 autoflow rules to send the template:

Create a rule :

Trigger: Case status changes to complete or closed
Condition: Optional — case type, priority, or customer preference
Action: Send Email (select the template created)

Test by resolving a case and verifying the email is sent to the case contact.

Step 5 — Build an integration endpoint to accept submissions

Sample Service Cloud V2 API call (generic example):

PATCH https://<your-v2-endpoint>/api/v1/cases/{caseId}
Headers:
  Authorization: Bearer <access_token>
  Content-Type: application/json

Body:
{
  {
    "extensions": {
        "ZSurveyRating": 5,
        "ZSurveyComments": "Satisfied",
        "ZSurveySatisfiedRating": "4"
    }
}
}

Confirm your SAP Service Cloud V2 API endpoint and payload structure from the Service Cloud API documentation.

The survey data is transmitted from SAP Build Apps to SAP Service Cloud V2.

Summary / Benefits

Fast, lightweight feedback loop right at case closure.
Survey hosted in Build Apps gives flexible UI and easy mobile experience.
Responses are tied to cases for reporting and targeted follow-up.
Low friction for customers: short surveys increase response rate.

Delivering a 360° Customer View in SAP Sales Cloud V2 Using SAP CDP and Build Apps

2025-11-27T10:29:10.924000+01:00

Today’s sales operations extend far beyond traditional CRM data. To make accurate, timely decisions, sales teams need deeper customer intelligence such as behavioural indicators, marketing engagement metrics, transactional history, digital footprints, sentiment analysis, and segment classifications. SAP Customer Data Platform (CDP) integrates these diverse data points into a single, real-time unified profile.

This blog explains how to bring a full 360° Customer View into SAP Sales Cloud V2 using:

SAP CDP as the unified profile and interaction source
SAP Build Apps to build custom UI extensions
SAP Sales Cloud V2 mashup capabilities to embed the experience seamlessly

Why a 360° Customer View Matters for Sales Reps

Traditional CRM systems give sales reps only a basic snapshot of customer information, such as:

Account and contact details
Open opportunities
Logged activities and visits
Quotes and order history

While useful, this limited view often leaves sales reps without the full context they need. In today’s competitive environment, reps must understand how customers think, behave, and engage. This requires deeper insights, including:

Email engagement patterns (opens, clicks, conversions)
Website behaviour and product interest
Cross-channel interaction history
Purchase trends and loyalty behaviours
Segment membership and scoring
Predictive signals like propensity to buy or churn risk

SAP CDP transforms fragmented data into a unified, real-time Golden Profile. With SAP Build Apps extending Sales Cloud V2, this intelligence flows directly to sales users at the critical moment—when they’re engaging with customers and making key decisions.

High-Level Architecture

Implementation Steps

Step 1: Enable CDP API Access

SAP CDP exposes APIs for:

Profiles
Interactions
Orders
Calculated attributes

Configure OAuth client in CDP and note:

Base URL
Client ID
Client Secret

Step 2: Configure BTP Destination

In SAP BTP:

Name: CDP

Type: HTTP

Proxy Type: Internet

URL: https://<tenant>. gigya.com

This is consumed by SAP Build Apps.

Step 3: Setup Integration in SAP Build Apps

Create integration for BTP destination created in last step

Create API Data Entity with following information:

Name: Specify the entity name (e.g., ‘Order History’ for this example)

Path: API Path

Capabilities: List (multiple record) or retrieve (for single record)

The relative path and query can be made dynamic by using a formula, as shown below:

Next, a Data Variable needs to be created to populate the UI with data based on the integration configured for the entity named ‘Order’:

Step 5: Create Build Apps UI

In this example, the UI is designed to display only the customer’s order history. The UI element is bound to the Data Variable created in the previous step.

Build and deploy the app:

Step 4: Embed Build Apps UI into SAP Sales Cloud V2

In Sales Cloud V2:

Go to Extensibility → Mashups
Create a URL Mashup
Paste Build App deployed URL
Pass context parameters:

https://<build-app-url>?customerId={displayId}

Place the mashup in Account Overview tab

Result: True Customer 360 Experience

When the sales user opens a Account overview page:

They see unified CDP profile
They can view every cross-channel interaction
They know which segments the customer belongs to
They get intelligent scores and signals
They operate inside Sales Cloud V2 with ZERO backend coding

This turns Sales Cloud into a smart, intelligence-driven selling platform.

Summary

By combining:

SAP CDP for unified customer intelligence
SAP Build Apps for custom UI
SAP Sales Cloud V2 mashups for embedding

you deliver a powerful, real-time, 360° customer view directly into the sales workflow.

SAP Build Appsでリスト型変数に対しての入力フォームを作る方法

2025-11-28T03:40:35.124000+01:00

お客様から以下のような質問が有りましたので、SAP Build Appsでのフォームの作り方を解説したいと思います。

"SAP Build AppsからREST APIを使用して外部システムにデータを送信します。JSONの形式でデータを送らなければならないのですが、JSON内に配列が存在し、何個入力されるかわかりません。このような場合入力フォームはどのように作成すればよいでしょうか？"

JSONは以下のような形式でした。（注：改変してあります。お客様問い合わせのままでは有りません）

{
  "UserId": "UserID",
  "Items": [
    {
      "ItemCd": "AA0001",
      "Quantity": 2
    },
    {
      "ItemCd": "BB0002",
      "Quantity": 5
    }
  ]
}

なるほど、仮に注文データとして解釈すると、Itemsのところが購入物のようですね。たしかにこれは毎回何品注文するのかで変わりますね。

このようなパターンに対応したデータ入力画面をSAP Build Appsで作ってみたいと思います。

1. このデータを格納する変数を作成する

まずはこのJSONに相当する形式でデータを格納できる変数を作成します。

リストの中身はオブジェクト型で、オブジェクトのプロパティとしてItemCdとQuantityがあることに注意してください。

また、この変数はオブジェクト型ですのでページを開いたときはNullの状態の部分が存在します。例えばリストであるItemsはnullです。これは後続の処理で少々面倒になりますので空文字列を割り当てて置きたいと思います。
PageのロジックでPage mountedにSet app variableの処理を繋げ

variable1に対し

Itemsに最初から要素を１つ入れておくようにします。

2. ページを設計する

ページのデザインを行います。TREEの部分も名称を変更してみましたので、どこにどのようなコンポーネントを配置しているか確認してください。
Card Container1はカード型のスタイルを適用し、カード型の表示にしてあります。これはItemCdとQuantityはペアで入力される必要があるためですが、どうでしょうか？（デザインセンスに依存する部分です）

3. 変数をバインドする

フィールドに変数をバインドします。

UserId Input FieldのValueにvariable1.UserIdをバインドします。これでUserId Input Fieldへの入力値がvariable1.UserIdへ代入されます。
ポイントとなるのはCard Container1へのバインドです。

Card Container1のRepeat withにvariable1.Itemsをバインドします。variable1.Itemsはリスト型ですのでRepeat withの効果によりCard Container1が繰り返し表示されます。そしてItemCd Input fieldのValueには

Data Item in repeatからcurrent.ItemCdをバインドします。これはリスト型変数の現在行のItemCdを意味します。
同様にQuantity Input fieldのValueにもcurrent.Quantityをバインドします。

4. +アイコンの処理を作成する

+アイコンは機能として「このアイコンがクリックされたらItemCd、Quantityの入力項目の数を増やすという役割をもたせます。前項でRepeat withでリスト型である変数variable1.Itemsをバインドしました。Repeat withの動作はバインドされたリスト型で変数の要素数だけ繰り返すというものです。では入力項目を増やしたい場合は？そうです。配列の要素数を増やせばよいのです。ということで+アイコンをタップしたときの処理としてSet app variableを使用して

variable1.Itemsに対し、Formulaで

WITH_ITEM(appVars.variable1.Items, {"ItemCd": "", "Quantity": 0 })
として、variable1.Itemsに配列要素を１つ追加します。これでRepeat withで繰り返される回数が1回増え、入力フィールドが増えるということになります。Previewで実際の動きを見てみましょう。

+アイコンをタップすると

Itemsの入力フィールドが増えていくのが確認できると思います。

5. -アイコンの処理を作成する

-アイコンは+アイコンとは逆にItemsの入力フィールドを消すということです。つまりはvariable1.Itemsの配列数を減らすということです。ということで-アイコンをタップしたときの処理としてset app variableを使用し、variable1.Itemsに対し

Formulaを使用して

REMOVE_ITEM(appVars.variable1.Items, index==repeatedInfo.current.index)
としてリストから現在行の要素を削除します。
repeatedInfo.current.indexはRepeat with機能を使用したオブジェクトで使用できるシステム変数です。式エディタのRepeat Informationから参照できます。他にも現在行が最初なのか最後なのか、奇数か偶数か、等面白い変数が用意されていますよ。

Previewで動作を確認すると、-アイコンのタップで入力フィールドが消えることを確認できるはずです。

6. フォームへの入力値をJSON形式に直して確認する

入力フォームは出来上がりましたので、あとは目的のJSONになるのかを確認します。ボタンを配置して、このボタンをタップしたときの処理を割り当てます。
ここで重要なポイントがあります。まずはENCODE_JSON関数を使用してvariable1の内容を

そのままAlertダイアログで表示したいと思います。

データを入力してボタンをクリックします。

全文が見えませんので、コピー＆ペーストしてみてみます。

{"Items":[{"ItemCd":"ItemCd1","Quantity":"10"},{"ItemCd":"ItemCd2","Quantity":"20"}],"UserId":"User1"}

これはよく見ていただくと解るのですが、Quantityの後の数値がダブルクォートで囲まれて文字列になっています。
このブログの冒頭にありますように、この部分は数値であることがRESTサービス側で要求されています。
なぜこのようになったのかというと、SAP Build Appsで開発したこのアプリケーションはWebアプリケーションであり、Java Scriptに変換されて動作するためです。Java ScriptとHTMLの仕様として以下のものがあります。

JavaScriptは「動的型付け言語」なので、変数自体に型は固定されておらず、あとから数値→文字列→オブジェクトというように中身の型を自由に変えることができます。
HTMLの入力フィールドへの入力値（HTMLInputElement.value ）はJavaScript では文字列として扱われます。

ページ上のQuantity Input fieldのValueにはvariable1のQuantityをバインドしましたが、これはHTMLレベルでは入力フィールドへの入力値です。そしてQuantity自体はNumber型を指定していますが、代入が出来てしまうので文字列型のまま代入されるということになります。バインド時にNUMBER関数を使用するという事ができませんので、表示時に数値型に変換するロジックを挟んで見ましょう。

variable1.Itemsに対してのset app variableのロジックです。Assigned valueにはFormulaとして以下を設定しています。

MAP(appVars.variable1.Items, { "ItemCd": item.ItemCd , "Quantity": NUMBER(item.Quantity)})

MAP関数を使用してappVars.variable1.Itemsの内容をitemというリスト型変数で取り出せるようにして、オブジェクト型の変数を再定義し、この際にNUMBER関数でQuantityの値を数値型に変換してappVars.variable1.Itemsに再代入という処理です。
動きを見てみましょう。

{"Items":[{"ItemCd":"ItemCd1","Quantity":10},{"ItemCd":"ItemCd2","Quantity":20}],"UserId":"User1"}

これで要求されるJSONの形式になりました。本当はこのあたりもSAP Build Appsでフォローしてくれると良いのですが。現状はこの様なやり方で対処する必要があります。

Repeat withは配列数分だけ繰り返す処理です。その配列自体の長さの変化にも追随できます。これをうまく利用することで複数項目の入力フィールドを作成することも可能です。実際にあるシチュエーションと思いますので使いこなしてください。

How to create an input form for a list-type variable in SAP Build Apps

2025-11-28T05:55:09.133000+01:00

A customer asked the following question, so I would like to explain how to create a form in SAP Build Apps.

"I want to send data from SAP Build Apps to an external system using a REST API. The data must be sent in JSON format, but there is an array in the JSON, and we don't know how many items will be entered. In such a case, how should the input form be created?"

The JSON had the following structure. (Note: It has been modified and is not exactly the same as the customer’s inquiry.)

{
  "UserId": "UserID",
  "Items": [
    {
      "ItemCd": "AA0001",
      "Quantity": 2
    },
    {
      "ItemCd": "BB0002",
      "Quantity": 5
    }
  ]
}

I see; if this is interpreted as order data, the Items section seems to represent the purchased products. Indeed, this will vary depending on how many items are ordered each time.

I would like to create a data entry screen in SAP Build Apps that can handle this kind of pattern.

1. Create a variable to store this data.

First, create a variable that can store data in a format corresponding to this JSON.

Note that the contents of the list are objects, and each object has properties ItemCd and Quantity. Also, since this variable is an object type, some parts may be null when the page is first opened. For example, the Items list might be null. This can cause some trouble in later steps.
so I want to assign an empty string instead. In the page logic, connect a Set app variable action to the Page mounted event.

For variable1

I will put one element into Items from the beginning , as initial value.

2. Page Design

I will now design the page. The names of each object have been changed to make them easier to understand, so please check the TREE section in the screenshot to see where and what kind of components are placed.
The "Card Container1" has a card-style layout applied so that it is displayed as a card. This is because ItemCd and Quantity need to be entered as a pair, but what do you think? (This part depends on design sense.)）

3. Bind Variables

Bind variables to input fields.

Bind variable1.UserId to the Value of the "UserId Input Field". This will assign the value entered in the "UserId Input Field" to variable1.UserId. The key point here is how "Card Container1" is bound.

Bind variable1.Items to the "Repeat with" property of "Card Container1". Since variable1.Items is a list type, "Card Container1" will be displayed repeatedly by the effect of Repeat with. Then, for the Value of the "ItemCd Input field",

Bind current.ItemCd from "Data Item in repeat". This refers to the ItemCd of the current row of the list-type variable. Likewise, bind current.Quantity to the Value of the "Quantity Input field".

4. Create logic for plus icon

The plus icon will have the role that when it is clicked, it increases the number of ItemCd and Quantity input fields. In the previous section, I bound the list-type variable variable1.Items to "Repeat with". The behavior of Repeat with is to repeat according to the number of elements in the bound list-type variable. So what should I do if I want to increase the number of input fields? Exactly, I just need to increase the number of elements in the array. Therefore, as the action when the plus icon is tapped, I use "Set app variable",

For variable1.Items, use Formula

WITH_ITEM(appVars.variable1.Items, {"ItemCd": "", "Quantity": 0 })
Add one array element to variable1.Items with the above settings. This will increase the number of repetitions in "Repeat with" by one and thus increase the number of input fields. Let’s check how it actually works in the Preview.

Tap plus icon ,

you will be able to see increase input fields for items.

5. Create logic for minus icon

The minus icon does the opposite of the plus icon; it removes an Items input field. In other words, it decreases the number of elements in the variable1.Items array. Therefore, as the action when the minus icon is tapped, use "Set app variable" for variable1.Items.

use Formula

REMOVE_ITEM(appVars.variable1.Items, index==repeatedInfo.current.index)
Set the above formula to delete the element in the current row.
"repeatedInfo.current.index" is a system variable that can be used with objects that use the "Repeat with" feature. You can reference it from "Repeat Information" in the formula editor, and there are other interesting variables such as whether the current row is the first or last one, or whether it is odd or even. When you check the behavior in the Preview, you should see that tapping the minus icon removes the input field.

6. Convert the values entered in the form to JSON format and verify them.

The input form is now complete, so the next step is to check whether it becomes the desired JSON. Place a button and assign the processing that will run when this button is tapped.

There is an important point here: first, use the ENCODE_JSON function on the contents of variable1.

I would like to display it as-is in an Alert dialog.

Enter the data in the Preview and click the button.

I can’t see the entire text, so I’ll copy and paste it to check.

{"Items":[{"ItemCd":"ItemCd1","Quantity":"10"},{"ItemCd":"ItemCd2","Quantity":"20"}],"UserId":"User1"}

Looking closely, you can see that the value after Quantity is enclosed in double quotes and is therefore a string. As mentioned at the beginning of this blog, the REST service requires this part to be a numeric value. The reason this happens is that the application developed with SAP Build Apps is a web application that runs after being converted to JavaScript. According to the specifications of JavaScript and HTML, the following behavior applies.

Because JavaScript is a “dynamically typed language,” variables do not have a fixed type, and the type of their contents can be freely changed later, for example from number -> string -> object.
The value entered into an HTML input field (HTMLInputElement.value) is treated as a string in JavaScript.

The Value of the Quantity Input field on the page is bound to variable1.Quantity, but at the HTML level this is the value entered into the input field. Even though Quantity itself is defined as a Number type, the assignment is allowed, so the value is assigned as a string. Since the NUMBER function cannot be used at bind time, let’s insert logic to convert it to a numeric type when displaying it.

Add a Set app variable logic for variable1.Items. For Assigned value, set the following as a formula.

MAP(appVars.variable1.Items, { "ItemCd": item.ItemCd , "Quantity": NUMBER(item.Quantity)})

This process uses the MAP function to read the contents of appVars.variable1.Items into a list-type variable called item, then redefines the object-type variable and, at that time, converts the value of Quantity to a numeric type with the NUMBER function and assigns it back to appVars.variable1.Items. Let’s see how it works.

{"Items":[{"ItemCd":"ItemCd1","Quantity":10},{"ItemCd":"ItemCd2","Quantity":20}],"UserId":"User1"}

With this, the JSON now has the required format. Ideally, SAP Build Apps would handle this part automatically, but at present it is necessary to deal with it in this way.

"Repeat with" is a process that repeats according to the number of elements in an array, and it can also adapt to changes in the length of that array. By making good use of this, it is possible to create input fields for multiple items. This is a situation that will likely occur in practice, so please make full use of it.

Regards,

Integrating ABAP system with SAP Build Apps

2025-12-02T14:46:34.261000+01:00

Hi! We want to use SAP Build Apps to create a full-stack application using ABAP (ADT-Eclipse) as backend, but we can't create a communication arrangement. We've tried multiple approaches, such as:

-Using the shared account provided through the e-learning materials

-Using a free trial personal BTP account

-Connecting to a private cloud/on-premise system via the Cloud Connector.

Unfortunately, each approach resulted in connection issues that we could not resolve. Given the current circumstances, we presume that regardless of the approach, we need to have access to an ABAP-on-Cloud instance in which admin roles are granted to me.

This is what our ABAP instance dashboard shows:

We've followed several tutorials, and we think we should have an Administrator tile and also, when we search Communication in the app finder, we only get System Outbound Communication as result.

We'd greatly appreciate any tips or guidance.

Hands-On Guide: SAP Build + Joule Skill for Purchase Order Listing, Approval, or Modification

2025-12-22T08:09:03.721000+01:00

Introduction

In this tutorial, we will build an AI powered Purchase Order listing, modification or approval app using SAP Build and Joule. This step by step guide covers everything from OData integration to creating a working Joule Skill.

Table of Contents

In today’s SAP ecosystem, intelligent automation is an expectation, not a future goal. SAP Build allows developers to quickly create business applications without extensive coding and SAP Joule brings AI-driven intelligence to these experiences.

In this hands-on guide, I’ll walk you through the process of building a Joule skill that connects to an OData service, allowing users to list, approve, and update purchase orders directly through SAP Build. ( This guide uses ZTABLE to store purchase order data because the standard SAP tables in the test system I work on don't have enough or the right kind of data. However, you can use the standard tables instead of ZTABLE. )

This project shows how AI capabilities can seamlessly integrate into SAP’s low-code environment, enabling automation and human decision-making in one interface. Whether you want to enhance your workflow with intelligent actions or explore real-world Joule integration scenarios, this guide will provide a practical starting point.

1. Create an Environment

We need to create an environment for testing joule skill.

Open the SAP Build Lobby, choose Control Tower->Environments and press the Create button.

Name your environment and add Description.

2. Exposing the Destination

Url of the destination on BTP is the url of our SAP system and the destination must have these properties:

sap.applicationdevelopment.actions.enabled -> true

sap.processautomation.enabled -> true

sap.build.usage -> odata_gen

Also the destination’s user will be used for set an external break-point for debugging the ABAP code.

Open the SAP Build Lobby, choose Control Tower->Destinations and press the Add button.

Select the Destination and choose next.

Choose the environment in which you want to use the target. For this tutorial you can choose the Test Environment that you create.

3. Create a database table to store purchase orders

@EndUserText.label : 'Purchase Order Change With Sap Build'
@AbapCatalog.enhancementCategory : #NOT_CLASSIFIED
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #A
@AbapCatalog.dataMaintenance : #ALLOWED
define table zbg_build_test {
  key mandt                      : mandt not null;
  key purchaseorder              : ebeln not null;
  key purchaseorderitem          : ebelp not null;
  key reservationitem            : ebelp not null;
  material                       : matnr;
  materialcompisvariablesized    : boolean;
  materialcomponentisphantomitem : boolean;
  reservation                    : char10;
  @Semantics.quantity.unitOfMeasure : 'zbg_build_test.entryunit'
  requiredquantity               : menge_d;
  requirementdate                : dats;
  reservationisfinallyissued     : boolean;
  baseunit                       : meins;
  @Semantics.quantity.unitOfMeasure : 'zbg_build_test.entryunit'
  quantityinentryunit            : menge_d;
  entryunit                      : meins;
  plant                          : werks_d;
  latestrequirementdate          : dats;
  billofmaterialitemnumber       : ebelp;
  bomitemcategory                : char1;
  isbulkmaterialcomponent        : boolean;
  debitcreditcode                : shkzg;
  @Semantics.quantity.unitOfMeasure : 'zbg_build_test.entryunit'
  withdrawnquantity              : menge_d;
  approver                       : uname;
  appoved                        : flag;

}

Fill the table:

4. Create a CDS from the ZTABLE for Odata

@AbapCatalog.sqlViewName: 'ZSLV_BUILD_TST_V'
@AbapCatalog.compiler.compareFilter: true
@AbapCatalog.preserveKey: true
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Purchasing Document Informations CDS'
@Metadata.ignorePropagatedAnnotations: true
@ObjectModel.deleteEnabled: true
@ObjectModel.createEnabled: true
@ObjectModel.updateEnabled: true
define view ZSLV_V_BUILD_TEST as select from zbg_build_test as z 
    
{   @EndUserText.label: 'Purchase Order'
    key purchaseorder,
    @EndUserText.label: 'Purchase Order Item'
    key purchaseorderitem,
    @EndUserText.label: 'Reservation Item'
    key reservationitem,
    @EndUserText.label: 'Material'
    material,
    @EndUserText.label: 'Material Size'
    materialcompisvariablesized,
    @EndUserText.label: 'Material Item'
    materialcomponentisphantomitem,
    @EndUserText.label: 'Reservation'
    reservation,
    @EndUserText.label: 'Quantity'
    requiredquantity,
    @EndUserText.label: 'Date'
    requirementdate,
    @EndUserText.label: 'Reservation Issue'
    reservationisfinallyissued,
    @EndUserText.label: 'Unit'
    baseunit,
    @EndUserText.label: 'Entry Unit'
    entryunit,
    @EndUserText.label: 'Quantity In Entry Unit'
    quantityinentryunit,
    @EndUserText.label: 'Plant'
    plant,
    @EndUserText.label: 'Latest Requirement Date'
    latestrequirementdate,
    @EndUserText.label: 'Bill Of Material Number'
    billofmaterialitemnumber,
    @EndUserText.label: 'BOM Item Category'
    bomitemcategory,
    @EndUserText.label: 'Is Bulk Material'
    isbulkmaterialcomponent,
    @EndUserText.label: 'Debit Credit Code'
    debitcreditcode,
    @EndUserText.label: 'With Drawn Quantity'
    withdrawnquantity,
    @EndUserText.label: 'Approver'
    approver,
    @EndUserText.label: 'Approved'
    appoved 
    
}

5. Create OData service with T-code SEGW

(Because of the version of the system I work on, this guide uses SEGW instead of RAP to create an OData service. However, you can easily create your own OData service with RAP.)

Press ‘Create Project’ button, fill the fields and assign the package, request (For this tutorial it will be local object).

Complete the creation.

Extend the project, right click to ‘Data Model’, select the Reference->Source

Fill the CDS name that you created. Choose ‘Next’.

Choose ‘Finish’.

Activate and generate the Service:

Go to the class ZCL_ZSLV_BUILD_DPC_EXT. At the bottom of the method list redefine the update method ZSLV_V_BUILD_TES_UPDATE_ENTITY.

In the method, update the approved field with the below code and activate it.

METHOD zslv_v_build_tes_update_entity.
 
  DATA: lv_ebeln TYPE ebeln,
        lv_ebelp TYPE ebelp,
        lv_item  TYPE ebelp,
        ls_entity TYPE zcl_zslv_build_mpc=>ts_zslv_v_build_testtype,
        lr_entity TYPE REF TO data,
        ls_table TYPE zbg_build_test.
 
  LOOP AT it_key_tab INTO DATA(ls_key).
    CASE ls_key-name.
      WHEN 'purchaseorder'.
        lv_ebeln = ls_key-value.
      WHEN 'purchaseorderitem'.
        lv_ebelp = ls_key-value.
      WHEN 'reservationitem'.
        lv_item = ls_key-value.
    ENDCASE.
  ENDLOOP.
 
  io_data_provider->read_entry_data( IMPORTING es_data = ls_entity ).
  MOVE-CORRESPONDING ls_entity TO ls_table.
  er_entity = ls_entity.
  UPDATE zbg_build_test FROM ls_table.
  COMMIT WORK.
 
ENDMETHOD.

6. Activate the Odata service via /iwfnd/maint_service T-code

Choose ‘Add Service’

Select the ‘System Alias’, fill the ‘Technical Service Name’ and press ‘Get Services’. Select the service that you create and press ‘Add Selected Services’.

Assign the package and continue.

We have added the service, which should appear as follows. In the ICF Nodes section, there is a button labeled "SAP Gateway Client" that provides a testing environment for the service. Press that button.

Select the HTTP method as ‘GET’. Press ‘EntitySets’ to choose entity set. Choose the one that you created.

Press ‘Execute’ button for testing and response should appear as follows.

7. Crete an Action in SAP Build

Open the SAP Build Lobby, choose Connectors->Actions and press the ‘Create’ button. Choose ‘OData Destinations’ and select the Destination that we created.

Fill the Resource Path as follows and click ‘Next’.

The available methods are listed in this window. Select ‘Next’.

Fill the name and description for your action and create.

The action Purchase_Order_Action is created. Click the action and open it.

Select the methods in the OData Service.

The GET method's input has no required fields, only optional GET parameters.

Output parameters are the fields in the CDS that we created.

Methods can be tested in the action interface. For the GET method we don’t need to fill any input parameters. Click ‘Test’ button.

The data appears on the ‘Test Preview’ section.

The PATCH method requires purchaseorder, purchaseorderitem and reservationitem, all of which are key fields in our ZTABLE and CDS.

There are no standard output in PATCH method.

In the Test section, all required fields and fields that need to be changed must be filled out. In this scenario these fields are purchaseorder, purchaseorderitem, reservationitem and approved fields.

Also the link on the Test section can be used in the SAP Gateway Client to test the PATCH method.

PATCH method return “204: NO CONTENT” and empty Response. This means the update is successful and we will use this emptiness in our joule skill.

After checking and testing, save the methods using the ‘Save’ button and select ‘Release’. After the release process, the action should appear as shown below. Then, press 'Publish'.

You can debug when testing methods via the SAP Gateway Client or the SAP Build Action. Set an external breakpoint for the user in your destination that we created at the beginning.

For the PATCH method, our key fields in the internal table IT_KEY_TAB.

8. Create A Joule Skill to Get Purchase Order

Open the SAP Build Lobby, choose Create->Joule Skill and fill the name and description. Open the created skill.

Select the ’Trigger’ step. On the ‘General’ tab fill the name and description. Allow Joule to generate a response and skill to be started directly by user.

We don't need input, but outputs can vary according to our needs. In this tutorial, the parameters shown below have been added as outputs.

Choose ‘Configure’ and add parameters you want to show to the user. For this example, all parameters are string except the ‘approved’ which is boolean.

Press ‘+’ and choose ‘Call Action’, ‘Browse All Actions’.

Search for ‘ZSLV_V_BUILD_TEST’ or your Service Name. Add the ‘Get entities from ZSLV_V_BUILD_TEST’.

Select the ‘Destination Variable’ as Destination we created.

We can skip the input tab because there are no input for GET method.

We can see the output parameters in this tab.

On the "End" step, we need to assign the input and output parameters for the skills. Since we don't have any inputs, let's assign the outputs added in the "Trigger" step as our action's outputs.

Save the Joule Skill.

And Release.

Now Deploy.

Choose the Environment we created and click ‘Upgrade’.

Match the destinations, and the skill will be ready to use by Joule after deployment.

9. Create A Joule Skill to Approve Purchase Order

On the ‘Trigger’ step, fill the name and description. Deactivate the ‘Allow Joule to generate a response’ feature because in this skill we will create our own messages. The other feature should be active.

Configure the input parameters. Add purchaseorder, purchaseorderitem and reservationitem key fields as string. For approve skill we don’t need any output field.

Choose ‘+’ and ‘Call Action’.

Browse All Actions.

Search update or the service name. Add the Update entity in ZSLV_V_BUILD_TEST.

On the ‘General’ tab, assign the Destination.

On the ‘Inputs’ tab, assign the purchaseorder, purchaseorderitem and reservationitem to the parameters created on the "Trigger" step.

We only need to fill the fields ‘approved’ from the fields to be updated. We need to configure the ‘approved’ field because action inputs can only be string.

Choose ‘approved’ field and ‘Apply a formula’.

Type ‘true’ and click ‘Apply’.

Choose ‘+’ and ‘Check Condition’.

Choose the ‘Condition Editor’.

Add the following conditions and Click ‘Apply’. If PATCH method is executed successfully, the result will be empty.

If the condition is met, the left branch of the condition executes. In the opposite case, the ‘Default’ branch of the condition executes.

Choose the ‘+’ on the left branch and ‘Send Response’.

Open Message Editor.

Fill the parameters as shown below and save.

You can add parameters to the title and message with the ‘<>’ button.

Do the same steps for the right branch of the condition. ‘+’ -> ’Send Response’ -> ‘Open Message Editor’

Fill the parameters as shown below and save.

Save, Release and Deploy just like the previous GET_PURCHASE_ORDER skill.

10. Launch The Joule and Test The Skills

Open the SAP Build Lobby, choose Control Tower->Environments->Joule

Launch the joule, ask for Purchase Orders and get the details.

Ask joule to approve the purchase orders and get the illustrated success message card we create.

Did you know SAP BTP Destination Fragments and how to consume to integrate ?

2025-12-22T08:22:26.037000+01:00

In the era of hyper-automation and low-code/no-code platforms, seamless connectivity between services is critical. SAP BTP’s Destination Fragments provide a standardized, reusable approach to managing API endpoints, security configurations, and network policies.

This blog explores how developers can consume Destination Fragments in SAP Build Apps, Process Automation, and other development contexts to accelerate integration, enhance security, and streamline governance.

Reference : SAP Help Documentation - Destinations with Fragments

1. What Are Destination Fragments?

Destination Fragments are reusable configuration components in SAP BTP that define:

Target endpoints (e.g., SAP S/4HANA, SAP SuccessFactors, or external APIs).
Authentication methods (OAuth, Basic Auth, Client Certificates).
Network policies (e.g., CORS, whitelisting).
Custom headers or query parameters.

Fragments are consumed by Destinations, which act as unified gateways for applications to access backend systems securely.

2. Why Consume Destination Fragments?

Reusability: Define once, use across multiple applications.
Security Centralization: Enforce consistent authentication and encryption.
Governance: Ensure compliance with enterprise policies.
Simplicity: Eliminate manual configuration for each service.

3. How to Consume Destination Fragments

Follow these steps to consume a Destination Fragment in your BTP subaccount:

Step 1: Create a Destination

Navigate to SAP BTP Cockpit > Connectivity > Destinations .
Define properties:
- Name: my-fragment.
- Type: HTTP.
- URL: https://api.example.com.
- Authentication: OAuth2ClientCredentials.
- Client ID/Secret: Stored in BTP secrets.

Step 2: Create a Destination Using the Fragment

you will have to perform API request to create a New Fragment as there is no option of creation via UI in BTP - Destination

Step 3: Consume in Applications

Applications access the destination via the destination service:

// Example: Resolve a destination with an optional fragment and call its target URL.
// Requires: axios ^1.x

const axios = require('axios');

async function callViaDestination() {
  // Replace with your values
  const region = 'eu10'; // e.g., eu10, us10, etc.
  const destinationName = 'AVR'; // your destination name
  const fragmentName = 'APIKey'; // optional: the name of the destination fragment to apply
  const accessToken = process.env.DEST_CONF_ACCESS_TOKEN; // bearer token for Destination Configuration service

  const baseUrl = `https://destination-configuration.cfapps.${region}.hana.ondemand.com`;
  const destUrl = `${baseUrl}/destination-configuration/v1/destinations/${encodeURIComponent(destinationName)}`;

  try {
    // 1) Resolve destination (apply fragment via header if provided)
    const headers = {
      'Authorization': `Bearer ${accessToken}`,
      'Accept': 'application/json',
    };
    if (fragmentName) {
      headers['X-Fragment-Name'] = fragmentName; // apply fragment
    }

    const { data: destination } = await axios.get(destUrl, { headers });

    // destination typically includes properties like URL, headers, and possibly Authorization
    // depending on the auth type configured in the destination.
    const targetUrl = destination.URL;
    const targetHeaders = { ...(destination.headers || {}) };

    // If the resolved destination returns an Authorization header (e.g., OAuth flow handled by Destination service),
    // propagate it to the call below.
    if (destination.Authorization) {
      targetHeaders['Authorization'] = destination.Authorization;
    }

    // 2) Call the resolved target URL (GET as example)
    const response = await axios.get(targetUrl, {
      headers: targetHeaders,
      // If your destination requires additional headers like sap-client etc.,
      // they may be present in destination.properties or destination.headers.
      // You can map them into targetHeaders as needed.
    });

    console.log('Status:', response.status);
    console.log('Data:', response.data);
  } catch (err) {
    // Helpful diagnostics
    if (err.response) {
      console.error('Destination/Target call failed:', err.response.status, err.response.data);
    } else {
      console.error('Error:', err.message);
    }
  }
}

callViaDestination();

4. Use Cases & Diagrams

Use Case 1: SAP Build Apps (Low-Code)

Scenario: A Build App needs to fetch data from SAP S/4HANA Sales Orders.

Fragment: Preconfigured with OAuth2ClientCredentials and S/4HANA endpoint.
Consumption: Drag-and-drop the destination into the app’s data source.

Diagram:

Use Case 2: SAP Process Automation

Scenario: A workflow triggers an external payment gateway API.

Fragment: Includes API URL, Basic Auth, and retry policies.
Consumption: Use the destination name in a REST API step.

Diagram:

Use Case 3: CAP-Based Applications

Scenario: A CAP service reads data from a custom API.

Fragment: Configured with JWT Bearer token and CORS settings.
Consumption: Reference the destination in cds.env.

Diagram:

5. Key Benefits

Accelerated Development: Reduce integration time by 40%+ using pre-configured fragments.
Consistent Security: Enforce MFA, encryption, and auditing across all apps.
Centralized Control: Update endpoints/authentications once; changes propagate everywhere.
Compliance: Align with ISO 27001, GDPR, and enterprise security policies.

6. Conclusion

Destination Fragments in SAP BTP are a game-changer for developers, enabling secure, reusable, and governance-ready integrations. Whether you’re building low-code apps, automating processes, or developing enterprise services, fragments simplify connectivity while maintaining security and compliance.

Next Steps:

Explore the SAP BTP Destination Documentation.
Try fragments in the SAP BTP Destination Fragment API Doc.

By leveraging Destination Fragments, you future-proof your integrations and focus on innovation—not configuration chaos.

Tribute to Thomas Volmering

2025-12-23T11:06:24.578000+01:00

📢 Today is @thomas_volmering's last day at SAP.

Thomas joined SAP 26 years ago, and I met him when he was head of Product Management for SAP Build Process Automation, before he became Head of Product for SAP Build. Together we worked on many communication projects for SAP Build, including technical blog posts that you can read here. 📰

Let me just say that it has been a great pleasure and also some fun working with him, and I thank Thomas a lot for that. 🙏🏻

Please join me in wishing Thomas the very best for what's to come! 👍🏻

Improve Build Apps UIs to Allow Keyboard Click / Control Focus

2026-01-15T07:43:49.523000+01:00

I was doing this great tutorial by my colleagues @Rekha_DR and @shrinivasan_neelamegam about creating a chatbot using Build Apps and AI Core, a topic they delivered in the SAP TechEd developer keynote in 2024: https://github.com/SAP-samples/teched2024-developer-keynote/blob/main/topics/DEV100A-build-chatbot-apps-aicore/README.md

It worked perfectly.

The tutorial let you create a chatbot where you typed a prompt, got an answer, and then could send a new prompt, like a regular chatbot. (By the way, one of the clever designs of theirs was that the context of the conversation was always sent back to the AI Core with every subsequent prompt.)

I thought what would make the app even more helpful would be:

To be able to press Enter after typing in each prompt.
To place the cursor automatically in the prompt input box so the user could just start typing the next prompt.

Allow Enter Instead of Button Click

To do this, you first want to create a custom event for the logic that you want connected to the button click / Enter press.

Drag a Receive Event flow function onto the canvas.

Set the Event Source to Fired from "Trigger Event", and give the event a name, like SendChat.

Attach your logic (in this case the calls to AI Core) to the event.

Now all that's left is to trigger this event when the user clicks the button, or presses Enter.

For the button click, select the button click, drag a Trigger Event flow function, and connect it to your Component Tap event for the button.

Configure the Trigger Event flow function by selecting your new event to be triggered.

To enable the logic to be triggered by pressing Enter, highlight your input box, and create the following logic on the input box's onKeyPress event.

To the onKeyPress event, add an If Condition flow function with the following formula:

outputs["Receive event"].eventValue == "Enter"

And then to the top output add a Trigger Event, configured the same as for the button click logic above.

Place Cursor in Input Box

Every time I send a prompt, I want the cursor to return to the input box so I can type in the next prompt.

Install the Focus Input flow function from the Marketplace.

After the logic for sending the prompt and receiving the answer from AI Core, add this flow function and specify the input box.

😽

Use SAP Integration Suite to connect SAP and AWS services

2026-01-20T11:36:09.592000+01:00

Bridging the gap between SAP and 3rd party systems

Everyone already knows that SAP Integration Suite is the election tool to connect your SAP services. But did you know that it is also your tool to integrate Everything, Everywhere, All in One Place? (yes, almost like the Oscar award winning movie 🏆)

Use SAP Integration Suite to connect SAP and AWS services is a new official SAP Discovery Center Mission that focus on showcasing how easy it is to integrate not only SAP systems but also non-SAP systems using SAP Integration Suite.

For this mission, we decided to use the AWS platform as the example of third-party cloud services provider, but the same rational with this set of best practices and capabilities can be used to integrate with other cloud providers. By following the cards provided in the mission, you will see step-by-step how you can start to integrate an application developed with SAP BTP development tools with AWS services, such as S3 for image storage and Rekognition for image identification.
You can even use a SAP BTP Trial account to perform the SAP BTP parts of the mission, even though you will always still require also an AWS account to connect with the S3 and Rekognition services (and IAM for user and roles management on the AWS side). Either if you are a technical user or more of a business user interested in rapid application development, cloud integration strategies and/or AI-powered business solution, this mission is for you!

The following architecture shows the big picture of what the final result of the mission should look like, seamlessly combining the best of both SAP BTP and AWS platforms:

Use Case Description

The use case followed trough out the mission focuses in enabling a Supplier to donate surplus food ingredients through an AI-powered mobile and web application built using SAP Build Apps, a low-code/no-code solution within SAP Business Technology Platform (SAP BTP), seamlessly integrated with AWS capabilities for storage and artificial intelligence–based image recognition. For the integration part, you will leverage and combine different integration capabilities that are part of the SAP Integration Suite. The intended outcome of the use case is to minimize food waste while simplifying the donation process and facilitating redistribution to organizations in need.

Solution Components:

SAP Build Apps: The low-code/no-code application development service used to create the application (frontend and logic) where the Supplier can donate the surplus ingredients by taking or uploading photos
SAP Integration Suite: The secure and centralized integration management service for all your integrations, making them easier to manage, monitor and troubleshoot
Amazon S3: The Amazon service for simplified and cost-effective image storage capabilities
Amazon Rekognition: The Amazon service for AI-powered identification and categorization, in this case used to identify the ingredients in the images taken or uploaded from the application to a S3 bucket

The Use Case Flow:

A Supplier captures or uploads an image of surplus ingredients through the mobile/web app (developed with SAP Build Apps)
The image is securely stored in Amazon S3 via SAP Integration Suite (using Cloud Integration, Pre-built Open Connector and API Management capabilities)
Also via SAP Integration Suite, the app then calls Amazon Rekognition to automatically identify and categorize the ingredient present in the image (using Cloud Integration, Custom Open Connector and API Management capabilities)
The results are sent back to the app and ready for further processing

Learning Outcomes

By completing this Discovery Center Mission, you'll gain practical experience in:

Building low-code applications with SAP Build Apps
Configuring SAP Integration Suite for AWS connectivity
Implementing secure cloud-to-cloud integrations
Leveraging AI services for business process automation
Managing integration flows and monitoring capabilities

Getting Started

Once you open and start the Mission, you will see in the Project Board the different cards that will guide you step-by-step, divided in 7 columns.

Make sure you fullfill all the requirements indicated in the SET UP and PREPARE columns. After that, you can start with the EXECUTE columns. You will first explore the Open Connectors capability of SAP Integration Suite (in the Execute - OpenConnectors), followed by the Cloud Integration and API Management capabilities of SAP Integration Suite (in the Execute - Security Material and Integration Flow) and lastly you will get to visually create a simple app screen with SAP Build Apps (in Execute - Build app) .
After finishing the mission, don't forget to mark all the cards as completed and we encourage you to leave your feedback and share your experiences with the rest of the SAP Community.

And now, for those who saw the movie Everything Everywhere All at Once, DON'T "Just be a rock" and start the mission here! -> SAP Discovery Center Missions - Use SAP Integration Suite to connect SAP and AWS services

SAPUI5 – Pagination in Table on button click using S/4 Hana cloud oData service

2026-01-29T05:36:26.980000+01:00

Hi, in this blog I’m going to explain the pagination in Table with S/4 Hana cloud oData service with flexibility to control number of visible rows per page.

In this example, I am using S/4 Hana cloud oData service through destination. I have 621 records in Product entity set and by default, I have to display 10 records per click and user can change number of visible rows. So, I have placed four nav buttons for First page, Previous page, Next page and Last page with page count information and drop down for number of visible rows and then some magical code.

Firstly, create new front end web and mobile application with zproducts name.

In the canvas, give title as Products and remove bottom text.

Add Integration:

Go to Integrations tab and select add integration and then select BTP destinations under sap systems.

In BTP destinations, select our S/4 Hana cloud service destination i.e., S4HANA_Joule_Product and select A_Product entityset. Now Select install integration and enable data entity. You can browse real data by selecting browse real data. Click on save at top right corner.

Add Variables:

Now go to Variables tab and go to page variables and select add page variable and choose from scratch.

Add variable noOfVisibleRows with value type Number with initial value 10.

Similarly add variables totalNoOfRows with value type Number,

Variable currentPage with value type Number with initial value 1,

totalPages with value type Number with initial value 1 and

variable isRefresh with value type true/false with initial value false and Click on save at top right corner.

User Interface:

In User Interface, we install table with data adaptor from marketplace and assign our entity set to it to fetch the data and we will add new property to make table to load the data at each time when user clicks on nav buttons or change number of visible rows.

Go to User Interface tab and select marketplace and search for basic table with data adapter and install it. Drag and drop the basic table with data adapter to canvas and select configure and select A_product and add the required columns and in properties tab, at pagination in Object with properties, assign noOfVisibleRows page variable to page size, assign currentPage page variable to Page Number and click on save. Click on save and exit and save at top right corner.

Go to open in component template editor at bottom in properties tab and select properties and in properties, add new property Refresh of type true/false. Go to view and select add logic to Basic table with data adapter at bottom right corner. Drag and drop Receive event and select Internal property 'Refresh' changed and connect end of the receive event to start of get record collection. Click on save and exit. You can see Refresh property in properties tab.

Assign Refresh property with isRefresh page variable

Now select at page level and open logic canvas. Drag and drop record collection and connect to Page Mounted and assign A_Product to resource and for pagination make Include total count as true by selecting binding type as static values true/false.

Now drag and drop set page variable and select variable name as totalNoOfRows and assign formula outputs["Get record collection"].totalCount for value and connect end of get Record Collection top node to start of Set Page Variable node.

Similarly, drag and drop another set page variable for totalPages and assign formula CEIL(outputs["Get record collection"].totalCount / pageVars.noOfVisibleRows).

Add Nav Buttons:

Now drag and drop container at bottom of table and select layout as horizontal.

Drag and drop button inside the container and name it as First. For disabled, add formula IF(pageVars.currentPage > 1, false, true) and in logic convas, add two set page variables. One for currentPage and set the value to 1 and another for isRefresh and assign formula NOT(pageVars.isRefresh).

Similarly add another button inside the container and name it as Previous. For disabled, add formula IF(pageVars.currentPage > 1, false, true) and in logic convas, add two set page variables. One for currentPage and assign formula pageVars.currentPage – 1 and another for isRefresh and assign formula NOT(pageVars.isRefresh).

Add another button inside the container and name it as Next. For disabled, add formula IF(pageVars.currentPage < pageVars.totalPages, false, true) and in logic convas, add two set page variables. One for currentPage and assign formula pageVars.currentPage + 1 and another for isRefresh and assign formula NOT(pageVars.isRefresh).

Add another button inside the container and name it as Last. For disabled, add formula IF(pageVars.currentPage < pageVars.totalPages, false, true) and in logic convas, add two set page variables. One for currentPage and assign formula pageVars. totalPages and another for isRefresh and assign formula NOT(pageVars.isRefresh).

Drag and drop text after Previous button and for content add formula pageVars.currentPage + " / " + pageVars.totalPages.

Drag and drop Dropdown and give label text as No of Rows and select option list -> List of values and add value and give values 10, 25, 50, 100 and save. Make Placeholder text as empty.

In Logic pane of dropdown field, drag and drop set page variable and assign variable name to noOfVisibleRows and add formula IF(self.value, NUMBER(self.value), pageVars.noOfVisibleRows ) for value.

Similarly, drag and drop another page variable and assign currentpageno to it and value as 1.

Another page variable with totalpages and formula for value is CEIL(pageVars.totalNoOfRows / pageVars.noOfVisibleRows) and save at the top right corner.

Add another page variable with isRefresh with formula for value NOT(pageVars.isRefresh).

Preview Application:

Save at top right corner and click on preview and select open web preview. Now, you can see our application with pagination and flexibility to control number of visible rows per page.

By doing this, we can easily add pagination in Table on button click by consuming S/4 Hana cloud oData service with flexibility to control number of visible rows per page.

That’s it!!!

Enhancing Customer Data Accuracy with SAP DQM Address Validation in CX Sales and Service Cloud V2

2026-02-02T06:29:43.494000+01:00

Why Address Quality Matters in Customer Experience

In today’s customer-centric world, accurate address data is far more than a backend requirement — it directly impacts customer satisfaction, operational efficiency, and compliance. Invalid or inconsistent addresses lead to failed deliveries, delayed services, poor agent productivity, and frustrated customers.

With SAP CX Service Cloud V2, organizations can significantly improve data quality by integrating SAP Data Quality Management (DQM) – Address Validation Service, ensuring that customer addresses are accurate, standardized, and validated in real time.

What is SAP DQM – Address Validation?

SAP DQM Address Validation is a cloud-based service that helps organizations:

Validate postal addresses in real time
Standardize address formats based on country-specific rules
Enrich address data with missing components
Reduce duplicates and incorrect records

The service supports global address validation across multiple countries, making it ideal for enterprises operating at scale.

Why Integrate DQM with CX Service Cloud V2?

CX Service Cloud V2 acts as the single source of truth for customer interactions. Ensuring clean address data at this layer brings several benefits:

Key Business Benefits

🚀Faster case handling with fewer address-related corrections
📦Reduced delivery failures and service disruptions
😊Improved customer trust and experience
📊Better reporting, analytics, and segmentation

Key Technical Benefits

Real-time validation during data entry
API-based integration aligned with SAP BTP standards
Reusable validation logic across multiple CX touchpoints

Prerequisites

Before enabling the DQM service, ensure the following are in place:

SAP BTP account (Cloud Foundry environment)
Entitlement to SAP Data Quality Management, microservices for location data
CX Service Cloud V2 tenant
Basic understanding of SAP BTP Destinations and API consumption
SAP Build Apps

Enable DQM Service in SAP BTP

Navigate to SAP BTP Cockpit
Go to Entitlements → Entity Assignments
Add entitlement for SAP Data Quality Management
Create a Service Instance for Address Validation

Configure Authentication & Access

DQM services are secured using OAuth 2.0:

Create a Service Key for the DQM instance
Capture:
- Client ID
- Client Secret
- Token URL
- API endpoint

These credentials are used by CX extensions or middleware to securely call the DQM API.

Create Destination in SAP BTP

Create an HTTP destination to consume the DQM service:

Authentication Type: OAuth2ClientCredentials
Token Service URL: From service key
Client ID / Secret: From service key
Target URL: DQM Address Validation endpoint

This destination enables secure and reusable connectivity from:

SAP Build Apps
SAP Build Process Automation
Custom CX extensions

Similarly create for SAP Service Cloud V2

Create SAP Build Apps Project

Open SAP Build Apps
Create a new project (Web or Responsive App)
Choose Blank App or Master-Detail template
Name it: CX_Address_Validation_App
Design your site as per you requirement

Create Mashup in CX Service Cloud V2

Log in to CX Service Cloud V2
Navigate to:
Administrator → Mashup Authoring
Click New Mashup
Provide:
- Name: Address Validation – DQM
- Type: URL Mashup
- URL: Build Apps deployed URL

✔ Save the mashup.

Embedded Mashup in Account - CX Service Cloud V2

For a detailed walkthrough of the functionality, please refer to the video.
It showcases the embedded address validation experience in CX Service Cloud V2.

Build custom Joule Agent to analyze blocked freight order in S/4HANA TM

2026-02-08T01:49:35.777000+01:00

In this blog, the objective is to build a custom Joule agent with multiple skills that analyzes a blocked freight order in the S/4HANA Transportation Management (TM) solution.

To keep the scenario simple, the agent analyzes blocks caused by time conflicts and explains them in simple business language.

What you will learn

By the end of this blog, you will understand:

The prerequisites for building this use case
How to expose TM documents as OData services consumable by Joule
How to create Build Actions, Joule Skills, and a Joule Agent
How to write basic instructions for the Joule Agent
How to test and fine-tune the agent

All of this can be done with minimal or no coding. With the right access and setup, even a business user can follow these steps and build a basic scenario in about 30 minutes. The approach is similar across S/4HANA solutions, with different OData services used to fetch backend data.

Let’s look at the high-level steps

Pre-requisites
Identify available CDS views in S/4HANA TM and wrap it with an OData service
Configure SAP Cloud Connector – Joule (from public internet) needs secure communication channel to connect your ERP environment
Define Destinations on your BTP subaccount - connect to the OData service via cloud connector
Define Actions in Joule Studio
Define Joule Skills
Define Joule Agent
Test!

Let’s look at the steps in detail.

STEP 1: Pre-requisites

You need the following to run this scenario,

An S/4HANA private or on-premise environment
Eclipse IDE with ABAP Development Toolkit (ADT) – see the tutorial if you haven’t done
SAP Cloud Connector installed in your landscape – follow this if haven’t done
An SAP BTP subaccount with Joule Studio (Joule studio is one of the components of SAP Build) – follow SAP Discovery Center Mission for steps to do that.

STEP 2: Identify available CDS views in S/4HANA TM and wrap it with an OData service

Look at the SAP documentation for all available standard S/4HANA CDS views. For S/4HANA TM, see here. In this use case, we require data from Freight Order, its item and stop nodes. So, let’s login to S/4HANA system and create an OData service for the three CDS views.

Select a package and create a service definition

Select referenced object as the respective CDS view and create and activate the service definition for the three CDS views.

Once created the definition, create a service binding by right click on each definition. Follow the wizard and after creation, activate the binding and then publish it. You can see the service URL and note that down. You can as well test the service now.

STEP 3: Configure Cloud Connector

Login to your SAP Cloud connector and Configure cloud to On-premise for the subaccount you are going to use for Joule. ‘/’ expose all which is not ideal, but fine for testing environments.

STEP 4: Define Destinations on your BTP subaccount

Now login to your BTP sub-account and navigate to ConnectivityDestinations and create a destination of type ‘HTTP,’ proxytype ‘OnPremise’.

The URL must be constructed by combining virtual host URL in cloud connector with service end point. Also add additional properties as shown in the screenshot.

STEP 5: Define Build Actions

Now navigate to your Joule Studio (SAP Build) environment.

Navigate to the ConnectorsActions and create an action to fetch freight orders which are blocked.

Once you click create, select OData Destinations as API source. It will display all OData destinations defined in the subaccount. Pick the destination created in step 4.

It displays the available services in the underlying CDS view. Select Next and provide a meaningful name and description. Then navigate to the created action project.

Initially, the OData service will be with its basic definition. We need to add filter to fetch only filter blocked freight order (just pick execution blocked).

For this, click $filter parameter and then click Value F4 help in the popup. You can use condition editor or Text Expression.

Reduce output fields

In the Output tab:

Select the Body parameter.
Remove unnecessary fields.

For this scenario, keep only:

Order number
Description
UUID

You can test the action under the Test tab by selecting the destination and clicking Test.

If destination is not visible, Go to Control Tower view of Build and select Destinations and add the destination you created before.

Do these steps to create three actions to fetch root, item and stop information. Idea here is, first fetch root and then PRD item. From item node, get the FU and go to FU stop to get acceptable and planned dates. Provide all this information to Joule for analysis.

While creating action for item,

add a filter to restrict only PRD items.
Reduce the Output to have only freightUnitUUID field.

While creating action for stop,

Reduce output to pick only location, stoprole, stopcategory,acceptable start and end time and planned time.

STEP 6: Define Joule Skill

Navigate to Build Lobby and click create and select Joule Agent and skill. Once the project is created, click create and select Joule Skill. Provide a clear name and description of the skill.

Click on conversation starter and provide the prompt. Example ‘get execution blocked freight order with stop details and analyze the reason for block’

You don’t need any other input from user as we already did filter in our action to pick execution blocked freight orders.

Add the action by clicking the ‘+’ button and select our action to fetch freight order root.

Navigate to skill parameter (select anywhere in the editor and click >> button to view skill parameter). Select the output for http 200 code as shown below.

Finally bind the skill output to the trigger end of action.

Likewise create other skills to fetch item and stop nodes.

For item skill,

Skill input must be TransportationOrderUUID
Map skill input to action input as shown below

Finally map skill output to trigger end.

For stop skill,

Skill input must be FreightUnitUUID
Map skill input to action inputs shown below

STEP 7 – Create Joule Agent

In the project, create ‘Joule Agent’ and navigate to agent definition screen.

Define ‘Expertise’ which provides the persona of the agent and ‘Instructions’ as system prompt on how to analyze reason for blocked freight order. Write that in plain, simple English. An example as shown below.

Provide some few-shot learnings to the agent as part of instructions. Example below

##Example 1 (case with date 'TranspOrdStopPlanTranspDteTme' is before date 'TranspOrdStopAccptblStrtDteTme')

Given the following Freight unit stop details:

- Transportation stop acceptable start date: 10-January-2026

- Transportation stop acceptable end date: 12-January-2026

- Transportation stop planned date: 8-January-2026

// Business Rule: date 'TranspOrdStopPlanTranspDteTme' must be after date 'TranspOrdStopAccptblStrtDteTme'

// Analysis: 8-January-2026 is NOT after 10-January-2026

// Expected blocked freight order Analysis result: Since planned date is not after acceptable start dates, freight order is blocked

Select your desired LLM provider, base and advanced model. Example OpenAI, GPT-4o Mini and GPT-4o. Save the agent definition.

Navigate to the Tools tab and add the three skills to the Agent you created before,

At the end, your project will have one Joule Agent and three Joule Skills.

STEP 8: Testing!

Click on the Test icon at the top of the project. Select the actual destinations within BTP to be used at runtime.

The conversation starter will appear and click that.

The agent will:

Select the required skills
Execute them in the appropriate sequence
Map parameters between skills
Evaluate the data
Return a business-friendly analysis using the selected LLM

Summary:

This example demonstrates how easy it is to build custom Joule agents and skills.
The same approach can be applied to other S/4HANA solutions and a wide range of use cases.

This blog should help anyone new to Joule get started and build a simple proof of concept.

Creating a ‘Hello World’ Joule Agent

2026-02-11T11:55:37.566000+01:00

Building on Michael Ameling's excellent Agent Builder in Joule Studio announcement and The Joule Studio Learning Series, this post will guide you through building your first Joule Agent.

I'll walk you through the steps to build a "Hello, World" agent. Along the way, you'll get familiar with the basic workflow in SAP Build, explore the UI, avoid at least one common pitfall, and have your agent up and running in just a few minutes. By building the simplest possible agent, you'll gain the confidence that building agents is easy, and creating more sophisticated ones will feel like a natural next step. Let's get started.

Setup and Prerequisites

The setup of SAP Build Apps, the activation of Joule, and the SAP Agent Builder are described in these two blog posts:

I'll assume that's done, and we'll start our journey in the lobby of SAP Build Apps.

Creating a Project

Click on the "Create" button, and select "Joule Skill":

Enter a name and a description:

Creating the Joule Agent

You'll be forwarded to the overview of your project where you can create the Joule Agent:

Again, enter a name and a description. A proposal for the identifier will be generated automatically:

On the details page of your Hello World Agent, you could fill in the fields manually, but let's use Joule to create a proposal. In the top left, click on the Joule icon to open the Joule sidebar. Enter a prompt like this:

"Can you please update our existing Hello World agent by filling in the expertise, instructions and additional context? The agent should respond to every prompt with "Hello, World!"."

As a result, Joule updates the agent, and we're almost done. We just need to add a placeholder tool, for example the calculator, because Joule Studio does not allow an agent to be saved without a tool assignment:

Now you can save the agent, and we can move on to testing the functionality we've just implemented.

Testing the Joule Agent

When you click on the "Test" button (just above the "Save" button), you'll be asked which environment you'd like to test in. Select the environment associated with your email address.

If your email address doesn't appear in the dropdown, you need to activate your private environment first. To do so, click on the SAP Build icon in the top left corner, click on "Control Tower" in the left-hand menu, and then click on the "Environments" tile:

On the Environments screen, click the button to activate your private environment:

Afterwards, you can resume testing and your private environment should appear in the dropdown as described above.

Now we're ready to test the agent, for example with a prompt like "Let's test the agent".

As we can see, the agent correctly responds with "Hello, World!" 😅

To end the test session, just click on the "Stop Testing" button.

Deploying the Joule Agent

To get our agent out of the testing environment, we need to deploy it to a real environment.

Let's create a Hello World environment. Navigate to the Control Tower, select the Environments tile, and click on "Create". Enter a name and description for the environment. The proposal for the identifier will be generated automatically.

Your user will be automatically added to this new environment. If you see a blank screen when you want to view the environment details, just try refreshing the page in the browser. It may take a little while to generate.

Once the environment is active, we can deploy our agent. Click on the "Release" button in the agent overview.

In the subsequent pop-up, enter a release note and click on "Release".

Once released, switch to version 1.0.0 at the top of the screen by clicking on the dropdown next to the title.

In the released version, there is a "Deploy" button instead of the "Test" and "Release" buttons. Click on the "Deploy" button, select the Hello World environment, and click on "Deploy".

After a few moments, the status of agent version 1.0.0 will change to "Deployed and Active".

Testing the Deployment

As a final step in this tutorial, let's test our deployed agent in the Hello World environment.

Open the Hello World environment via the Control Tower and view the environment details by clicking on it in the list. There, you will see the deployment of the Hello World agent we just made.

To test it, open the Joule tab for this environment. Depending on your screen resolution, this may be hidden in the "More" drop-down. On this tab, click the "Launch" button.

Joule will open in a new tab and we can prompt it to test the agent, for example like this: "Run the Hello World agent."

To confirm that Joule actually called the agent, you can investigate the log by clicking on the icon in the top right of the title bar.

Conclusion

Congratulations, you just implemented your first Joule agent! As intended, the overall result is "just" a Hello World agent, but this is an important first step in your journey to becoming a Joule agent builder. You familiarized yourself with the UI and performed the full workflow from start to finish, including creating a project, creating an agent, testing, and deploying it. Along the way, we also used Joule itself to fill in the agent's configuration details.

From here, there are many more topics worth exploring, like Joule skills, MCP integration, or agent-to-agent communication. However, for me, it's always important to build a Hello World example first without getting lost in the details. With more complex starter scenarios, it's easy to get stuck on technical details and lose sight of the big picture. Now that you've completed your "Hello World", you can iteratively add more features and build more sophisticated agents. What's the first use case you're going to tackle?

SAP Community - SAP Build Apps

Unlocking the Power of SAP Build (SAP Build Bootcamp for Partners)

Agenda highlights & session recap:

Welcome & Introduction // SAP Build engagement- Speaker: Luis Felipe Lanz (SAP)

The Road to Clean Core - Speaker: Daniel Alamo (SAP)

The New SAP Build and Joule Studio - Speaker: Alejandra Gómez y Oswaldo Seara (SAP)

ABAP RAP (RESTful Application Programming) - Speaker: Daniel Álamo (SAP)

SAP BTP AI Core and AI Capabilities - Speaker: Fernando Terry (SAP)

Key Takeaways

What’s Next?

Frontend Strategies for SAP Sales Cloud V2: An Architect’s Perspective on Modern UI Extensions

Introduction

Understanding SAP Sales Cloud V2's UI

Frontend Development Considerations

1. Aligning with SAP Fiori Design Principles

2. Choosing the Right Frontend Technology

When to Choose Fiori Elements for Sales Cloud V2

Balancing Look & Feel vs Out-of-the-Box Fiori

Comparison Matrix

Guidelines / Recommendations

Backend Integration Considerations

Extensions, Mashups, and SAP Build Apps

Mashup-Based HTML UI

Extensibility Using SAP Build Apps

References for Mashups and SAP Build Apps

Recommendations

References

Key Takeaways

SAP TechEd2025-XP264- Explore how to run cloud-native applications on SAP BTP, Kyma runtime

Description

Overview

During the session you will learn

Requirements

Info/Links for TechEd Community Talk CT1293 - SAP Build Control Tower

Control Tower Layout

Permissions

IAS

Tenants

Roles

Design-Time Authorizations

Runtime Automarizations

Governance Rules

Transport

What tools and practices enable advanced app development and SAP integration?

Driving Extensibility, Innovation and Automation with SAP Build's Clean Core

Survey-driven Customer Feedback with Service Cloud V2 + SAP Build Apps

Delivering a 360° Customer View in SAP Sales Cloud V2 Using SAP CDP and Build Apps

SAP Build Appsでリスト型変数に対しての入力フォームを作る方法

1. このデータを格納する変数を作成する

2. ページを設計する

3. 変数をバインドする

4. +アイコンの処理を作成する

5. -アイコンの処理を作成する

6. フォームへの入力値をJSON形式に直して確認する

How to create an input form for a list-type variable in SAP Build Apps

1. Create a variable to store this data.

2. Page Design

3. Bind Variables

4. Create logic for plus icon

5. Create logic for minus icon

6. Convert the values entered in the form to JSON format and verify them.

Integrating ABAP system with SAP Build Apps

Hands-On Guide: SAP Build + Joule Skill for Purchase Order Listing, Approval, or Modification

1. Create an Environment

2. Exposing the Destination

3. Create a database table to store purchase orders

4. Create a CDS from the ZTABLE for Odata

5. Create OData service with T-code SEGW

6. Activate the Odata service via /iwfnd/maint_service T-code

7. Crete an Action in SAP Build

8. Create A Joule Skill to Get Purchase Order

9. Create A Joule Skill to Approve Purchase Order

10. Launch The Joule and Test The Skills

Did you know SAP BTP Destination Fragments and how to consume to integrate ?

1. What Are Destination Fragments?

2. Why Consume Destination Fragments?

3. How to Consume Destination Fragments

Step 1: Create a Destination

Step 2: Create a Destination Using the Fragment

Step 3: Consume in Applications