SAP Community - ABAP Cloud

Overview and roadmap of SAP Joule for Developers, ABAP with AI capabilities

2026-01-20T09:00:00.019000+01:00

ABAP is evolving.
AI is accelerating it.
And SAP Joule is right at the center.

In our live webinar, “Overview and roadmap of SAP Joule for Developers, ABAP with AI capabilities,” we’ll cut straight to what matters for partners: real use cases, clear direction, and practical value.

You’ll see how ABAP with AI helps speed up development with RAP, how to empower your apps with AI capabilities, and how to move custom code toward SAP BTP and SAP S/4HANA Cloud without breaking clean core principles. No theory overload. Just what works, and why.

We’ll also walk through the roadmap, so you can align your skills, services, and customer conversations with what’s coming next.

If you have basic ABAP Cloud knowledge and want to stay ahead instead of catching up, don’t miss this one.

👉 Register now and future-proof your ABAP strategy. https://partneredge.sap.com/en/library/education/psd/2026/jan/e_oe_te_w_PSD_WEB_00012777.html

#SAP #SAPBTP #SAPJoule #ABAPwithAI #SAPPartners #S4HANACloud

Your 2026 Roadmap to Getting Started with ABAP AI and ABAP-1

2026-01-21T18:01:36.956000+01:00

The era of "Wait and See" for AI in ABAP development is officially over. With the general availability of Joule for Developers (J4D) and the planned availability of ABAP agentic AI frameworks in 2026, the question isn't if you should use AI, but where you should start.

The "Start Here" Recommendation: For 90% of developers, the best starting point is SAP Joule for Developers integrated within ABAP Development Tools (ADT) for Eclipse. In addition you can also experiment with the first versions of ABAP-1 model to analyze and explain code on your own - but be aware that this is currently not for code generation and only for those which want to be independent of J4D. Therefore starting with J4D is the fastest but also the most powerful way to start with ABAP AI.

Why should I start with Joule for Developers (J4D)?

Contextual Intelligence: Unlike generic LLMs, Joule for Developers is additionally trained on over 250 million lines of proprietary SAP code and is aware of your specific ABAP Cloud context. In general J2D is powered by a combination of third-party foundation models (e.g. OpenAI, Gemini, Anthropic, Mistral AI), alongside SAP-centric models like the LLMs, trained specifically on ABAP and purpose-built for cloud-based SAP development.
It’s Free (For Now): SAP has extended the free promotional period for Joule for Developers until September 2026.
Native Skills: It handles predictive code generation (e.g. RAP generation), "Explain" skills for legacy code, and unit test generation directly within your IDE. So it can do way more then ABAP-1 right now.
J4D is out of the box integrated in Eclipse ADT.

The Three Paths for ABAP AI Evolution:

1. The Standard Path: Joule for Developers in ADT

Best for: Daily coding, documentation, and unit testing.
Action: Request access through your administrator (Material 8019124 for customers and 8019541 for partners) and activate it in ADT.

2. The Innovation Path: ABAP AI SDK & BTP Free Tier

Best for: Building your own AI-powered business applications (e.g., automated invoice processing).
Action: Use the SAP BTP Free Tier to access the Generative AI Hub and the ABAP AI SDK to connect your custom ABAP code to external foundation models.

3. The Modernization Path: VS Code with ABAP Cloud (Roadmap Q2/2026)

Best for: Developers looking for a lightweight, file-based experience and for those which want to be the first to leverage agentic ABAP AI in side-by-side approach.
Action: Explore the new side-by-side ABAP Cloud Extension for VS Code (GA planned for Q2 2026) with built-in Agentic AI assistance powered by an ABAP MCP server. This will support a broader range of SAP S/4HANA Private Editions and provide faster update cycles.

Key Takeaway for 2026:
Don't get bogged down trying to "prompt engineer" experimental models like ABAP-1 for production code generation. Instead, leverage Joule for Developers mature "Explain" and "Generate" skills to maintain a Clean Core and accelerate your migration to SAP S/4HANA.

Here you can learn more:

More high-level insights about Joule for Developers/ABAP AI and ABAP platform can be found here . Here you find more on ABAP- 1,

Mass Update Through Custom Action In RAP

2026-01-23T06:31:27.262000+01:00

Introduction:

With the increasing adoption of the RESTful ABAP Programming Model (RAP), SAP developers are encouraged to move away from classic procedural approaches and design applications that are behavior-driven, scalable, and Fiori-ready. While RAP provides powerful standard operations such as create, update, and delete, real-world business scenarios often require mass processing or bulk updates triggered by user actions.

In this blog, I will walk through a practical implementation of mass update using a custom action in RAP. This approach is especially useful when you need to update multiple records based on business logic that cannot be handled by standard CRUD operations alone.

Solution Overview:

The blog covers:

Why custom actions are required for mass updates in RAP
How to define a custom action in the Behavior Definition
Implementing the action logic in the Behavior Implementation class
Triggering the mass update from a Fiori Elements UI
Key considerations and best practices

Database Table:

@EndUserText.label : 'travel uuid table'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #A
@AbapCatalog.dataMaintenance : #RESTRICTED
define table zuuid_table {

  key client    : abap.clnt not null;
  key travel_id : sysuuid_x16 not null;
  description   : /dmo/description;
  status        : /dmo/travel_status;
  @Semantics.amount.currencyCode : 'zuuid_table.currency_code'
  booking_fee   : /dmo/booking_fee;
  @Semantics.amount.currencyCode : 'zuuid_table.currency_code'
  total_price   : /dmo/total_price;
  currency_code : /dmo/currency_code;
  createdby     : syuname;
  createdat     : timestampl;
  lastchangedby : syuname;
  lastchangedat : abp_locinst_lastchange_tstmpl;

}

Root Entity:

@AccessControl.authorizationCheck: #MANDATORY
@Metadata.allowExtensions: true
@ObjectModel.sapObjectNodeType.name: 'ZUUID_TABLE'
@EndUserText.label: '###GENERATED Core Data Service Entity'
define root view entity ZR_UUID_TABLE
  as select from zuuid_table as R_UUID_TABLE
{
  key travel_id as TravelID,
  description as Description,
  status as Status,
  @Semantics.amount.currencyCode: 'CurrencyCode'
  booking_fee as BookingFee,
  @Semantics.amount.currencyCode: 'CurrencyCode'
  total_price as TotalPrice,
  currency_code as CurrencyCode,
  createdby as Createdby,
  createdat as Createdat,
  lastchangedby as Lastchangedby,
  @Semantics.systemDateTime.localInstanceLastChangedAt: true
  lastchangedat as Lastchangedat
}

Projection View:

@Metadata.allowExtensions: true
@Metadata.ignorePropagatedAnnotations: true
@EndUserText: {
  label: '###GENERATED Core Data Service Entity'
}
@ObjectModel: {
  sapObjectNodeType.name: 'ZUUID_TABLE'
}
@AccessControl.authorizationCheck: #MANDATORY
define root view entity ZC_UUID_TABLE
  provider contract transactional_query
  as projection on ZR_UUID_TABLE
  association [1..1] to ZR_UUID_TABLE as _BaseEntity on $projection.TravelID = _BaseEntity.TravelID
{
  key TravelID,
  Description,
  Status,
  @Semantics: {
    amount.currencyCode: 'CurrencyCode'
  }
  BookingFee,
  @Semantics: {
    amount.currencyCode: 'CurrencyCode'
  }
  TotalPrice,
  CurrencyCode,
  Createdby,
  Createdat,
  Lastchangedby,
  @Semantics: {
    systemDateTime.localInstanceLastChangedAt: true
  }
  Lastchangedat,
  _BaseEntity
}

Metadata Extension:

@ui.lineItem: [ {
    position: 10 , 
    label: 'Modify Status', type: #FOR_ACTION, dataAction: 'UpdateStatus'
  } ]
  @ui.selectionField: [ {
    position: 10 
  } ]

Root Behavior Definition:

define action in BDEF.
parameter which defines inputs for our actions.

managed implementation in class ZBP_R_UUID_TABLE unique;
strict ( 2 );

with draft;

extensible;
define behavior for ZR_UUID_TABLE alias R_UUID_TABLE
persistent table ZUUID_TABLE

extensible
draft table ZUUID_TABLE_D
etag master Lastchangedat

lock master total etag Lastchangedat
authorization master( global )
{
  field ( readonly )
   TravelID,
   Lastchangedat;

  field ( numbering : managed )
   TravelID;


  create;
  update(features : instance );
  delete(features : global);
  action(features : global) UpdateStatus parameter zstatus_str;
  draft action Activate optimized;
  draft action Discard;
  draft action Edit;
  draft action Resume;
  draft determine action Prepare;

  mapping for ZUUID_TABLE corresponding extensible
  {
    TravelID = travel_id;
    Description = description;
    Status = status;
    BookingFee = booking_fee;
    TotalPrice = total_price;
    CurrencyCode = currency_code;
    Createdby = createdby;
    Createdat = createdat;
    Lastchangedby = lastchangedby;
    Lastchangedat = lastchangedat;
  }

}

Parameter For Action:

@EndUserText.label : 'staus structure'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
define structure zstatus_str {

  status : /dmo/travel_status;

}

Implementation:

  METHOD UpdateStatus.


  MODIFY ENTITIES OF zr_uuid_table IN LOCAL MODE ENTITY r_uuid_table
  UPDATE FIELDS ( Status ) WITH VALUE #(  for key in keys
                                            (  %key-TravelID = key-TravelID
                                              Status = key-%param-status ) )
                                              REPORTED data(lt_reported)
                                              FAILED data(lt_failed).

  ENDMETHOD.

Explanation:

MODIFY ENTITIES is the RAP statement used to change data in a behavior-managed entity.
IN LOCAL MODE ensures the operation runs within the current LUW without immediately committing to the database.
UPDATE FIELDS Status explicitly restricts the update to the Status field only, improving clarity and performance.
keys contains all selected instances for which the action is triggered.
The FOR expression loops over each selected key, enabling mass processing in a single statement.
%key-TravelID identifies the record to be updated.
key-%param-status retrieves the action parameter value passed from the UI for ex, a new status selected by the user.
lt_reported captures informational, warning, or success messages generated during the update.
lt_failed contains records that could not be updated due to validation errors, authorization issues, or business rule violations.
These tables are automatically processed by RAP and reflected back to the UI, ensuring proper user feedback.

Projection BDEF:

expose our custom action in projection behavior definition.

projection implementation in class ZBP_C_UUID_TABLE unique;
strict ( 2 );
extensible;
use draft;
use side effects;
define behavior for ZC_UUID_TABLE alias R_UUID_TABLE
extensible
use etag
{
  use create;
  use update;
  use delete;

  use action Edit;
  use action Activate;
  use action Discard;
  use action Resume;
  use action Prepare;
use action UpdateStatus;
}

Preview:

select records and click on modify status button.
Assign any travel status and it will be updated.

Conclusion:

Custom actions in RAP provide a clean and scalable way to handle mass update scenarios that go beyond standard CRUD operations. By leveraging MODIFY ENTITIES, action parameters, and RAP-managed messaging, developers can implement efficient bulk updates while fully adhering to RAP principles. This approach ensures better performance, cleaner code, and seamless integration with Fiori Elements, making it a recommended pattern for real-world business requirements.

ABAP Connectivity ABAP Extensibility SAP BTP ABAP environment

Developing AI Enabled Applications with ABAP AI SDK powered by ISLM

2026-01-23T08:05:00.042000+01:00

SAP Joule for Developers, ABAP AI Capabilities is your intelligent coding companion, bringing deep expertise in ABAP Cloud and AI-driven development. When we talk about ABAP AI use cases, they revolve around three key pillars — Accelerate, Empower, and Transform. Each AI capability is delivered as part of these pillars, helping developers enhance productivity, build smarter applications, and drive innovation. To learn more about SAP Joule for Developers, refer to the blog post Joule speaks ABAP! by Dr. Alexander Rother.

Have you ever wondered how to infuse intelligence into your ABAP-based business applications and move beyond standard transactional scenarios? If yes, you’ve landed at the right place. In this blog, we’ll explore how you can build AI-enabled applications using the ABAP AI SDK powered by Intelligent Scenario Lifecycle Management (ISLM), the main deliverable of the Empower use case.

The Scenario
The goal of this scenario is to infuse generative AI into an ABAP Cloud application to enhance user experience and automate content creation.

Use Case: Build an ABAP Cloud application to generate a travel itinerary for a given city based on user input, along with a budget breakdown, using ABAP AI SDK powered by ISLM.

Which products are supported?

The ABAP AI SDK powered by ISLM is available in:

SAP BTP ABAP Environment

SAP S/4HANA Cloud Public Edition

SAP S/4HANA Cloud Private Edition and SAP S/4HANA OnPrem as of release 2025 via standard delivery. Lower releases of SAP S/4HANA Cloud Private Edition and SAP S/4HANA OnPrem are supported via Transport-based Correction Instructions (TCI), see details in SAP Note 3513374 and the SAP Notes and instructions linked therein.

Overview

To build this application, we’ll bring together several key components:

SAP AI Core – for managing AI scenarios and accessing generative AI capabilities via the generative AI hub.

Communication Arrangement – to establish secure integration between ABAP and AI Core.

ISLM (Intelligent Scenario Lifecycle Management) and ABAP AI SDK – for seamless integration with Generative AI Hub, SAP BTP AI services

Custom ABAP Cloud Application – to embed and expose AI capabilities through a user-friendly application.

Implementation Steps

Set Up the Environment
Configure the AI Core service plan and establish communication arrangements between the ABAP system and AI Core.
Build Custom Travel Plan ABAP Cloud application.
Create and Deploy Intelligent Scenarios
Define the AI scenario in ISLM, train or connect your model, and deploy it for consumption.
Consume Intelligent Scenarios in ABAP
Integrate the deployed scenario within a custom ABAP Cloud application to generate AI-driven outputs - in this case, travel itineraries and budget breakdown.

1. Set Up the Environment

Configure the required entitlements to make SAP AI Core accessible in your subaccount. To use Generative AI capabilities (including the Generative AI Hub and LLM access), choose the extended service plan. To add a Service Plan, see: Add a Service Plan | SAP Help Portal
Download the client default certificate of the ABAP system to create the X.509 service key in AI Core instance. Follow the steps here : Download Certificate | SAP Help Portal
Create a service instance and a service key to access SAP AI Core, where the large language models in the generative AI hub are hosted. The X.509 service key is created with the downloaded client default certificate of the ABAP system passed as parameter. Follow the steps from here: Create SAP BTP Service Instance and Key | SAP Help Portal
Configure the communication system for SAP_COM_0A69. Currently, you can create one instance of the communication scenario per client. Follow the steps from here: How to Configure the Communication System for SAP_COM_0A69 | SAP Help Portal
To create the Communication Arrangement for SAP_COM_0A69. Follow the steps from here: How to Create the Communication Arrangement for SAP_COM_0A69 | SAP Help Portal
After the communication system and communication arrangement are configured, create an intelligent scenario and continue managing the lifecycle of the intelligent scenario. You are required to create an intelligent scenario for your custom-owned Gen AI use cases.

2. Create a custom ABAP Cloud Application to infuse AI Capabilities

2.1 Create Package

In ABAP Development Tools (ADT), go to the Project Explorer, right-click on the package ZLOCAL, and select New → ABAP Package from the context menu.
Maintain the required information:
1. Name: ZTRAVEL_ITINERARY
2. Description: ABAP AI Capabilities
  Select the box Add to favorites package. Choose Next and Finish.

2.2 Create database table

Create a database table to store the Travel Itinerary data.

Right-click on your ABAP package ZTRAVEL_ITINERARY and select New → Other ABAP Repository Object from the context menu.
Search for database table, select it, and choose Next.
Maintain the required information: Name: ZRAP_TRAVEL_DATA Description: Database Table for Travel Itinerary
Choose Next. Choose Finish and replace the default code with the following code snippet:

@EndUserText.label : 'Database table for travel Itinerary'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #A
@AbapCatalog.dataMaintenance : #RESTRICTED
define table zrap_travel_data {
  key client            : abap.clnt not null;
  key travel_id         : sysuuid_x16 not null;
  traveler_name         : abap.char(80);
  starting_point        : abap.char(100);
  destination           : abap.char(100);
  start_date            : /dmo/begin_date;
  end_date              : /dmo/end_date;
  @Semantics.amount.currencyCode : 'zrap_travel_data.budget_curr'
  budget                : abap.curr(15,2);
  budget_curr           : abap.cuky;
  transport_mode        : abap.char(40);
  accommodation_type    : abap.char(50);
  ai_itinerary          : abap.sstring(1333);
  ai_budget_breakdown   : abap.sstring(1000);
  status                : abap.char(20);
  local_created_by      : abp_creation_user;
  local_created_at      : abp_creation_tstmpl;
  local_last_changed_by : abp_locinst_lastchange_user;
  local_last_changed_at : abp_locinst_lastchange_tstmpl;
  last_changed_at       : abp_lastchange_tstmpl;
}

5. Save and activate the changes in the table ZRAP_TRAVEL_DATA

2.3 Generate transactional UI service

Create your OData V4-based UI service with the built-in ADT generator. The generated business service will be transactional, draft-enabled, and enriched with UI semantics for the generation of the SAP Fiori elements app.

Right-click your database table ZRAP_TRAVEL_DATA and select Generate ABAP Repository Objects from the context menu.
Select OData UI Service and choose Next and provide the package details.
Maintain the required information on the Configure Generator dialog to provide the name of your data model and generate them.
For that, navigate through the wizard tree (Business Objects, Data Model, etc…), maintain the artefact names provided and choose Next.
Verify the maintained entries and choose Next to confirm and choose Finish.
The artifacts needed will be generated. Go to the Project Explorer, select your package ZRAP_TRAVEL_ITENERARY, refresh it by choosing F5, and check all generated ABAP repository objects.

ℹ️ NOTE: The names of the artifacts may differ from those shown in this blog post, as they are generated by the wizard.

2.4 Adjust meta data extensions
Open the metadata extension ZC_RAP_TRAVEL_DATA and make the adjustments as shown in the provided code snippet. ZC_RAP_TRAVEL_DATA should look like this:

@Metadata.layer: #CORE
@UI.headerInfo.title.type: #STANDARD
@UI.headerInfo.title.value: 'TravelID'
@UI.headerInfo.description.type: #STANDARD
@UI.headerInfo.description.value: 'TravelID'

annotate view ZC_RAP_TRAVEL_DATA with
{
  .facet: [
    { label: 'General Information', id: 'GeneralInfo', purpose: #STANDARD, position: 10, type: #IDENTIFICATION_REFERENCE },
    { label: 'AI Generated Itinerary', id: 'AIItineraryFacet', purpose: #STANDARD, position: 200, type: #FIELDGROUP_REFERENCE, targetQualifier: 'AI_ITIN' },
    { label: 'AI Budget Breakdown', id: 'AIBudgetFacet', purpose: #STANDARD, position: 210, type: #FIELDGROUP_REFERENCE, targetQualifier: 'AI_BUDGET' }
  ]

  @EndUserText.label: 'TravelID'
  .identification: [ { position: 10, label: 'TravelID' } ]
  .lineItem: [ { position: 10, label: 'TravelID' } ]
  .selectionField: [ { position: 10 } ]
  TravelID;

  @EndUserText.label: 'TravelerName'
  .identification: [ { position: 20, label: 'TravelerName' } ]
  .lineItem: [ { position: 20, label: 'TravelerName' } ]
  .selectionField: [ { position: 20 } ]
  TravelerName;

  @EndUserText.label: 'StartingPoint'
  .identification: [ { position: 30, label: 'StartingPoint' } ]
  .lineItem: [ { position: 30, label: 'StartingPoint' } ]
  .selectionField: [ { position: 30 } ]
  StartingPoint;

  @EndUserText.label: 'Destination'
  .identification: [ { position: 40, label: 'Destination' } ]
  .lineItem: [ { position: 40, label: 'Destination' } ]
  .selectionField: [ { position: 40 } ]
  Destination;

  .identification: [ { position: 50 } ]
  .lineItem: [ { position: 50 } ]
  .selectionField: [ { position: 50 } ]
  StartDate;

  .identification: [ { position: 60 } ]
  .lineItem: [ { position: 60 } ]
  .selectionField: [ { position: 60 } ]
  EndDate;

  @EndUserText.label: 'Budget'
  .identification: [ { position: 70, label: 'Budget' } ]
  .lineItem: [ { position: 70, label: 'Budget' } ]
  .selectionField: [ { position: 70 } ]
  Budget;

  @EndUserText.label: 'TransportMode'
  .identification: [ { position: 80, label: 'TransportMode' } ]
  .lineItem: [ { position: 80, label: 'TransportMode' } ]
  .selectionField: [ { position: 80 } ]
  TransportMode;

  @EndUserText.label: 'AccommodationType'
  .identification: [ { position: 90, label: 'AccommodationType' } ]
  .lineItem: [ { position: 90, label: 'AccommodationType' } ]
  .selectionField: [ { position: 90 } ]
  AccommodationType;


  // FULL-WIDTH AI ITINERARY
  @EndUserText.label: 'Generated Itinerary'
  .fieldGroup: [ { qualifier: 'AI_ITIN', position: 10, label: 'AI Generated Itinerary' } ]
  .multiLineText: true
  AiItinerary;


  // FULL-WIDTH AI BUDGET
  @EndUserText.label: 'Budget Breakdown'
  .fieldGroup: [ { qualifier: 'AI_BUDGET', position: 10, label: 'AI Budget Breakdown' } ]
  .multiLineText: true
  AiBudgetBreakdown;


  @EndUserText.label: 'Status'
  .identification: [ { position: 120, label: 'Status' } ]
  .lineItem: [ { position: 120, label: 'Status' } ]
  .selectionField: [ { position: 120 } ]
  Status;

   @EndUserText.label: '_BaseEntity'
  .identification: [ {
    position: 180 , 
    label: '_BaseEntity'
  } ]
  .lineItem: [ {
    position: 180 , 
    label: '_BaseEntity'
  } ]
  .selectionField: [ {
    position: 180 
  } ]
  _BaseEntity;

  

}

2.5 Preview travel app

1. Publish the local service endpoint of your service binding and start the Fiori elements App Preview. Open your service binding ZUI_RAP_TRAVEL_DATA_O4 and choose Publish.

2. Double-click on the Entity ZC_RAP_TRAVEL_DATA in the Entity Set and Association section to open the Fiori elements App Preview.

For reference: Create Database Table and Generate UI Service | SAP Tutorials

3. Create an Intelligent Scenario (Generative AI)

You first need to create an intelligent scenario for your custom Generative AI use cases. This scenario acts as the central place to manage the entire lifecycle of your AI asset from setup to generating inference results. All lifecycle steps can be executed through the Intelligent Scenario Management app. Here are the key steps to create an intelligent scenario:

3.1 Create ISLM Scenario
An intelligent scenario is an ABAP representation of a predictive business-specific use case. These intelligent scenarios are AI-powered workflows or processes designed to automate and optimize business tasks.

Select your package, right-click, New → Other → Intelligent Scenario → ZINTS_RAP120
Enter a name and description. Select SIDEBYSIDE for Scenario Technology field. Choose Next.
Set the following parameters for the created Intelligent Scenario.

Intelligent Scenario Lifecycle Management supports two primary types of intelligent scenarios:

Embedded Scenarios

Embedded scenarios are built and executed within SAP S/4HANA using the ABAP platform. They rely on the in-database machine learning capabilities of SAP HANA, such as: HANA Predictive Analysis Library (PAL), Automated Predictive Library (APL)

Side-by-Side Scenarios

Side-by-side scenarios, where SAP S/4HANA runs in a separate stack than its machine learning infrastructure provider, such as SAP Business Technology Platform (SAP BTP). These scenarios use external ML services or custom ML models.
Generative AI, SAP AI Core, Data Attribute Recommendation

For our scenario, we will be using the side by side scenarios type, sap SAPGEN AI
Turnkey Enablement: Automatically enable SAP-delivered (turnkey) GenAI use cases with minimal configuration effort.

Field	Value
Intelligent Scenario Type	SAPGENAI
Automate Turnkey Switch On	Check the checkbox
Usage Type	CUSTOMER

Activate the object.

3.2 Create ISLM Model

1. Select your package, right-click, New → Other → Intelligent Scenario Model

2. Fill the Description and Model Name fields. Assign the previously created scenario in Intelligent Scenario Name. Choose Next.

3. Enter the ExecutableID and Large Language Model Name and Large Language Model Version

Field	Possible values
Executable Id	o aicore-sap o aws-bedrock o azure-openai o gcp-vertexai
Large Language Model Name	It depends on the Executable Id
Large Language Model Version	One option is to leave the version field free, then the latest version will be used. This helps to avoid issues in case that the model has been deprecated in AI Core More info: https://me.sap.com/notes/3437766

4. Through the Prompt Library API, we can use predefined prompt templates to generate new prompts. Currently prompt templates are defined through ISLM. To get an instance of the prompt template you want to use, you need to provide the ISLM scenario and the ID of the prompt template. Click on Add and provide the following details:

Prompt Template Name: SYSTEM_PROMPT_ITIN
Prompt Template: System prompt for generating Itinerary
Prompt: You are a professional travel planner. Create a {ISLM_days} day itinerary for a given destination, including daily highlights, must-visit spots and activities. Keep it under 1000 characters.

5. The Prompt Parameters is captured from the prompt template after activation.

6. Add another prompt template for User prompt:

Prompt Template Name: USER_PROMPT_ITIN
Prompt Template: User prompt template
Prompt: Destination: {ISLM_destination} Departure: {ISLM_startingpoint} Travel Dates: {ISLM_startdate} to {ISLM_enddate} Mode of Transport: {ISLM_transportmode} Accommodation Type: {ISLM_accommodationtype} Generate the itinerary now

7. Activate the object
⚠ WARNING : Before you try the ABAP AI SDK out in an ABAP Class, please make sure that the deployment is running.

3.3 In Fiori Launchpad

To use the Intelligent Scenarios and Intelligent Scenario Management apps, you must have the appropriate access rights to the SAP Fiori Launchpad. The access for ISLM is added to the business role of an analytics specialist; BR_ANALYTICS_SPECIALIST.
You can create and manage ISLM Scenarios through Intelligent Scenario Management app.

You can check your previously created scenario in the Intelligent Scenario Management Fiori App.
In the next step instantiate ABAP AI SDK using the created ISLM Scenario

3.4. Consume Intelligent Scenarios in ABAP

ABAP AI SDK
The ABAP AI SDK powered by Intelligent Scenario Lifecycle Management (ISLM) is an ABAP reuse library that supports you in interacting with large language models (LLMs) hosted on the generative AI hub in SAP AI Core. Using the ABAP AI SDK, you can build your own AI-based features in ABAP.

Completion API
This API provides access to the completion API functionality of Large Language Models (LLMs), meaning that it uses an LLM to generate a text response from a prompt.

Prompt Library API
Using the prompt library API, you can use prompt templates predefined via ISLM to generate new prompts.

Catchable Exceptions
The execution of the completion API may cause an error, and therefore, CX_AIC_COMPLETION_API can be caught as a result. When the error is triggered by the LLM itself or by the AI service provider, CX_AIC_COMPLETION_API provides further information about the error.

Add a determination to the Travel Business Object and enhance it with the ABAP AI SDK powered by ISLM. Define the determination generateAIItinerary in the behavior definition ZR_RAP_TRAVEL_DATA and implement it in the behavior implementation class, aka behavior pool ZBP_R_RAP_TRAVEL_DATA.

1. Add the mandatory fields. Go to the Project Explorer and open your behaviour definition ZR_RAP_TRAVEL_DATA.

field ( readonly )
TravelID,
Status,
AiBudgetBreakdown,
AiItinerary,
LocalCreatedBy,
LocalCreatedAt,
LocalLastChangedBy,
LocalLastChangedAt,
LastChangedAt;

field ( mandatory : create )
TravelerName,
EndDate,
StartDate,
Budget,
AccommodationType,
StartingPoint,
TransportMode,
Destination;

determination generateAIItinerary on modify { create; }

Define the generateAIItinerary determination:

Save and activate the changes in ZR_RAP_TRAVEL_DATA.
Declare the required method in the behavior implementation class ZBP_RAP_TRAVEL_DATA using ADT Quick Fix Ctrl/Cmd + 1.
Save and activate the changes in ZBP_R_RAP_TRAVEL_DATA.
Let's implement the determination generateAIItinerary. In your implementation class ZBP_R_RAP_TRAVEL_DATA, in generateAIItinerary method implementation.
Replace the following code. Your code should look like this:

 METHOD generateAIItinerary.
    LOOP AT keys INTO DATA(ls_key).
      READ ENTITIES OF zr_rap_travel_data IN LOCAL MODE
      ENTITY ZrRapTravelData
      FIELDS ( destination startdate enddate transportmode accommodationtype     BudgetCurr ) WITH CORRESPONDING #( keys )
      RESULT DATA(lt_travel).
      LOOP AT lt_travel INTO DATA(ls_travel).
        DATA(days) = ls_travel-enddate - ls_travel-startdate + 1.
        DATA(itinerary) = ``.
        DATA(budget)    = ``.
        IF ls_travel-AiItinerary IS INITIAL OR ls_travel-AiBudgetBreakdown IS INITIAL.
          TRY.

*Calling the Prompt Library API.Through the Prompt Library API, we can use predefined prompt templates to generate new prompts.

              FINAL(sys_prompt_template_instance) =  cl_aic_islm_prompt_tpl_factory=>get( )->create_instance(
                                                   islm_scenario = 'ZINTS_RAP120' template_id = 'SYSTEM_PROMPT_ITIN' ).
              " Add a system prompt based on an ISLM prompt template with one parameter
              FINAL(sys_prompt) = sys_prompt_template_instance->get_prompt( parameters = VALUE #( ( name  = 'ISLM_days'    value = days  ) ) ).

              " Add a user prompt based on an ISLM prompt template with parameters
              FINAL(user_prompt_template_instance) =  cl_aic_islm_prompt_tpl_factory=>get( )->create_instance(
                                                  islm_scenario = 'ZINTS_RAP120' template_id = 'USER_PROMPT_ITIN' ).

              FINAL(user_prompt) = user_prompt_template_instance->get_prompt( parameters = VALUE #(
     ( name  = 'ISLM_startdate'
       value =  |{ ls_travel-startdate }| )
     ( name  = 'ISLM_enddate'
       value = |{ ls_travel-enddate }| )
         ( name  = 'ISLM_startingpoint'
       value = ls_travel-StartingPoint )
           ( name  = 'ISLM_destination'
       value = ls_travel-Destination )
     ( name  = 'ISLM_transportmode'
       value = ls_travel-transportMode )
        ( name  = 'ISLM_accommodationtype'
       value = ls_travel-accommodationtype )
   ) ) .




              FINAL(api_itin) = cl_aic_islm_compl_api_factory=>get( )->create_instance(
                                                      islm_scenario = 'ZINTS_RAP120' ).

*Set the LLM parameters
              FINAL(params) = api_itin->get_parameter_setter( ).
              params->set_maximum_tokens( 800 ).


              FINAL(msg_itin) = api_itin->create_message_container( ).
              msg_itin->set_system_role( sys_prompt ).
              msg_itin->add_user_message( user_prompt ).
              itinerary = api_itin->execute_for_messages( msg_itin )->get_completion( ).
            CATCH cx_aic_api_factory INTO DATA(lx_api_itin).
              itinerary = |AI instance creation failed for itinerary.|.
            CATCH cx_aic_completion_api INTO DATA(lx_comp_itin).
              itinerary = |AI completion call failed for itinerary.|.
          ENDTRY.
          IF itinerary IS NOT INITIAL.
            TRY.

* To pass prompts directly without prompt parameters
* Your ISLM scenario for itinerary

                DATA(system_prompt_budget) =
                  |You are a travel finance advisor. Based on the Itenary , destination, duration, | &&
                  |and total budget, estimate how much to allocate for travel, hotel, | &&
                  |food, sightseeing, and miscellaneous expenses. Output under 500 characters.|.
                DATA(user_prompt_budget) =
                  |Itenerary: { itinerary }| &&
                  |Departure: { ls_travel-StartingPoint }| &&
                 |Destination: { ls_travel-destination }| &&
                  |\nTravel Dates: { ls_travel-startdate } to { ls_travel-enddate }| &&
                  |\nTotal Budget: ₹{ ls_travel-Budget }| &&
                  |\nTotal Budget Currency: ₹{ ls_travel-BudgetCurr }| &&
                  |\nProvide a short, realistic breakdown.|.
                FINAL(api_budget) = cl_aic_islm_compl_api_factory=>get( )->create_instance(
                                                      islm_scenario = 'ZINTS_RAP120' ).
                " Your ISLM scenario for budget
                FINAL(msg_budget) = api_budget->create_message_container( ).
                msg_budget->set_system_role( system_prompt_budget ).
                msg_budget->add_user_message( user_prompt_budget ).
                budget = api_budget->execute_for_messages( msg_budget )->get_completion( ).
              CATCH cx_aic_api_factory INTO DATA(lx_api_budget).
                budget = |AI instance creation failed for budget.|.
              CATCH cx_aic_completion_api INTO DATA(lx_comp_budget).
                budget = |AI completion call failed for budget.|.
            ENDTRY.
          ENDIF.
          MODIFY ENTITIES OF zr_rap_travel_data  IN LOCAL MODE
            ENTITY ZrRapTravelData
           UPDATE FIELDS ( aiitinerary aibudgetbreakdown status )
            WITH VALUE #(
              ( %tky = ls_travel-%tky
                aiitinerary        = itinerary
                aibudgetbreakdown = budget
                status              = 'Generated' )
            ).
        ENDIF.
      ENDLOOP.
    ENDLOOP.

  ENDMETHOD.

Save and activate the changes in ZBP_R_RAP_TRAVEL_DATA.
Preview and test the enhanced Travel Itinerary App with Generative AI Capabilities.

For the latest updates, subscribe to the blog posts below :

ABAP AI - Chapter 2 - SAP Community
Introducing the Next Era of ABAP Development - SAP Community
Joule speaks ABAP! - SAP Community
From Legacy to AI-Powered: RISE Transformation Rev... - SAP Community

Happy Learning!

My Home in SAP BTP ABAP Environment

2026-01-28T10:41:54.700000+01:00

Good news – My Home is finally available with SAP BTP ABAP environment!

My Home is your personalized entry page that provides you with easy access to the business insights and applications you need to do your job with greater speed and agility. My Home for SAP BTP ABAP Environment lets you access and manage your favorite pages, your favorite apps, and your insights on any device. It follows a modular approach to meet the needs of different roles and builds on the functionality of the SAP Fiori launchpad using spaces and pages.

New Look and Feel

My Home will be set as default for newly provisioned and existing systems as of SAP BTP ABAP Environment 2602. Accordingly, this soon changes the appearance of the SAP Fiori launchpad for every user. So, look forward to the new look and feel!

However, the setting to disable My Home will still be available for administrators until the release upgrade SAP BTP ABAP environment 2608. Then, My Home will be the one and only entry page within SAP BTP ABAP environment.

My Home in SAP BTP ABAP environment

My Home Sections

My Home is divided into different sections. You can view your News, Pages, Apps, Insights Tiles, and Insights Cards on this page.

News

The News section keeps you updated on your company's latest news, or SAP BTP ABAP environment system news.

News section on My Home entry page

Pages

The Pages section provides you with quick access to your favorite or most used pages. You can manage the visibility of your pages and order them in a way that enhances your productivity.

Pages section on My Home entry page

Apps

The Apps section provides easy access to your favorite, most used, recently used, and recommended applications. The Apps section improves the discoverability of your applications. The Recommended tab offers app suggestions using SAP Business AI, based on your user-specific role assignment. You can add apps to the Favorites tab from your most used, recently used, and recommended applications. You can organize and categorize your favorite applications by using the grouping, ordering and color-coding functionality so you can access them even more efficiently.

Apps section on My Home entry page

Insights Tiles and Insights Cards

The Insights section allows you to manage and monitor your company’s activities. It shows critical business information through KPIs and micro charts. This section is broken into two sections: Insights Tiles and Insights Cards. Insights cards and tiles display dynamic content at a glance. They provide quick and easy access to the applications that can provide more detailed information.

Insights tiles offer analytical information, such as charts or KPIs. Insights cards are similar to Insights tiles but provide more detailed analytical information in the form of charts, tables or lists from supporting overview page-, list report-, and analytical list page-based applications. Thanks to this information, you can assess what is happening at any time and take action when needed. You can customize the Insights section to display information that enables you to do your job with speed and agility.

Insights section on My Home entry page

Make it Mine – Personalize My Home to Your Needs

Following the “Make it Mine” approach, you can personalize the entry page to hide or display specific sections as well as the content maintained within these sections. Another key feature is the ability to customize the layout of these sections. This personalization capability allows you to prioritize the information that is most important to you.

To personalize the entry page to your needs, choose My Home Settings from the dropdown menu of the respective sections. Here, you can customize the layout and configure the respective sections.

My Home Settings

We hope you enjoy working with My Home in SAP BTP ABAP environment and reap its benefits. You can look forward to more enhancements that will improve your My Home experience even further in future releases. Stay tuned for more updates!

Removal of Business Groups in SAP BTP ABAP Environment: Switching to Spaces and Pages

2026-01-28T11:58:43.178000+01:00

Recently, we announced My Home in SAP BTP ABAP environment.
My Home is your personalized entry page that provides you with easy access to the business insights and applications you need to do your job with greater speed and agility.

As a prerequisite for My Home, SAP Fiori launchpad spaces and pages need to be enabled.
The spaces mode was developed to offer more flexibility to influence the launchpad layout for specific user groups. Pages are assigned to users via spaces that are assigned to business roles. The business role defines which users see a specific space. By defining pages with meaningful sections, you can define in which order the apps are sorted on the page.

Switching to Spaces and Pages

Spaces and pages have been announced as the standard layout approach for structuring content in the SAP Fiori launchpad with SAP BTP ABAP environment 2302.
Consequently, the classic Fiori launchpad home page with business groups will be removed gradually until 2608 in favor of SAP Fiori launchpad spaces and pages.

Luckily, this is no news: The transition is going on for quite some time now, as spaces and pages are already the default in newly provisioned systems for several years.
The removal of groups will affect newly provisioned systems at first with 2602. Later, with 2605, the switch will take place for existing systems as well.

This means in detail:

With 2602, it is no longer possible to switch between spaces and pages and the classic Fiori launchpad home page with groups in newly provisioned systems.
With 2605, spaces and pages will be the default in existing systems as well. The option to switch to the classic home page with groups will still be available for end users if the administrator has enabled it in the Manage Launchpad Settings app.
With 2608, the option to switch to the classic FLP home page will be removed completely in production systems.

How to Prepare for the Transition

Good news: The transition is straightforward, but there are a few important points to note. Until now, users couldn’t create their own groups in the SAP BTP ABAP environment. They relied on SAP-delivered groups and personalized them by adding, removing, or renaming tiles.

SAP provides predefined spaces and pages with similarly structured content. SAP-delivered groups will be switched to these predefined spaces and pages. Important: user-level personalizations made to the previous groups will not be carried over and will be lost due to the switch. You will need to recreate personal adjustments after the transition.

To be as well prepared as possible, we recommend administrator to enable the switch to spaces and pages now to remain productive after the transition.

Here are our best practices for end users:

Plan the switch carefully and identify which adjustments are important to you.
Document your existing personalizations so you can rebuild them in spaces and pages.
Use SAP’s predefined spaces and pages as a starting point and tailor them to your workflow.

For Administrators: Summary of the Upcoming Changes

As part of the mentioned transition to spaces and pages, SAP will change the SAP Fiori launchpad settings in the Manage Launchpad Settings app for administrators accordingly over the next release upgrades:

With SAP BTP ABAP environment 2602:

The parameter SPACES is removed in newly provisioned systems.
The parameter SPACES_ENABLE_USER is removed in newly provisioned systems.
The parameter SPACES_CUSTOM_HOME is true (ON) as default for all existing and newly provisioned systems. The setting to disable My Home is still available. Since spaces and pages need to be enabled as a prerequisite for My Home, this needs to be manually activated for existing systems.

With SAP BTP ABAP environment 2605:

The parameter SPACES is true (ON) as default in existing systems.
The parameter SPACES_ENABLE_USER is false (OFF) as default in existing systems. The settings to enable switching between the classic FLP homepage and the spaces and pages layout is still available.

With SAP BTP ABAP environment 2608:

The parameter SPACES is removed.
The parameter SPACES_ENABLE_USER is removed.
The parameter SPACES_CUSTOM_HOME is removed.

Ultimately, there will be no option to switch back to groups or to enable toggling between spaces and pages and groups after the SAP BTP ABAP environment 2608 release upgrade. You must complete the transition to spaces and pages before the final, irreversible switch in production systems with the 2608 release upgrade.

We therefore invite all customers to begin transitioning now and proactively embrace this change.

SAP CodeJam Roadshow 2026 - Brazil edition 🇧🇷 (Kicking off in March and continuing in April)

2026-01-30T12:35:15.511000+01:00

Oi SAP Developers!

I've got some exciting news to share with you. The SAP CodeJam roadshow is coming back to Latin America! This time, we will do a special edition in Brazil. We will have many stops on the roadshow starting the 1st week of March, doing CodeJams as part of SAP Inside Tracks, organised by local community members, and then continuing in April. Also, we'll organise a couple of meet-ups as we've done in previous year. :-).

Keep an eye on this blog post as more events will be announced as part of the roadshow shortly

SAP CodeJam events and meetups part of the roadshow (Register Now!)

Below is a listing of the SAP CodeJam events and quedadas (meetups) on the roadshow schedule:

Dates	CodeJam topic	Location	Registration
2 Mar	Build AI services using the CAP and Generative AI Hub	Campinas, Brazil 🇧🇷	Link
3 Mar	Joule Studio: Create Joule Skills and Agents Without Coding	São Paulo, Brazil 🇧🇷 🇧🇷	Link
3 Mar	São Paulo meetup	São Paulo, Brazil 🇧🇷	Link
4 Mar	SAP Build: Create Event-Based Processes	São Paulo, Brazil 🇧🇷	Link
5 Mar	Getting started with Generative AI Hub on SAP AI Core	Rio de Janeiro, Brazil 🇧🇷	Link
13 Mar	Getting started with Generative AI Hub on SAP AI Core	Joinville, Brazil 🇧🇷	Link
14 Mar	SAP Inside Track - Joinville	Joinville, Brazil 🇧🇷	Link
20 Mar	Getting started with Generative AI Hub on SAP AI Core	Belo Horizonte, Brazil 🇧🇷	Link
21 Mar	SAP Inside Track - Belo Horizonte	Belo Horizonte, Brazil 🇧🇷	Link
6 Apr	Combine SAP CAP with SAP HANA Cloud to Create Full-Stack App	São Paulo, Brazil 🇧🇷	Link
7 Apr	ABAP AI: Capabilities in SAP Joule for Developers CodeJam	São Paulo, Brazil 🇧🇷	Link
8 Apr	ABAP AI: Capabilities in SAP Joule for Developers CodeJam	Londrina, Brazil 🇧🇷	Link
10 Apr	Getting started with Generative AI Hub on SAP AI Core	Curitiba, Brazil 🇧🇷	Link
10 Apr	SAP HANA Cloud for AI Applications: ML, Vectors, and Knowledge Graphs	Ribeirão Preto, Brazil 🇧🇷	Link
13 Apr	SAP HANA Cloud for AI Applications: ML, Vectors, and Knowledge Graphs	São Leopoldo, Brazil 🇧🇷	Link
14 Apr	Build code-based AI Agents on SAP BTP	São Leopoldo, Brazil 🇧🇷	Link
16 Apr	SAP HANA Cloud for AI Applications: ML, Vectors, and Knowledge Graphs	Recife, Brazil 🇧🇷	Link
17 Apr	Build code-based AI Agents on SAP BTP	Recife, Brazil 🇧🇷	Link

Make sure to register to secure your place. It is likely that the places available will go fast.

What if the CodeJam topics do not cover the SAP technology that you focus on? We've organised additional local meetups just to get together and have a chat. See you all somewhere in Brazil on the roadshow!

Updating records using Dialog Box in RAP

2026-02-03T07:30:32.746000+01:00

Description : In this blog, we implement a RAP-based solution to update existing records using a Dialog Box (popup) instead of navigating to a separate page.

In this scenario user need to update the records in list page itself instead of going of going to object page using a dialog box in RAP application

Step 1 : Create a Data base table

@EndUserText.label : 'DB table for Numbering' 
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE 
@AbapCatalog.tableCategory : #TRANSPARENT 
@AbapCatalog.deliveryClass : #A 
@AbapCatalog.dataMaintenance : #RESTRICTED 
define table zfa_dt_num { 
key managed_num : sysuuid_x16 not null; 
key unmanged_id : char10 not null; 
name : char10; 
age : char2; 
attendance_status : char10; 
lastchangedat : abp_locinst_lastchange_tstmpl; 
}

Step2 : create a interface view and projection view upon data base

Interface View

@AbapCatalog.viewEnhancementCategory: [#NONE] 
@AccessControl.authorizationCheck: #NOT_REQUIRED 
@EndUserText.label: 'interface view for numbering' 
@Metadata.ignorePropagatedAnnotations: true 
define root view entity zi_zfa_num as select from zfa_dt_num 
{ 
key managed_num as ManagedNum, 
key unmanged_id as UnmangedId,
name as Name, 
age as Age, 
attendance_status as AttendanceStatus, 
@Semantics.systemDateTime.localInstanceLastChangedAt: true 
lastchangedat as LastChangeAt 
}

Projection View

@AccessControl.authorizationCheck: #NOT_REQUIRED 
@EndUserText.label: 'Projection view num' 
@Metadata.ignorePropagatedAnnotations: true 
@Metadata.allowExtensions: true 
define root view entity zc_zfa_num 
as projection on zi_zfa_num  
{ 
key ManagedNum, 
key UnmangedId, 
Name, 
Age, 
AttendanceStatus, 
@Semantics.systemDateTime.localInstanceLastChangedAt: true 
LastChangeAt

Step3 : create a behavior definition for both interface view and projection view

Interface View Behavior definition

managed implementation in class zbp_i_zfa_num unique; 
strict ( 2 ); 
define behavior for zi_zfa_num //alias <alias_name> 
persistent table zfa_dt_num 
lock master 
authorization master ( instance ) 
etag master LastChangeAt 
late numbering 
{ 
action Updateatt parameter za_zfa_num result[1] $self; 
create ( authorization : global ); 
update; 
delete; 
field ( readonly ) ManagedNum , UnmangedId; 
mapping for zfa_dt_num{ 
ManagedNum = managed_num; 
UnmangedId = unmanged_id; 
Name = name; 
Age = age; 
AttendanceStatus = attendance_status; 
LastChangeAt = lastchangedat; 
} 
}

Projection view Behavior defination

projection; 
strict ( 2 ); 
define behavior for zc_zfa_num //alias <alias_name> 
use etag 
{ 
use create; 
use delete; 
use action Updateatt; 
}

Step4 : implement the behavior pool class

CLASS lhc_zi_zfa_num DEFINITION INHERITING FROM cl_abap_behavior_handler. 
PRIVATE SECTION. 

METHODS get_instance_authorizations FOR INSTANCE AUTHORIZATION 
IMPORTING keys REQUEST requested_authorizations FOR zi_zfa_num RESULT result.  

METHODS get_global_authorizations FOR GLOBAL AUTHORIZATION 
IMPORTING REQUEST requested_authorizations FOR zi_zfa_num RESULT result. 

METHODS updateatt FOR MODIFY 
IMPORTING keys FOR ACTION zi_zfa_num~updateatt RESULT result.  

ENDCLASS. 

CLASS lhc_zi_zfa_num IMPLEMENTATION.
 
METHOD get_instance_authorizations. 
ENDMETHOD. 

METHOD get_global_authorizations. 
ENDMETHOD.

METHOD Updateatt.
 
data(lt_keys) = keys. 
read eNTITIES OF zi_zfa_num in LOCAL MODE 
ENTITY zi_zfa_num 
fiELDS ( AttendanceStatus Name Age ) wiTH corRESPONDING #( keys ) 
reSULT data(lt_res). 
data(lv_new_status) = lt_keys[ 1 ]-%param-attendance_status. 
data(lv_new_Name) = lt_keys[ 1 ]-%param-name. 
data(lv_new_age) = lt_keys[ 1 ]-%param-age. 
modIFY enTITIES OF zi_zfa_num in LOCAL MODE 
entity zi_zfa_num 
uPDATE fiELDS ( AttendanceStatus Name Age ) 
wITH vaLUE #( ( 
%tky = lt_res[ 1 ]-%tky 
AttendanceStatus = lv_new_status 
Name = lv_new_name 
age = lv_new_age  
) ). 

read eNTITIES OF zi_zfa_num in LOCAL MODE 
ENTITY zi_zfa_num 
all fiELDS wiTH corRESPONDING #( keys ) 
reSULT data(lt_res1). 
result = value #( 
for <lfs_num> in lt_res1 ( 
%tky = <lfs_num>-%tky 
%param = <lfs_num> 
)
). 

ENDMETHOD. 

ENDCLASS.
 
CLASS lsc_ZI_ZFA_NUM DEFINITION INHERITING FROM cl_abap_behavior_saver.
PROTECTED SECTION. 

METHODS adjust_numbers REDEFINITION. 

METHODS cleanup_finalize REDEFINITION. 

ENDCLASS. 

CLASS lsc_ZI_ZFA_NUM IMPLEMENTATION. 

METHOD adjust_numbers. 
DATA(lt_managedid) = cl_uuid_factory=>create_system_uuid( )->create_uuid_x16( ).  
SELECT MAX( unmanged_id ) FROM zfa_dt_num INTO (lv_num).
IF sy-subrc = 0. 
lv_num += 1 . 
ELSE. 
lv_num = 000000001 . 
ENDIF. 
LOOP AT mapped-zi_zfa_num REFERENCE INTO DATA(ls_num). 
ls_num->ManagedNum = lt_managedid. 
ls_num->UnmangedId = lv_num. 
ENDLOOP. 

ENDMETHOD. 

METHOD cleanup_finalize. 

ENDMETHOD. 

ENDCLASS.

Step 5 : For achieving the Dialog box we have to make use of a abstract entity , in this abstract entity declare the fields which you have to update

@EndUserText.label: 'Abstract entity for numbering' 
@Metadata.allowExtensions: true 
define abstract entity za_zfa_num 
// with parameters parameter_name : parameter_type 
{ 
name : char10; 
age : char2; 
attendance_status : char10; 
}

Step 6 : create a metadata for this abstract entity

@Metadata.layer: #CORE 
annotate entity za_zfa_num with 
{ 
@EndUserText.label: ' Update Name' 
name; 
@EndUserText.label: ' Update Age' 
age; 
@EndUserText.label: 'Set Student Status' 
attendance_status; 
}

Step7 : now for displaying the popup we have to make use of custom actions , declare a actions with parameters , in parameter give the abstract entity name

Step8 : now implement the logic for updating the records in action method

METHOD Updateatt. 

data(lt_keys) = keys. 

read eNTITIES OF zi_zfa_num in LOCAL MODE 
ENTITY zi_zfa_num 
fiELDS ( AttendanceStatus Name Age ) wiTH corRESPONDING #( keys ) 
reSULT data(lt_res). 
data(lv_new_status) = lt_keys[ 1 ]-%param-attendance_status. 
data(lv_new_Name) = lt_keys[ 1 ]-%param-name. 
data(lv_new_age) = lt_keys[ 1 ]-%param-age. 

modIFY enTITIES OF zi_zfa_num in LOCAL MODE 
entity zi_zfa_num 
uPDATE fiELDS ( AttendanceStatus Name Age ) 
wITH vaLUE #( ( 
%tky = lt_res[ 1 ]-%tky 
AttendanceStatus = lv_new_status 
Name = lv_new_name 
age = lv_new_age 
) ). 

read eNTITIES OF zi_zfa_num in LOCAL MODE 
ENTITY zi_zfa_num 
all fiELDS wiTH corRESPONDING #( keys ) 
reSULT data(lt_res1). 
result = value #( 
for <lfs_num> in lt_res1 ( 
%tky = <lfs_num>-%tky 
%param = <lfs_num> 
)  
).

ENDMETHOD.

Step9 : Create a service definition and service binding for the projection view and expose it

Here we can see we have 2 records and a button is visible UPDATE RECORDS

Select the button and click on the update record action

Edit the records

Here you can see the records have been updated

Conclusion : Using a Dialog Box in RAP makes record updates faster and more user-friendly by keeping the user on the same screen while still following RAP’s behavior, validations, and transactional processing

Tweaks for RAP BO events addressing filtering (before send) and too small payload (callbacks needed)

2026-02-03T15:18:52.529000+01:00

Are you working on modernizing your SAP integrations, or looking for better ways to integrate with clean core compliance? But when you've looked at "Event Objects" from the SAP Business Accelerator Hub, you have found that it's not exactly matching your needs? Too many events are fired (can I filter?). The callback API is too time-consuming/unwanted. Or maybe you are simply interested in how ABAP RESTful Programming Model (RAP) Events work, how you can use and/or extend SAP Standard events?

In this blog I'll go through first some basic info and then start to showcase some tips / tweaks / workarounds you may or may not be aware about. Let's go.

1 ABAP RESTful Programming Model (RAP) Events Intro

I'll keep this very brief as the meat of this blog is to go into the nitty-gritty details. But, for the uninitiated, RAP BO events are events that have been built with the RAP framework which can easily integrate with event brokers, such as SAP Business Technology Platform's Event Mesh or Advanced Event Mesh. They are a sort of modern version of BTEs. You may refer to a previous blog of mine where I go into one full end-to-end example, showcasing how to find SAP standard events and then use them: Working with RAP BO Events end-to-end . The short version is that all events can be found on the SAP Business Accelerator Hub -> Your SAP Product -> Events.

2 Too many events are fired / I want to filter

This is probably one of the most common discussion points when I work with my customers. More often than not a "Created" or even more interestingly, a "Changed" event is simply fired too often for the actual integration needs. So what can we do here? In essence we have 3 main options:

Integration middleware handles filtering (= no changes in SAP system, use event as is)
1. This can be desirable if there are lots of receiving systems that need to receive information for a certain object, and maybe each of them would like to filter a little different. The middleware receives the event as it happens and can then handle the distribution accordingly. This way 1 single event could be the foundation of several functioning integrations (instead of several point-to-point integrations). The quote-on-quote downside to this is that you would of course increase the complexity in the middleware itself, but again if the same event benefits several receivers, this could be a good option.
Extend SAP standard event to include filtering fields (= extension development in your SAP system, use extended event, not standard)
1. This can be used if you know for sure you always want to filter out certain types of objects, that none of the integrated systems would want to be informed about. The quote-on-quote downside here is that we need to create an extension. Secondly, we first have to check if the SAP Standard RAP BO in question even allows behavior extensions. If not, we cannot use this option at all.
Use custom event in combination with SAP Standard event as a workaround (= custom development in your SAP system, use custom event, not standard)
1. Same as for the previous one, this option can be used if we know for a fact we always want to filter away certain objects. We can use this over the extend option, if for example the extension was not possible, or if the extension possibilities do not suffice (for example we need to add fields that are not easily associated in the RAP BO, or we need some complex logic and checking before we send an event)

As this blog focuses on RAP, I'll skip the first option and let the integration gurus tackle that one. Let's take a closer look at the other two...

2.1 Extend SAP standard event

If we found a suitable SAP standard RAP BO event and all we want is to add a few filter fields, we can do that with what is called Derived Events. Please refer to this page for details: Derived Business Events | SAP Help Portal

For my showcase I'll be using R_SalesOrderTP~Changed event. First of, we need to check if the behavior definition of the BO allows extensions. Open it and check for the word "extensible" somewhere at the beginning of the definition + on the entity which has the event (so we need two extensible).

If it's there, we can proceed. Next we can also check the event itself and the payload (if no parameter statement is written there, the payload is the key field(s) of the BO alone).

2.1.1 Create derived event payload with filter fields

Before we extend the behavior, we need a custom payload that includes our filter fields. Create a new data definition root entity and define your custom payload. For example:

@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Sales Ord. ext. event for derived event'
define root view entity ZP_SalesOrder_EventExt as select from I_SalesOrder
{
  key SalesOrder,
  .context.attribute: 'xsapordtype'
  SalesOrderType,
  .context.attribute: 'xsapslsorg'
  SalesOrganization,
  .context.attribute: 'xsapbillplc'
  _BillingPlan.BillingPlanCategory,
  DistributionChannel,
  OrganizationDivision,
  SoldToParty,
  CustomerGroup,
  ShippingCondition,
  IncotermsClassification,
  OverallSDProcessStatus
}

Few points:

Key fields must match the RAP BO you are extending
You can access fields just like the standard RAP BO and also associated fields (I showcase this with BillingPlanCategory above). Note, we focus only flat structures, so the associated field needs to be 1:1 (for deep structures, please refer to chapter 3).
With above, we created exactly 3 filter fields: Sales Order Type, Sales Organization, and Billing Plan Category. Filters must have the annotation "Event.context.attribute" and must start with "xsap"!

2.1.2 Extend standard RAP BO behavior to create a derived event (with our custom payload)

Now we are ready to extend the behavior definition as per usual practice: find/display it in the project explorer - right click - New Behavior Extension. Here type out your derived event, for example:

extension
//using interface i_salesordertp
;
extend behavior for SalesOrder {
  managed event ZZChangedExtended on Changed parameter ZP_SalesOrder_EventExt;
}

Few notes on the above:

First of I want to start with the interface commented away above. Bear with me, this is important to understand!
In RAP it is always best to interact with RAP BOs via their interface, if there is one (not to be confused with a basic interface view, such as I_SalesOrder or I_Customer etc., which reads from the DB table). In the case of R_SalesOrderTP, it has a transactional interface called I_SalesOrderTP. This interface is meant as a stable "API" to interact with the BO, and is usually released with C1/C0 contracts for clean core compliance. So in truth, we should be using the interface as we are extending this BO, but as you see above, it's commented away. That is because we must, in this case. I_SalesOrderTP does not include any of the events, and because we need those, we cannot use the interface in this case. What this means is that my extension behavior definition, as of right now, must be saved as "Standard ABAP" and cannot be assigned to a package with an ABAP Cloud software component. HOWEVER, this is clean core compliant, because R_SalesOrderTP is released with a C0 contract for extension, thus allowing such extensions. The problem is that the syntax check for ABAP for Cloud Development only checks for C1 contracts (which is missing on R_SalesOrderTP behavior), which is why, as of right now, we have to save this as Standard ABAP, meaning a "level B" extension which is clean core compliant (it would have been "level C", if R_SalesOrderTP hadn't had the C0).
The rest is quite straight forward. We say which entity we are extending (SalesOrder, using the alias in the behavior definition) and we are stating the Changed event to be extended with ZZChangedExtended with our own payload we previously created.

2.1.3 Create Event Binding for derived event

Next up we need an Event Binding for our derived event. As a small side note: if you only intend to consume your own derived within your SAP system (the same system) and not send it out to an event broker, then you would not need an event binding.
Create a new Event Binding object (Business Service - Event Binding or just search for event binding in the new ABAP object dialog) and add the event we just created to it:

Note that we of course refer to the SAP Standard RAP BO, which now includes our derived event thanks to the extension we just did.

2.1.4 Configure Event Channel to include your derived event

Lastly, to send our derived event to an event broker, we need to add it to our event channel. Assuming you already prepared an event channel (refer to my other blog linked above for more info on that), go to /n/IWXBE/CONFIG, select your event channel and go to Outbound Bindings.

Click the create button to add the event binding you just created. It could look something like this:

The above means that my Event Mesh on my BTP subaccount receives the SAP standard Sales Order Created event, and my own derived Sales Order Changed event.

And that's it: now we are ready for filtering or for simply getting the larger payload as per our derived event.

2.1.5 Adding Filters

In the same location as we were (/n/IWXBE/CONFIG -> Event Channel -> Outbound Bindings) click on the button Filters at the top. Open up the folder Outbound Bindings for your event channel and click on your derived event. Clicking on the plus-button shows all available filter fields, in this example:

Create a filter, for example that only Sales Order Type "OR" should be sent to out:

2.1.6 Subscribe to the event on your event broker

To receive this derived event for example in Event Mesh on SAP BTP, you need of course a corresponding queue and then add the subscription for this new derived event. In my example:

2.1.6 Test example

I changed a sales order in my system and saved. This now triggered my derived changed event, which I can see in the events monitoring transaction /n/IWXBE/EVENT_MONITOR (select event channel, click on Outbound Events, double-click on derived event)...

...and on SAP BTP Event Mesh where I added the subscription:

Here we can only see what's sitting in the queue. So let me consume the message in the test tool to show the same payload as in our monitor:

Awesome! We succeeded and this concludes the extend event option.

2.2 Use custom event in combination with SAP Standard event

This is an interesting one and in my experience comes with some confusion attached to it. I have heard sentences such as "But can't we just create a custom event instead of the standard one and use that?" And the simple answer to that is yes, but no 😊. Let me explain...

Now of course if we create our own, custom RAP BOs, we can add events to them. That is clear. And within that custom BO you decide when that event is fired. Clear and no problem. But this is all custom.

And now, if you want "your custom event" to be trigged during SAP standard processing, well no, SAP standard can't do that, as it does not know your custom event exists. And if you are thinking to use user exits or BAdIs to do this; think again, because it would be wrong to do so. User exits and BAdIs are called while the processing has not yet completed. Meaning at this point, in theory, something could still go wrong (no update in DB), but you already triggered your event. So, do not do this, ever! The point of the event framework is to inform about a state change. So you only want to do that, if the state change has actually occurred, meaning after the DB is fully updated.

So what else then, you wonder? That's where the SAP standard event comes in (which yes, is fired AFTER the state change occurred and all processing has completed). The SAP Standard event will trigger, and thus if you want more flexibility than just explored in the previous option with the extension of the SAP standard event, that's when we can try to combine standard with custom event.

Essentially, this is the pattern:

SAP standard process does something, which triggers an event for a certain object. This triggering happens at the exact time you want, but the SAP Standard event does not fulfill your requirement (and we can't / don't want to do a derived event)
You will create a custom event on a "dummy" RAP BO which includes the exact payload you need (flat structure for EM, it can be a deep one for AEM).
You will create a local event listener (within your SAP system) for the SAP standard event that triggers at the right moment. Within this local consumption you can now do any ABAP logic you may need. Complex filtering. Complex data collection (calling BAPIs or other things) etc.
Once all your data validation and collection is done, you fill the payload format of your custom event and finally you trigger your custom event (with a slight workaround, as events can only be raised from with the RAP BO itself)
You only configure your custom event in the event channel for the event broker. The event arriving there is ready to be consumed with all needed fields and only events are that are really expected are arriving there.

Let's do this example now. We stick with R_SalesOrderTP, this time using Created as the SAP Standard event.

Let's assume I don't just want to send all sales order that are created. Sales order type filtering is not good enough. In fact, it matters whether a product is sold that has certain characteristics, for example. As a simplified example here, I will only check the product type of the product, but hopefully this gives you some ideas; we could check anything at this point.

2.2.1 Create custom event

Our custom event doesn't need much of a BO. Meaning we don't want to (re)create read/update/delete etc. functionality, but this is purely for defining how the event payload should look like and for triggering the custom event.

In my example I took it a step further: what if I create a generic "event forwarder", that could potentially be used together with many SAP standard objects? Now, this isn't to say that I recommend this approach, in fact quite the opposite. And depending on your exact requirement, this may definitely the wrong approach. But I did this also in an effort to answer if this is at all feasible.

If having an event trigger with only key field information and then having a subsequent callback API later in the integration is a good pattern for you, then this could potentially help you, as you could reuse it for several use cases.

But, if instead you want something very specific, for example only forward my object under certain circumstances and including already all data needed, then of course it makes more sense to create a tailored custom event, with the exact payload of that object you want.

So please bear that in mind as we continue with this example. With this example I handle only a generic key-field based payload.

2.2.1.1 Custom entity data definition

We start of course with the data definition. Custom entity is in my opinion the best, as again we don't actually need any read or update functionality, but we simply describe our event payload at this point (and here you could have a large flat/deep structure):

@EndUserText.label: 'Event Forwarder BO'
define root custom entity ZR_EventForwarder
{
  key ObjectKey  : abap.string;
  key ObjectType : zevent_fwd_object;
}

2.2.1.2 Custom entity behavior definition

Next we need the behavior that will include our custom event:

unmanaged implementation in class zbp_r_eventforwarder unique;
strict ( 2 );

define behavior for ZR_EventForwarder
lock master
authorization master ( instance )
{
  field ( readonly ) ObjectKey, ObjectType;
  event ForwardEvent;
}

Finally, let ADT generate the BP implementation for you (we do not need to fill any of the methods but so it's properly created (again, we need no read/save methods etc.)). So I will not paste the whole Class/or Local Types.

Instead, what we need to do here is now offer an option to "raise" our custom event "ForwardEvent" from outside this BO. The "raise entity event" command is not allowed outside the RAP BO itself. So instead, we need to encapsulate it in a way that ABAP code from outside this behavior pool can call it. For this we need 2 things:

"Local event handler" (not actually inheriting anything => chose this to separate it from other, standard RAP BP behavior methods)
Method in the global class that can be called from other ABAP code

Let's start with the "local event handler". Within the section Local Types of your behavior implementation class, add something this:

class lcl_event_handler definition friends zbp_r_eventforwarder.
  public section.
    class-methods on_forward_event importing it_events type zbp_r_eventforwarder=>tt_events.
endclass.

class lcl_event_handler implementation.
  method on_forward_event.
    raise entity event zr_eventforwarder~forwardevent from it_events.

  endmethod.
endclass.

Note the "friends" command in the class definition. This is needed to be able to access private/protected class variables from the behavior pool (raising our entity event).

And in the Global Class, we change it as follow (full code copied):

class zbp_r_eventforwarder definition public abstract final for behavior of zr_eventforwarder.
  types tt_events type table for event zr_eventforwarder~forwardevent.

  public section.
    constants:
      co_type_salesorder    type zevent_fwd_object value 'SALESORDER'.
    class-methods raise_forward_event
      importing it_events   type tt_events.


endclass.

class zbp_r_eventforwarder implementation.
  method raise_forward_event.
    " tell RAP framework that we are in a SAVE sequence (otherwise it thinks
    " we are in the middle of a MODIFY)
    cl_abap_tx=>save( ).
    " trigger event (only allowed during SAVE)
    lcl_event_handler=>on_forward_event( it_events ).
  endmethod.
endclass.

We did 3 main things: a global type for the event payload table, a constant to distinguish different types of RAP BO that I mean to handle with my generic one (right now only one) and, most importantly, a global class method that can be called from other ABAP code.

2.2.1.3 Event Binding

As before, we need an event binding if we want to forward this to an event broker:

(Namespace, object type etc. can be freely chosen.)

And that's all for our custom event. Remember that the only purpose of this custom event is to offer a way to define the payload and to trigger it. Any functionality, such as filtering, complex validation or data selection etc. we do when the real SAP standard event is triggered. Meaning in the local consumption.

2.2.2 Local consumption of SAP Standard event

Now I won't go into step-by-step on this one, as I have done this already on the above linked blog post of mine. Please check there if the below steps are not enough for you.

I have an ABAP Class, abstract, final with the "for events of" functionality, where once again we must type R_SalesOrderTP here (and not I_SalesOrderTP, which would have been the preferred option). This means my class has to be again saved as "Standard ABAP" and cannot be in an ABAP for Cloud Development package. But this is clean core compliant, as explained above.

In Local Types I have my local class that inherits from cl_abap_behavior_event_handler and I add a method for the Created event:

class lcl_event_cons definition inheriting from cl_abap_behavior_event_handler.

  private section.
    methods:
      consume_created for entity event instances for salesorder~created.
endclass.

And here the implementation of that method (we'll go through it one by one below):

    data: lt_fwd_event  type zbp_r_eventforwarder=>tt_events.
    
    " go through RAP BO entity instances that triggerd the event
    " (should only be 1 as we listend to sales order (header) created)
    loop at instances into data(instance).
      " get data needed for complex filtering
      select salesorderitem, product, \_product-producttype
        from i_salesorderitem
        where salesorder = @instance-salesorder
        into table (lt_items).

      " check if sales order should be handled (forwarded to event broker)
      if line_exists( lt_items[ producttype = 'HAWA' ] ). 
        " this sales order is now filtered OK and will be added to the forwarding instances
        append initial line to lt_fwd_event assigning field-symbol(<fs_event>).
        <fs_event> = value #( objectkey  = instance-salesorder
                              objecttype = zbp_r_eventforwarder=>co_type_salesorder ).
      else.
        continue. " we are not interested in this Sales Order
      endif.
    endloop.

    " now that we checked all instances, only those that we filtered will be forwarded
    if lt_fwd_event is not initial.
      zbp_r_eventforwarder=>raise_forward_event( lt_fwd_event ).
    endif.

We create an internal table of the payload type that is the custom event (we created a global type in the behavior definition)
We loop through all instances that were sent by the SAP standard event (since this is a sales order (header), this will only ever include 1)
As we loop, we select some additional data to do "some complex logic" for checking if this sales order should be forwarded or filtered out.
Once all requirements are met for forwarding the sales order, we fill the custom event payload table.
When the looping is done, we check if any sales orders remained (if we have any custom event payload) and if yes, we now call the method we offered on the custom event RAP BO behavior as global class method and give it the payload we just filled.

And that's all 😲😀

2.2.3 Finishing

As before, we need to configure our custom event (binding) in the event channel in order to forward it to the event broker:

On the event broker, we need to subscribe to that topic, to receive it there:

To summarize, this is what will happen:

A user creates any sales order
R_SalesOrderTP-Created is triggered
Our local consumption of the SAP standard event is called: our local consumption checks if the sales order has any items with products of product type HAWA. If yes, we add it to be forwarded. If no, we disregard it.
If we had any sales order to forward, the ZR_EventForwarder behavior is called via workaround (a little bit nasty by just calling the global class but I could not think of any other way. For example we can't use an action, as actions are invoked via EML MODIFY, which in turn does not allow for RAISE EVENT). This triggers the ZR_EventForwarder-EventForwarded event with our payload
The custom event is forwarded to event broker

2.2.4 Testing

Let's test this. I create a new sales order and I include 1 item that has a product of type HAWA. Meaning my filtering will allow this sales order and eventually trigger my custom event.

Let's see what the event monitor says:

And consuming this message in BTP Event Mesh:

3 I want a larger payload

This is without a doubt the 2nd most discussed topic when talking event based integrations. In order to avoid callback APIs, maybe this is the way to go for you. As of right now, SAP Standard delivers notification events only, meaning small payloads to allow for the creation of fast, simple, integrations that can be easily reused.

You may already noticed that we already covered this in chapter 2. Both when extending the SAP standard event or when creating a custom event to work in combination with standard: I showcased how we can decide our own payload. So far I have only mentioned flat structures, as that is the only type that is supported by Event Mesh on SAP BTP. If you have a need for deep structure payloads, you may want to consider to upgrade to Advanced Event Mesh instead. And instead of creating a brand new example, please check out this blog post by a colleague that goes into deep payload: RAP Events with AEM 3 - Creating Events with deep payload.

Conclusion / Final Words

I hope this blog post helps and gives some ideas how far you can take RAP BO events and influence your integration landscape, in a positive way (of course, that's the end goal).

Is there anything I've missed? Another requirement that you would like to solve with eventing? Or any other questions or comments/feedback? Let me know in the comments and let's see 😊

ABAP AI Podcast: Reflecting on 2025 and Looking Ahead to 2026

2026-02-05T11:20:57.156000+01:00

2025: The Year ABAP AI Became Tangible

As Simona and I reflected on 2025, one theme stood out: it was the year ABAP AI stopped being a promise and became something developers could touch, use, and trust. That shift didn’t happen all at once — it was shaped across the year through a series of releases that progressively deepened what ABAP and AI could do together.

The journey began with Release 2502, our first big delivery, which marked a turning point for the ABAP developer experience. This release introduced the foundational AI capabilities that developers immediately felt in their workflow: the initial wave of explain ability for ABAP and CDS, predictive and context‑aware code suggestions, and early ABAP Cloud compliance insights. 2502 was a statement: ABAP AI had arrived, and it was ready for real use cases.

Building on this momentum, Release 2505 expanded and strengthened the story. the RAP BO Generator for Fiori applications. The explain model grew to cover more ABAP constructs, predictive assistance became more capable, and clean‑core compliance checks were enhanced to give developers clearer, more actionable guidance.

Toward the end of the year, Release 2508 brought refinement and specialization. AI guidance became more scenario‑aware — better tuned for migration, modernization, and, AI‑supported extensibility patterns. Autogenerated documentation became richer and more reliable. Custom code migration also received a boost with deeper AI‑powered insights and more intelligent documentation support — small but meaningful improvements that helped teams move faster and with more confidence.

And throughout all of this, we made sure customers in private cloud were not left behind. With the 2025 PCE add‑ins, Joule for Developers became available to S/4HANA Private Cloud Edition customers as well — enabling AI‑assisted custom code migration, modernization support, and clean‑core guidance even for those on older releases. This was a major step in democratizing ABAP AI and bringing its value to a much broader installed base.

Key Features and Developer Impact

With Joule for Developers, ABAP developers immediately benefited from a range of intelligent capabilities, including:

Predictive and context‑aware code suggestions
Automated ABAP Cloud compliance checks
Natural‑language explanations for both legacy and new ABAP code and extended explain use for autogenerated technical documentation
Developers could even generate complete Fiori applications simply by describing the functional requirements.

These advancements significantly accelerated development cycles and reduced manual effort. AI also enhanced custom code migration by proposing simplifications, improving code quality, and easing the transition to clean‑core architectures.

ABAP and AI: A Strengthened Relationship

Simona shared insights into why ABAP required SAP‑specific AI models. Because ABAP is proprietary, large language models were not initially trained on it. SAP addressed this by training internal models on over 250 million lines of ABAP code and 30 million lines of CDS views, unlocking high‑quality AI support tailored specifically to ABAP.

To hear the full conversation, listen to the episode: ABAP AI Podcast: Reflecting on 2025 and Looking Ahead to 2026

Another important point we touched on in the conversation is how ABAP AI brings together the best of both worlds. SAP pairs its own ABAP‑specialized models—trained on hundreds of millions of lines of ABAP and CDS code—with best‑of‑breed third‑party foundation models. This hybrid approach ensures developers always get the most accurate and context‑aware support for ABAP tasks, while still benefiting from the broad language understanding and creativity of large general‑purpose models. And for customers who are primarily interested in explain ability, SAP also offers the explain‑only model through the AI Hub, making ABAP‑focused code explanations accessible even without the full Joule for Developers experience.

Far from replacing developers, AI strengthens the ABAP ecosystem. The ABAP community has shown excitement and readiness to embrace these advancements, seeing AI as a powerful augmentation of their skills.

2026: Scaling the Promise

Looking forward, 2026 is shaping up to be a pivotal year of scaling ABAP AI. SAP plans to bring AI capabilities to customers running older private cloud releases through a side‑by‑side version of Joule for Developer, ensuring broader access also for customers on older S4HANA versions.

SAP will also add to it agentic tools and frameworks and an ABAP MCP Server, enabling SAP teams and partners to build intelligent agents that automate development tasks and connect seamlessly into an integrated agentic ecosystem. Investment in AI‑assisted custom code migration will continue, focusing on clean‑core compliance and automated code simplification proposals.

VS Code and Modern Tooling

A major priority for 2026 is establishing VS Code as a first‑class development environment for ABAP. By combining VS Code’s modern developer experience with Joule and AI‑centric capabilities, SAP aims to reposition ABAP as a future‑proof, cloud‑native, enterprise‑grade language.

Trust and Enterprise Readiness

As AI evolves, SAP continues to emphasize safety, compliance, and enterprise‑grade ethics. All AI use cases undergo rigorous validation to meet SAP’s security and trust standards.

Custom Code Migration (CCM)

A core focus area we highlighted in the podcast is the continued evolution of Custom Code Migration (CCM) and its central role in helping customers transition to clean‑core, cloud‑ready architectures. Throughout 2025, AI became a powerful companion in this journey — analyzing legacy patterns, identifying simplification opportunities, and guiding developers toward more future‑proof designs. With Joule for Developers, teams benefit from usage‑aware insights, automated refactoring suggestions, and richer technical documentation that dramatically reduces the manual effort usually tied to migration projects. As we move into 2026, CCM is set to scale even further, with deeper automation and more intelligent guidance that make modernization and S/4HANA transitions faster, more predictable, and far less error‑prone.

Conclusion

The year 2025 proved the real, tangible value of ABAP AI. In 2026, ABAP and AI will become inseparable—empowering developers with intelligent tools that make coding faster, smarter, and more reliable. The vision is clear: the future of ABAP development is deeply AI‑enhanced, enabling organizations to innovate with confidence and speed.

SAP Developer News, February 5th, 2026

2026-02-05T21:10:00.018000+01:00

DESCRIPTION

SAP Build Q4 2025 Release Highlights

https://community.sap.com/t5/tooling-sap-build-blog-posts/what-s-new-in-sap-build-q4-2025-release-highlights/bc-p/14316927

My Home in SAP BTP ABAP Environment

https://community.sap.com/t5/technology-blog-posts-by-sap/my-home-in-sap-btp-abap-environment/ba-p/14314918

Did You Know? #2 – Mocking Auth in CAP

Devtoberfest 2025 – Winners Announcement

https://community.sap.com/t5/devtoberfest-blog-posts/devtoberfest-2025-winners-announcement/ba-p/14320779

New live stream series and blog post series on CAP topics

Modules, modularity & reuse in CDS models (blog post series) https://qmacro.org/blog/posts/2026/01/01/modules-modularity-and-reuse-in-cds-models/
Hands-on SAP Dev CXL live stream series playlist https://www.youtube.com/playlist?list=PL6RpkC85SLQCEU8XcyqnA5wYEZGxMPm6B
A new Hands-on SAP Dev mini-series on the core expression language in CDS (blog post) https://qmacro.org/blog/posts/2025/12/09/a-new-hands-on-sap-dev-mini-series-on-the-core-expression-language-in-cds/
Constraints, expressions and axioms in action (blog post) https://qmacro.org/blog/posts/2026/01/27/constraints-expressions-and-axioms-in-action/

CHAPTER TITLES

0:00 Intro

0:10 SAP Build Q4 2025 Release Highlights

1:36 My Home in SAP BTP ABAP Environment

3:04 DYK #2 Mocking Auth in CAP

4:10 Devtoberfest 2025 – Winners Announcement

4:44 New live stream series and blog post series on CAP topics

Transcription

00;00;00;29 - 00;00;05;28
Announcer Guy
This is the SAP Developer News for February 5th, 2026.

00;00;06;00 - 00;00;09;25
Shrini Neelamegam
Q4 of 2025 was a huge season for SAP Build,

00;00;09;27 - 00;00;40;11
Shrini Neelamegam
and we have got some powerful new features to talk about. First up, the agent builder in Joule Studio is officially GA. With MCP server integration and the ability to link multiple agents together. You can now build production grade AI agents that actually moves the needle for your business. Plus, Joule is now baked into every edition of Work Zone, bringing context aware answers and proactive insights right to your team's fingertips.

00;00;40;13 - 00;01;07;17
Shrini Neelamegam
For the developers out there, you can now spin up Freestyle UI5 apps in SAP Build Code with a simple slash command. And if you are looking to automate, you have added new ways to trigger processes and build process automation, making it easier to bridge the gap between SAP and non SAP systems. On the design front end SAP mobile start just got a makeover with Apple's liquid glass look.

00;01;07;20 - 00;01;35;14
Shrini Neelamegam
And for the admins, Workzone sites can now handle thousands of documents and translations. We are just scratching the surface here. There is plenty more on decision tables, decision rules, HTML templates for notifications, and new CAPannotations. Head over to Frederick's latest blog post for full Q4 2025 release announcement.

00;01;35;17 - 00;02;07;13
Sheena M K
SAP has rolled out My Home, the new personalized, light entry page for the SAP BTP ABAP Environment. By default, from at least 2602, and it will be the one and only entry page from release 2608. My home is designed to boost productivity with a modular, customizable layout that includes key sections such as news pages, add and insights, and cards, all aimed at giving users quick access to the tools and information they interact with the most.

00;02;07;15 - 00;02;40;00
Sheena M K
While the new section keeps you updated with the latest company or system updates, beta section offers quick access to your most used or favorite pages. The apps section improves discoverability with favorite, recent and most used apps. Plus, AI powered recommendations based on role assignments via SAP Business AI. The inside 30s provide immediate visibility into KPIs and analytics and data, offering quick access to apps for further details.

00;02;40;03 - 00;03;06;08
Sheena M K
Following the “Make It Mine” approach, users can hide, reorder and restructure sections. The skew then working side across all devices. So start exploring my home for a clean, organized and smarter navigation for the SAP BTP ABAP Environment. And for details, check out the blog post from Laura in the description below.

00;03;06;10 - 00;03;33;19
DJ Adams
Did you know that CAP has a mocked authentication strategy you can use in local development? So you don't have to put off this important part of your domain design? Here's a simple service annotated with some auth requirements. Authentication is required generally, and there are some role based restrictions on one of the entities. With CDS watch we get this strategy out of the box, as we can see, along with some users and roles too.

00;03;33;21 - 00;04;01;05
DJ Adams
Here's Alice with the admin role. For example. Let's explore. How about trying to read the Book Stocks Entity? 401! We need to authenticate, of course. Let's authenticate as Alice. Now we have read access. What about write? 403. Nope. Alice doesn't have the requisite role. Let's fix that with some extra config in dot cdsrc dot Json, for example, which assigns her the back office role that's required.

00;04;01;08 - 00;04;09;21
DJ Adams
Okay, let's try again. Success output request as Alice is now accepted. Nice.

00;04;09;23 - 00;04;31;17
Kevin Kiedelsheimer
Hey, SAP Community, it's finally time! We have the full list of the ten Devtoberfest 2025 winners ready and online. You can find a link to the blog post down in the description of this video, so you can head over to the SAP community and see if you are one of the approved winners of last year's Devtoberfest.

00;04;31;20 - 00;04;42;27
Kevin Kiedelsheimer
And if you're one of the winners, you can look forward to a great fully paid trip to SAP TechEd this year. I can't wait to see you there!

00;04;43;00 - 00;05;21;13
DJ Adams
The developer advocates mission is to help developers. That's you be successful. To that end, we create lots of content in various forms CodeJam, tutorials, videos, talks, and lots more. We just wanted to highlight a couple of recent series in the CAP area. First, there's a blog post series on the topic of CDS modeling. The series is called Modules Modularity and Reuse in CDS models, and it explores how we can use modules for reuse in and across our projects and beyond.

00;05;21;15 - 00;05;53;15
DJ Adams
It illustrates this by first creating and publishing a simple passive reuse module before moving on to understand, explore and dig into the active Capire common reuse module. We're also running a series right now on our hands on SAP Devs live stream show. It's on CAP’s Expression Language, C XL, and we're very happy to have Patrice Bender from the Cap compiler team take us through the beautiful detail in this show and tell style series.

00;05;53;17 - 00;06;21;10
DJ Adams
As always, driven by curiosity and the desire to understand. By the way, there's also a related blog post just published that explains some of the amazing detail that Patrice revealed in showing how constraints are realized by pushing down to the database. This week sees the third livestream episode in this series. You can join live at the usual hands on SAP Dev time.

00;06;21;10 - 00;06;29;09
DJ Adams
It's Friday mornings in Europe, and of course you can always watch the replays at your leisure links in the description.

Triggering SAP Datasphere/BDC Task Chains from SAP BTP ABAP Cloud using the Task Chain REST API

2026-02-10T16:44:24.061000+01:00

Our modern data landscapes thrive on automation. In this post, we’ll walk end-to-end through a real-life integration scenario that tackles one of the building blocks in this context:

Starting a SAP Datasphere Task Chain remotely from SAP BTP ABAP Cloud using OAuth 2.0 Client Credentials and the Datasphere Task Chain REST API

The goal is to orchestrate Datasphere data processing flows directly from ABAP Cloud — securely, programmatically, and fully automated.

We will cover the below points:

Creating a Task Chain in Datasphere
Configuring OAuth clients in Datasphere
Setting up Communication System & Arrangement in ABAP Cloud
Executing the Task Chain remotely: Consume REST API from ABAP Cloud

1 Architecture Overview

Solution Architecture

ABAP Cloud Task Chain Execution: ABAP Cloud acts as the caller. Datasphere exposes the Task Chain API protected by OAuth.

2 Prerequisites

You must have:

SAP Datasphere tenant with developer + admin access
A Task Chain to trigger
SAP BTP ABAP Environment (ABAP Cloud) with developer access
BTP ABAP: Authorization to configure OAuth clients and Communication Arrangements

3 Creating a Task Chain in SAP Datasphere

The first step is defining a Task Chain that encapsulates the processing logic you want to execute remotely.

In the given example:

The Task Chain starts with a Begin node
Executes a Replication Flow for loading dimension data
(Can be extended with transformations, views, or further flows)

SAP Datasphere Task Chain with Replication Flow inside

Main takeaways:

Task Chain must be Deployed
Note the Technical Name (used later by API)
Verify it runs manually before you automate via the API

4 Configuring OAuth Client in SAP Datasphere

To allow ABAP Cloud to call Datasphere APIs securely, we create an OAuth Client in Datasphere Administration.

Navigation Path

Datasphere → Administration → App Integration → OAuth Clients

OAuth Endpoints Provided

Amongst others, SAP Datasphere automatically exposes:

Authorization URL
Token URL

These are required for OAuth2 token retrieval. Moreover you must create a technical user that has access to the Datasphere space and is able to run the task chains that are in scope. Typically this is done by assigning a scoped role.

Configured OAuth Client (based on Technical User)

Menu Path Datasphere

This is where you see the OAuth Client specific URLs - take note of them for later configuration in ABAP BTP:

OAuth Client Generation

Your specific OAuth client for consumption from ABAP BTP. The secret key is only shown once upon creation - keep this in mind!

OAuth Client Details

Important settings:

Parameter	Value
Grant Type	Client Credentials
Purpose	Technical User
Roles	space access must be given (e.g. by scope role in DSP)
Token Lifetime	e.g. 60 minutes

Save the Client ID and Client Secret — this is used in ABAP Cloud later on.

5 Creating Communication Artifacts in ABAP Cloud

Now we configure the outbound technical connection from ABAP Cloud to Datasphere.

First create an Outbound Service of type HTTP:

Create Outbound Service

Create a Communication Scenario with Authentication Methods = OAuth 2.0 only, bind it to your outbound service and publish it:

Communication Scenario Creation

Navigation: ABAP Environment Web Access → Communication Management → Communication Systems

ABAP Cloud Web Access

ABAP Cloud Communication Systems

The hostname is your Datasphere tenant URL. Outbound OAuth URLs (like Token/Authentication) can be found on the Datasphere side under Administration -> App Integration (previous step).

ABAP Cloud Communication Systems Details

You have to add a user "OAuth 2.0 (Basic)":

ABAP Cloud Communication Systems Users

Key fields:

Field	Example
System ID	DSP_REST
Host Name	<your-datasphere-host> (tenant URL)
Port	443
OAuth 2.0 Endpoints	From Datasphere for Token & Authorization URL (Audience URL not required)
Client ID	Datasphere OAuth Client ID
Client Secret	Datasphere Secret (you must take note of this when creating the OAuth Client)

6 Creating a Communication Arrangement in SAP ABAP Cloud

Now we bind the Communication System to a Communication Scenario that allows REST calls.

Navigation: Communication Management → Communication Arrangements

Arrangement Example: ZDSP_CS_REST

ABAP Cloud Communication Arrangements

Note the service path: The dynamic parts of the path are set from ABAP (this is to keep the space + task chain flexible and controllable from the actual caller: ABAP).

ABAP Cloud Communication Arrangements Detailed Configuration

What this provides:

Preconfigured service URL
OAuth token handling by ABAP runtime
Secure outbound API consumption

7 Calling the Datasphere Task Chain API from ABAP Cloud

Now comes the fun part: consuming the REST API. Datasphere exposes endpoints such as:

POST /api/v1/datasphere/tasks/chains/<space_id>/run/<task_chain_technical_name>
GET /api/v1/datasphere/tasks/logs/<space_id>/<log_id>

Which triggers a new execution or reads the status of a task chain run.

ABAP Cloud Implementation Pattern

In ABAP Cloud when working with REST API to integrate external services, you typically:

Create HTTP destination automatically from the created Communication Arrangement
Use CL_WEB_HTTP_CLIENT_MANAGER
Perform POST/GET requests
Parse response (run ID, status)

The code snippet performs the following parts in more detail:

Run as a class-run program (IF_OO_ADT_CLASSRUN) -> you can execute directly from ADT and print to the console.
Locate the configured Communication Arrangement (bound to our Communication System DSP_REST) using CL_COM_ARRANGEMENT_FACTORY.
Create an HTTP destination from the Communication Arrangement using CL_HTTP_DESTINATION_PROVIDER=>CREATE_BY_COMM_ARRANGEMENT.
Create an HTTP client from the destination (CL_WEB_HTTP_CLIENT_MANAGER).
POST request to the Task Chain “run” endpoint:

triggers a new run
receives a JSON response containing a LogId

WAIT a few seconds.
GET the log endpoint using the returned LogId:

retrieves the execution status (RUNNING, later SUCCESS / FAILED, etc.)

Print everything in the ABAP Console.

ABAP-Code Snippet:

CLASS zcl_dsp_rest_api DEFINITION PUBLIC FINAL CREATE PUBLIC.
   PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.

    CLASS-DATA:
      out TYPE REF TO if_oo_adt_classrun_out.
    CLASS-METHODS:
      call_dsp
        RAISING
          cx_http_dest_provider_error
          cx_web_http_client_error.
ENDCLASS.

CLASS zcl_dsp_rest_api IMPLEMENTATION.
  METHOD if_oo_adt_classrun~main.
    zcl_dsp_rest_api=>out = out.

    TRY.
        call_dsp( ).
      CATCH cx_web_http_client_error
            cx_http_dest_provider_error INTO DATA(exception).
        out->write( exception->get_text( ) ).
    ENDTRY.

  ENDMETHOD.

  METHOD call_dsp.

    TYPES: BEGIN OF ty_log,
             logId  TYPE i,
           END OF ty_log.

    DATA: ls_log TYPE ty_log.
    DATA(communication_system) = 'DSP_REST'.
    DATA(arrangement_factory) = cl_com_arrangement_factory=>create_instance( ).

    DATA(comm_arrangement_range) = VALUE if_com_arrangement_factory=>ty_query-cs_id_range(
      ( sign = 'I' option = 'EQ' low = communication_system ) ).

    arrangement_factory->query_ca(
      EXPORTING
        is_query = VALUE #( cs_id_range = comm_arrangement_range )
      IMPORTING
        et_com_arrangement = DATA(arrangements) ).

    DATA(arrangement) = arrangements[ 1 ].

    DATA(destination) = cl_http_destination_provider=>create_by_comm_arrangement(
      comm_scenario  = 'ZDSP_CS_REST'
      service_id     = 'ZDSP_REST_SRV_REST'
      comm_system_id = arrangement->get_comm_system_id( ) ).

    DATA(http_client) = cl_web_http_client_manager=>create_by_http_destination( destination ).
    DATA(request) = http_client->get_http_request( ).
    request->set_uri_path( '/chains/BDCPOC/run/TC_DIM2_A001' ).

    DATA(response) = http_client->execute( if_web_http_client=>post ).

    CALL METHOD /ui2/cl_json=>deserialize
      EXPORTING
        json = response->get_text( )
      CHANGING
        data = ls_log.

    data(log_str) = CONV string( ls_log-logId ).
    out->write( 'Task Chain started. LogId created:' && log_str ).

    WAIT UP TO 10 SECONDS.

    CONCATENATE '/logs/BDCPOC/' log_str INTO DATA(uri).

    clear: request, response, http_client.
    http_client = cl_web_http_client_manager=>create_by_http_destination( destination ).
    request = http_client->get_http_request( ).
    request->set_uri_path( uri ).
    response = http_client->execute( if_web_http_client=>get ).
    out->write( 'Task Chain Log REST API - via GET - Task Chain Status:' && response->get_text( ) ).

  ENDMETHOD.
ENDCLASS.

Once triggered:

Datasphere creates a new Task Chain run
Execution can be monitored in Datasphere UI
API returns run ID and status

Follow-up calls can fetch:

Execution status
Logs
Completion result

8 Execution Results

ABAP Cloud Console Log: Results

The Task Chain in Datasphere is in Running status:

SAP Datasphere Task Chain Running Status

9 Conclusion/Outlook & Further aspects:

Overview of the major building blocks:

Capability	Result
Secure Auth	OAuth 2.0 Client Credentials
No hardcoded secrets	via Communication Arrangements/System
Remote orchestration	Creating an end-to-end orchestrated chain of tasks
Cloud-native ABAP	Using appropriate ABAP Class APIs
Datasphere automation	Using Task Chain API

Use Cases that the implementation enables:

Nightly batch orchestration
Event-driven data loads
Cross-system workflows (this was our ultimate focus)
CI/CD data pipelines
API-driven analytical data refresh

References

SAP Datasphere Task Chain API Documentation: https://api.sap.com/api/DatasphereTasks/overview
SAP Datasphere Task Chain Help Page: https://help.sap.com/docs/SAP_DATASPHERE/c8a54ee704e94e15926551293243fd1d/274f2736465c4c48a091c675880502a2.html?locale=en-US
ABAP Cloud - how to call external APIs: https://jacekw.dev/blog/2022/oauth-client-credentials-from-abap-cloud/

These are your main takeaways to further sharpen the solution:

Use short token lifetimes
Separate technical OAuth users
Monitor task runs via API from ABAP
Handle retries & failures in ABAP
Log run IDs for observability

If you have any aspects, comments and/or concerns, please raise them and let's discuss. I'm happy and proud that this article was written by at least 90% human and only 10% AI 🙂

A SAP BTP Kyma Encryption/Decryption Microservice for ALL Contexts (e.g. SAP Datasphere/BDC/ABAP)

2026-02-11T16:12:01.099000+01:00

G’day!

Warning: This is only for readers who are really interested in this subject 😍 The article is quite comprehensive and has got some cross-article links inside, that also need to be considered. Therefore: A lot of reading and a lot of hands-on + thinking if you want to rebuild the thing.

Below is the structure of this article:

1 Status Quo on En-/Decryption in BTP
2 Motivation
3 Fundamentals
4 Architecture
5 HDLFS Configuration
6 Insights into Python
7 Containerization & Deployment in Kyma
8 Achievements
9 More Scope
10 References

Let's begin:

1 Status Quo on En-/Decryption in BTP

When it comes to En-/Decryption on SAP BTP, there are a couple of pitfalls to be considered. The following roughly outlines the situation, platform and application-wise:

Individual applications (e.g. SAP Successfactors) got proprietary encryption/decryption mechanisms available. They are typically not reusable.
SAP Integration Suite has got PGP En-/Decryptor nodes available. However, it is not advisable to run large volume scenarios using this approach. It has been built for data sizes on the levels represented within message handling scenarios (I‘m not an expert therein, but I guess thats typically not in the area of GBs).
A policy/rule for data to remain encrypted until its landing into BTP: You face challenges to securely onboard large volume files containing sensitive data into BTP, because there is no out-of-the-box solution to keep them encrypted in motion and decrypt them at rest once available in BTP (and vice versa for an outbound flow).

The Challenge

2 Motivation

Due to the above limitations, we were eager to find an appropriate solution approach that first of all satifies our specific scenario, but can also be augmented to other contexts. This is why the following motivation arose:

Especially En-/Decryption for larger files on BTP side seems to be a missing piece in the puzzle.
Our ambition is to encapsulate such kind of mechanism centrally as a reusable service. Multiple kinds of contexts can be served, exposing this service: Applications, data flows & transformations etc. – in our context the consumer will be SAP Datasphere.
There is another consequence of finally being able to load decrypted large data sets into BTP. To be more precise: To onboard this data into SAP Datasphere to further process and transform, the fact that Base64 encoded data must be handled in our context too, why not also expose or incorporate columnar Base64 En-/Decoding into the microservice?
The intended solution is custom-built and must be managed individually. However, the baseline that will be set can be reused and adapted to various customer needs and application contexts.

3 Fundamentals

The following represent some fundamentals and success criteria we‘ve established for our solution:

Use HANA Data Lake Files (HDLFS) as a file store for inbound/outbound persistency
Implement the service as containerized Python code logic
Service capabilities must be controllable and schedulable within Kyma
Service can handle PGP encrypted files, but can also decrypt for outbound delivery
Service can decode Base64 columns for inbound source files
Service manages and cleans up directories and file in-/output on HDLFS
Service can handle files with sizes in GB range
Deploy service into a Kyma Cluster (Cloud Foundry? -> no, Memory/Sizing limitations)
Security: Facilitate simple and secure handling of all required secrets and certificates
Service not exposed via HTTP endpoints (this is kind of a contradiction to a true microservice, however this requirement applies in our context. Under "More Scope" you will find guidelines/directions how to enable HTTP based microservices)

4 Architecture

The following architectural components represent what we‘ve picked out for our solution:

Usage of HANA Data Lake Files (HDLFS) as a file store for inbound/outbound persistency
Use BTP Kyma for service runtime (Kyma deployed in the 2nd smallest T-Shirt size)
SAP Datasphere represents the persistency layer (DSP as a consumer is exchangeable but in our case relevant for the business scenario)
The other more general blue box "other BTP Solutions" indicates, that the service implementation on Kyma isn't necessary limited to SAP Datasphere only, but should be rather considered as something agnostic. This of course heavily depends how it is built and finally implemented.

BTP Solution Architecture Kyma Microservice

5 HDLFS Configuration

I strongly recommend to read the tutorial by Jason Hinsperger to familiarize yourself with the HDLFS REST API dependencies and the essential steps to spin up the instance. You must follow all the steps described therein.

Its important to note that the generated client key and client certificate is what you are about to use from python level. Moreover you should take note of the REST API endpoint. This is the endpoint you run all your requests against (you find it in HANA Cloud Central -> Instances -> HDLFS Instance -> "Files REST API Endpoint".).

To familiarize yourself in general with the HDLFS REST API documentation, you can use this link.

HDLFS REST API Endpoint

One essential detail I don't want to hide, is the IP whitelisting of the Kyma environment. In order to do that, navigate to the start page of your cluster dashboard. There is a section called "Cluster Overview --> Metadata". Copy the (typically three) IP listed there: "NAT Gateway IP Addresses".

Go to your HANA Cloud Central and navigate to your HDLFS instance. Click "Manage Configuration" and go to the section "Connections": If you have enabled the setting to only allow specific IP addresses, likewise maintain the ones of the Kyma Cluster that you previously copied:

HDLFS Configuration Connections

6 Insights into Python

The python coding part is split into several modules, which are all described in a detailed way further below:

Inbound processing
Outbound processing
Common functions
Crypto function for encryption/decryption

Python Modules Sketch

Inbound Module (1)

The inbound part scans a given datalake path for .gpg files, then decrypts each file locally in parallel using a configurable worker count. After decryption, it samples the CSV (semicolon-delimited), detects which columns contain base64-encoded data, and runs a transformation step to produce a cleaned output file. The transformed result is uploaded to a decrypted output path, and the original encrypted input is moved to an archive folder. It logs success or errors with timing details on file level and exits with a failure code if any file fails.

This code snippet describes the parallel processing of files:

    with ThreadPoolExecutor(max_workers=MAX_PARALLEL_JOBS) as exe:
        futs = {exe.submit(processFile, f): f for f in files}
        for fut in as_completed(futs):
            f = futs[fut]
            try:
                res = fut.result()
                ok += 1
                print(f"[OK] {res['input']} -> {res['output']} sec={res['sec']:.2f} base64_cols={res['base64_cols']}")
            except Exception as ex:
                err.append((f, str(ex)))
                print(f"[ERR] {f}: {ex}")

Sampel code of processing an individual file:

def processFile(file_name: str):
    t0 = timer()
    out_name = normalize_output_name(file_name)

    with tempfile.TemporaryDirectory() as td:
        enc_path = os.path.join(td, file_name)
        dec_path = os.path.join(td, out_name + ".decrypted.csv")
        out_path = os.path.join(td, out_name)

        download_to_file(f"{PATH_IN_DATALAKE}/{file_name}", enc_path)
        decrypt_symmetric(enc_path, dec_path)

        header, sample = sample_csv(dec_path, delimiter=";")
        base64_cols = detect_base64_columns(out_name, header, sample)

        transform_csv(dec_path, out_path, base64_cols, delimiter=";")

        mkdirs(PATH_OUT_DATALAKE)
        upload_file_chunked(f"{PATH_OUT_DATALAKE}/{out_name}", out_path)

    mkdirs(PATH_ARCHIVE)
    rename(f"{PATH_IN_DATALAKE}/{file_name}", f"{PATH_ARCHIVE}/{file_name}")

    return {"input": file_name, "output": out_name, "base64_cols": base64_cols, "sec": timer() - t0}

Outbound module (2)

It scans the HDLFS outbound folder for .csv files and subdirectories containing Parquet parts, then processes them in parallel using a configurable worker count. CSV files are downloaded locally, then encrypted and uploaded back again to an encrypted outbound path. The originals are moved to an archive folder. Parquet file based directories on HDLFS (when enabled) are downloaded, consolidated into a single CSV using PyArrow, encrypted and uploaded similarly. As a last step, they are marked with an _SUCCESS file to prevent reprocessing and moved to the archive.

Crypto Module (3)

It provides helper functions for symmetric file encryption and decryption using the gpg command-line tool with an AES-256 cipher. It requires a passphrase supplied via the PASSPHRASE environment variable (from a Kyma Secret). Both encrypt_symmetric and decrypt_symmetric execute GPG in batch mode through subprocess, capturing stdout/stderr and validating the return code.

The decrypt_symmetric function is implemented as follows:

def decrypt_symmetric(enc_path: str, dec_path: str):
    _require_passphrase()
    cmd = [
        "gpg", "--batch", "--yes",
        "--pinentry-mode", "loopback",
        "--passphrase", PASSPHRASE,
        "--output", dec_path,
        "--decrypt", enc_path
    ]
    r = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    if r.returncode != 0:
        raise RuntimeError(f"GPG decrypt failed: {r.stderr.decode('utf-8', 'replace')}")

Common Functions Module (4)

All major control variables are built using environment variables (defined as secrets in Kyma) for endpoint/container, TLS certificates, verification behavior, timeouts, retries, and chunk size.

In one function it builds a reusable SSL context. API requests are wrapped with exponential-backoff retries for transient HTTP statuses (e.g., 429/5xx) and network errors. It provides HDLFS related helpers to list files/directories, check existence, create directories, rename paths, download remote content to disk in chunks, and upload files.

The below part builds the SSL context to connect to HDLFS via its REST API:

def buildSSLContext() -> ssl.SSLContext:
    ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
    if os.path.exists(CRT_PATH) and os.path.exists(KEY_PATH):
        ctx.load_cert_chain(certfile=CRT_PATH, keyfile=KEY_PATH)

    if TLS_VERIFY:
        if CA_CERT_PATH:
            ctx.load_verify_locations(CA_CERT_PATH)
        else:
            ctx.load_default_certs()
        ctx.verify_mode = ssl.CERT_REQUIRED
        ctx.check_hostname = True
    else:
        ctx.check_hostname = False
        ctx.verify_mode = ssl.CERT_NONE

    return ctx

This part establishes a connection to the HDLFS REST API endpoint as defined in the environment variable FILES_REST_API:

def _conn():
    if not FILES_REST_API:
        raise RuntimeError("FILES_REST_API is empty (set env FILES_REST_API).")
    return http.client.HTTPSConnection(FILES_REST_API, timeout=HTTP_TIMEOUT, context=_SSL_CTX)

The below function represents the upload (HDLFS REST API PUT) of a file in streaming mode to an HDLFS directory:

def _put_to_location(location: str):
        url = urlparse(location)
        if u.scheme and u.netloc:
            host = url.netloc
            path = (url.path or "/") + (("?" + url.query) if url.query else "")
            conn = http.client.HTTPSConnection(host, timeout=HTTP_TIMEOUT, context=_SSL_CTX)
        else:
            path = location
            conn = _conn()

        try:
            conn.putrequest("PUT", path)
            conn.putheader("x-sap-filecontainer", CONTAINER)
            conn.putheader("Content-Type", "application/octet-stream")
            conn.putheader("Content-Length", str(size))
            conn.putheader("Connection", "close")
            conn.endheaders()

            with open(file_path, "rb") as f:
                while True:
                    chunk = f.read(CHUNK_SIZE)
                    if not chunk:
                        break
                    conn.send(chunk)

            r = conn.getresponse()
            data = r.read()
            status = r.status
            r.close()

            if status in _RETRYABLE_STATUSES:
                raise RetryableHttpError(f"PUT retryable: {status} {data[:200]!r}")
            if status not in (200, 201):
                raise RuntimeError(f"PUT failed {remote_path_no_leading_slash}: {status} {data[:200]!r}")
        finally:
            conn.close()

7 Containerization & Deployment in Kyma

I won't describe in detail, how the creation of a docker container is made step by step. I just provide some essentials + hints to guarantee that you succeed and don't stumble upon the same issues I had faced. The following prerequisites must be met in order to create a runnable docker container based on your Dockerfile + python code:

Local installation of docker (Docker Desktop)
Docker registry (e.g. GitHub Docker Registry) – this is from where the Pod pulls the docker image
kubectl cli
IDE such as Visual Studio code

For an overall procedure, including the part in Kyma, you can refer to this blog entry on SCN. I strongly recommend that you try to rebuild the example the author walks through first, BEFORE you tackle your actual project.

Recommendations out of my personal learnings:

Try to not create any Kyma artifacts via the UI, but rather define those within descriptor yaml files of the corresponding kinds (e.g. kind: Deployment or Service or APIRule).
!!! A minor but very important thing to consider when running the docker build command, run it as follows:

docker build . --tag ghcr.io/<github_user>/<git_repo_name>:latest --platform linux/amd64

The deployment.yaml in the blog specified above is based on three Kyma/K8S artifacts that are created: Deployment, Service + APIRule. Which kind of artifacts you actually require strongly depends on your python implementation and how your service/logic runs. In the event of a purely job schedule based execution of your processing logic, you don't need a service or APIRule artifact, of course. Instead, you'd only need a deployment of kind: CronJob. This will spin up all dependent artifacts implicitely. In a CronJob based deployment you will have to specify the following details in the yaml file: scheduling details (time, frequency, time zone), required volumes, container spec including secrets to pull image, container level: mounts & env variables, resource allocation.
A template for a CronJob based deployment can look like this:

apiVersion: batch/v1
kind: CronJob
metadata:
  name: <job_name>
  namespace: <kyma_namespace>
spec:
  suspend: false
  schedule: "* * * * *" 
  timeZone: "Europe/Berlin"

  jobTemplate:
    spec:
      backoffLimit: 3
      template:
        spec:
          restartPolicy: Never
          imagePullSecrets:
            - name: ghcr-pull-secret

          volumes:
            - name: gnupg-home
              emptyDir: {}

          initContainers:
            - name: init-gnupg
              image: busybox:1.36
              command: ["sh","-c","mkdir -p /tmp/gnupg && chmod 700 /tmp/gnupg"]
              volumeMounts:
                - name: gnupg-home
                  mountPath: /tmp/gnupg

              resources:
                requests:
                  cpu: "10m"
                  memory: "32Mi"
                limits:
                  cpu: "50m"
                  memory: "64Mi"

          containers:
            - name: inbound
              image: <container_registry_path>
              imagePullPolicy: Always
              command: [<custom_os_level_command_if_required>]
              volumeMounts:
                - name: gnupg-home
                  mountPath: /tmp/gnupg

              env:
                - name: KEY_PATH
                  value: "/keys/keyfile.key"
                - name: PASSPHRASE
                  valueFrom:
                    secretKeyRef:
                      name: kyma-secret
                      key: PASSPHRASE

              resources:
                requests:
                  cpu: "100m"
                  memory: "1Gi"
                limits:
                  cpu: "200m"
                  memory: "2Gi"

8 Achievements

The following functionality and service details were delivered:

The Python code was improved multiple times: Handling approx. 30 files in one go with a total of 10 GB in encrypted state could be accelerated to < 30 minutes of processing time
Cron Jobs in the Kyma cluster can be used to schedule individual services, e.g. inbound processing of files that reside in a specific folder on HDLFS
SAP Datasphere writes local tables via Replication Flows back into HDLFS, on which the outbound service performs encryption and marks the files to „collectible“

9 More Scope

...up to come soon. I will cover aspects how to further mature the microservice/python logic and moreover exemplify on HTTP based encryption/decryption service endpoints, exposed on the Kyma Cluster.

10 References

K8S/Kyma + Python SCN Blog

Getting Started with Data Lake Files HDLFSCLI

HDLFS REST API Guide

Thx...

...to my fellow colleagues at SAP who provides meaningful input and discussed about solution options. Furthermore I am especially grateful to our implementation partner who also supported, implemented and showed strong endurance in building up this scenario.

I hope you enjoyed reading this article and could have gained some deeper insights into what we did. If you have comments or suggestions of any kind, don't hesitate to comment and start-off a discussions with me and hopefully other SMEs.

yaai_cloud - ABAP AI tools Cloud version

2026-02-16T08:04:23.543000+01:00

yaai_cloud - ABAP AI tools Cloud version
Open-Source AI Tools for ABAP Developers

A few months after releasing the ABAP AI tools last year, I started working on a new version, created specifically for ABAP Cloud environments.

I decided to build a cloud version for a couple of reasons. First, for the challenge itself. I had no idea how far I could go in developing these tools, given the restrictions of the SAP BTP ABAP Trial Environment compared to an on‑premise system, where we can essentially do anything we want. Second, not everyone has access to an on‑premise ABAP system to install and experiment with these tools. Since AI tools can introduce security risks, we need to be careful not to expose sensitive data. And finally, this was a great opportunity to build something more complex in a SAP BTP ABAP environment and explore features that only exist in SAP BTP ABAP Environments.

So, let me introduce the ABAP AI tools Cloud version.

This new version comes with many more features and a different approach compared to the on‑premise version. The Cloud version was built with AI agent development as its primary focus, and all the tooling is designed to support ABAP developers in building and testing AI agents.

It also includes a library with a variety of tools for function calling, most of them related to ABAP development tasks and built on top of the XCO Library. These tools allow AI agents to create and maintain DDIC objects, messages, translations, classes, interfaces, and more.

The ABAP AI tools Cloud is organized into four packages:

ABAP AI tools Cloud - https://github.com/christianjianelli/yaai_cloud
ABAP AI tools Cloud Function Calling - https://github.com/christianjianelli/yaai_cloud_fc
ABAP AI tools Cloud REST API - https://github.com/christianjianelli/yaai_cloud_rest
ABAP AI tools Cloud Cockpit - https://github.com/christianjianelli/yaai_cloud_cockpit

The first package contains all the core objects that form the foundation of the ABAP AI tools Cloud.

The other packages provide additional resources and features, such as the function calling library and the Cockpit, which makes it easier to manage settings and test AI agents.

There is also a fifth package, yaai_cloud_examples (https://github.com/christianjianelli/yaai_cloud_examples), which, as the name suggests, contains examples of how to use the tools.

AI Agents Development using ABAP AI tools Cloud

AI agents need at least two fundamental things: guidance and tools.

To guide an AI agent, we provide system instructions that define its role, responsibilities, and how it should use the available tools.

For the agentic part, we need to supply tools that the AI agent can call so it can perform tasks in the system on our behalf.

In ABAP AI tools Cloud, there are basically two ways to develop AI agents.

The first is to manually set everything in the code, the model, its settings, the system instructions, the tools, and so on.

The second way is to configure an AI agent by assigning an LLM model, defining the model settings, configuring the system instructions markdown document, registering the tools available to the agent, and so on.

Let’s look at two coding examples to compare the two development options.

In this first example, everything is defined directly in the code.

CLASS zcl_aaic_example_fc_openai DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.

    INTERFACES if_oo_adt_classrun.

  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.

CLASS ZCL_AAIC_EXAMPLE_FC_OPENAI IMPLEMENTATION.

  METHOD if_oo_adt_classrun~main.

    DATA: l_api_key             TYPE string,
          l_message             TYPE string,
          l_system_instructions TYPE string.

    DATA(lo_aaic_conn) = NEW ycl_aaic_conn( i_api = yif_aaic_const=>c_openai ).

    lo_aaic_conn->set_api_key( i_api_key = l_api_key ).

    DATA(lo_aaic_db) = NEW ycl_aaic_db( i_api = yif_aaic_const=>c_openai ).

    DATA(lo_aaic_openai) = NEW ycl_aaic_openai( i_model = 'gpt-5'
                                                i_o_connection = lo_aaic_conn 
                                                i_o_persistence = lo_aaic_db ).

    l_system_instructions = |# Identity\n|.
    l_system_instructions = |{ l_system_instructions }You are a friendly and helpful math support assistant.\n|.
    l_system_instructions = |{ l_system_instructions }Your primary role is to assist users with mathematical questions and problems.\n|.
    l_system_instructions = |{ l_system_instructions }You must use the provided calculation tools to solve numerical problems, ensuring accuracy.\n|.
    l_system_instructions = |{ l_system_instructions }Never do the calculations yourself. Always use the provided tools instead, respecting the results returned.\n|.
    l_system_instructions = |{ l_system_instructions }Call one tool at a time. You must wait for the result from one tool before making any subsequent tool calls.\n|.
    l_system_instructions = |{ l_system_instructions }Never send multiple tool calls at once.\n|.
    l_system_instructions = |{ l_system_instructions }Always be patient, encouraging, and explain your steps in a clear and understandable way.\n|.

    lo_aaic_openai->set_system_instructions( l_system_instructions ).

    DATA(lo_function_calling) = NEW ycl_aaic_func_call_openai( ).

    lo_function_calling->add_methods( VALUE #( ( class_name = 'zcl_aaic_math_tools'
                                                 method_name = 'add'
                                                 description = 'Use this method to add two numbers (i_num1 + i_num2)' )

                                               ( class_name = 'zcl_aaic_math_tools'
                                                 method_name = 'subtract'
                                                 description = 'Use this method to subtract two numbers (i_num1 - i_num2)' )

                                               ( class_name = 'zcl_aaic_math_tools'
                                                 method_name = 'multiply'
                                                 description = 'Use this method to multiply two numbers (i_num1 * i_num2)' )

                                               ( class_name = 'zcl_aaic_math_tools'
                                                 method_name = 'divide'
                                                 description = 'Use this method to divide two numbers (i_num1 / i_num2)' ) ) ).

    lo_aaic_openai->bind_tools( lo_function_calling ).

    l_message = 'Hi there! What is the result of 5 + 7?'.

    lo_aaic_openai->chat(
      EXPORTING
        i_message    = l_message
      IMPORTING
        e_t_response = DATA(lt_response)
    ).

    out->write( lt_response ).

  ENDMETHOD.

ENDCLASS.

In the second example, we make use of a configured AI agent.

CLASS zcl_aaic_example_openai_agent DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.

    INTERFACES if_oo_adt_classrun.

  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.

CLASS ZCL_AAIC_EXAMPLE_OPENAI_AGENT IMPLEMENTATION.

  METHOD if_oo_adt_classrun~main.

    DATA: l_api_key TYPE string,
          l_message TYPE string.

    DATA(lo_aaic_conn) = NEW ycl_aaic_conn( i_api = yif_aaic_const=>c_openai ).

    lo_aaic_conn->set_api_key( i_api_key = l_api_key ).

    DATA(lo_aaic_db) = NEW ycl_aaic_db( i_api = yif_aaic_const=>c_openai ).

    DATA(lo_agent) = NEW ycl_aaic_agent(
      i_agent_id = CONV #( 'C6111BEC04B71FE0B9DFCCB09425F70E' ) "Replace the agent id with your agent id
      i_chat_id  = lo_aaic_db->m_id
    ).

    DATA(lo_aaic_openai) = NEW ycl_aaic_openai( i_model = 'gpt-5-nano'
                                                i_o_connection = lo_aaic_conn
                                                i_o_persistence = lo_aaic_db
                                                i_o_agent = lo_agent ).

    l_message = 'What data elements does the package yaai_cloud contain?'.

    lo_aaic_openai->chat(
      EXPORTING
        i_message    = l_message
      IMPORTING
        e_t_response = DATA(lt_response)
    ).

    out->write( lt_response ).

  ENDMETHOD.

ENDCLASS.

ABAP AI tools Cloud Cockpit

Configuring an AI agent in ABAP AI tools Cloud involves maintaining a bunch of database tables. To make this whole process easier, the ABAP AI tools Cloud Cockpit was built. It’s a frontend application designed to streamline the development of AI agents created with ABAP AI tools Cloud.

ABAP AI tools Cloud Cockpit Main Features

Configuration

Setup of LLM APIs
Setup of tools for function calling
Setup of documents for RAG (Retrieval Augmented Generation)
Setup of AI agents

Testing and Monitoring

Integrated Chat
Chat Monitoring
System Logs
Background Task Monitoring

Configuring AI Agents

The configuration of AI agents in the Cockpit is a simple process that basically consists of the following steps:

Register the tools (function calling).>
Upload the markdown file containing the system instructions.
Create the agent and assign the system instructions.
Assign the tools you want the AI agent to have access to.
Set the LLM model and its parameters.

In the tools section we register the tools.

In the documents section, we can upload and edit markdown documents.

Once we have the tools registered and the system instructions uploaded, we can proceed with the agent creation and configuration, which is done in the Agents section.

Testing AI Agents

But the ABAP AI tools Cloud Cockpit is really helpful when it comes to testing AI agents. Once we’ve developed all the tools the agent needs, defined the system instructions, and added any extra documentation it may require to accomplish its tasks, we don’t need to jump straight into writing code to test and debug it. Instead, we can use the testing tooling available in the cockpit.

The ABAP AI tools Cloud Cockpit comes with some handy features that make testing and analyzing an AI agent’s execution much easier and much faster.

Integrated Chat

The Cockpit includes an integrated chat on the right side, which we can use to test the AI agent.

Chat Monitoring

In the chat monitoring view, we can see all the messages exchanged with the AI agent, including the tool calls and their corresponding responses.

Another really useful feature is the message sequence diagram, where we can visualize the entire conversation flow, including the tools that were called and the exact order in which they were triggered.

And last but not least, there is the system log, which can be extremely helpful when things go wrong, like communication errors or unexpected behavior.

Built‑in Tools

The ABAP AI Tools Cloud core package yaai_cloud comes with a few built‑in tools that are bundled with the core components because of their importance. Their main goal is simple: keep the context window as small as possible.

Retrieval Augmented Generation (RAG) tools.

Class: ycl_aaic_rag_tools

Methods:

get_list_of_documents
get_documentation

Instead of relying on a vector database to retrieve documents (or chunks of documents), the strategy here is a bit different. The idea is to provide tools that the LLM can use to first fetch a list of all available documentation. From there, the LLM decides which documents it actually needs in order to perform the task it was instructed to execute.

Once it knows what it needs, it can request the specific documents using the corresponding tool. With this approach, we avoid loading unnecessary information into the context window, keeping it as small and focused as possible.

Function‑Calling Related Tools.

Class: ycl_aaic_func_call_tools

Methods:

get_available_tools
request_tools

These tools follow the same philosophy as the RAG tools. The goal is identical: keep the context window as small as possible.

Instead of loading the JSON schema of every available tool into the context window upfront, we let the LLM first retrieve a list of available tools. Then it can request only the ones it actually needs to perform its task. This avoids overloading the context window with information that might never be used and gives the model more control over what it pulls in.

Closing Thoughts

There’s still a lot more to cover about the ABAP AI tools Cloud, but I’ll save that for future blog posts.

The official documentation is available in the GitHub repositories. It’s still a work in progress, but I’m actively updating it and will do my best to complete it as soon as possible.

Thanks for reading, and I hope these tools help you have some fun building AI agents in ABAP Cloud.

ABAP AI tools Cloud is released under the MIT License.

Transport Developer Extensibility Artifacts in SAP Public Cloud

2026-02-17T09:04:00.881000+01:00

Transport Developer Extensibility Artifacts

Introduction:

In the SAP S/4HANA Public Cloud 3-System Landscape (3SL), developers often face challenges when transporting extensibility artifacts across environments. While the customizing tenant (client 100) is dedicated to configuration, the development tenant (client 080) is where ABAP coding and developer extensibility take place.

This blog aims to provide a high-level overview of how developer extensibility artifacts (such as custom CDS views and service bindings) can be moved upstream in the landscape.

It also highlights important restrictions, such as the absence of a transport path from ADT-created objects into the customizing tenant, and points to SAP Note 3324929 for further clarification. By walking through a practical example, we will explore the steps required to expose CDS views securely via OData services and ensure smooth integration with external systems.

To set the context, here’s a quick snapshot of the artifacts available through developer extensibility and key user extensibility.

Detailed Explanation:

When working with developer extensibility in SAP S/4HANA Public Cloud, one common requirement is to expose custom CDS views so they can be consumed by integration teams. However, due to technical restrictions in the cloud environment, you cannot directly publish an OData service from a CDS view using the @odata.publish: true annotation. Instead, the recommended approach is to expose the CDS view through a service binding.

Let’s walk through the process step by step. We begin in the development tenant (client 080).

Create a Custom CDS view in ADT
Create Service Definition to expose your CDS view
Create Service Binding – Select Binding type as per your need. In this example, OData V4 - Web API is selected
Publish your Service Binding
It will then generate an Inbound service
Security is a critical aspect here. To ensure that your OData service is protected, you must configure authentication, which forms the basis for secure external consumption.
To do this you need to create a Communication Scenario in Development tenant (Client 080)
In ADT, create a Communication Scenario.

Give this new Communication Scenario a name starting with "Z". e.g., ZSAP_COM_825
Add needed Inbound Service ID:

Click the Inbound configuration
Click the Add button
Click the Browse button
Select the S_PRIVILEGED_SQL1

Add Authorization Object:

Click the Authorization configuration
Click the Insert button
Search for SQL_VIEW
Select SQL_VIEW
Expand Authorization 0001

SQL_SCHEMA: The name of the Service Binding (exposed as a schema) that you want to grant access to
SQL_VIEW: Comma-separated list of all CDS view entities to which you want to grant access or * (if you want to allow access to all CDS view entities in the service definition)
SQL_VIEWOP: Choose at least one option

For Remote Tables → Choose SELECT

For Replication Flows → Choose REPLICATE

Click the Publish Locally button

You are all done from Development tenant (Client 080). The next stage takes place in the customizing tenant (client 100).

Create the Communication arrangement using the scenario delivered from 080
Open the Communication Arrangements APP.

Click the New button.
Search for the required scenario.
Click the required scenario.
Rename the Arrangement Name.
Click the Create button.

Configurate the Communication Arrangement

Select the Customer Communication system.
Record the API-URL. e.g., https://myXXXXXX-api.s4hana.cloud.sap

Click the Save button.

Congratulations 🎉🎉, you are all set now and ready to push your transport into upward environments. Now you can get CDS data from this API. You can test it from Postman and connect to this API using IS tools for example CPI.

Tip💡
If your Communication Scenario does not appear in client 100, then most likely you have not published it in Development tenant (client 080).

Additional information:

Why You can't See Communication Arrangements in the Export Software Collection App

SAP clearly states that:

The Export Software Collection app is used only for key‑user extensibility objects (custom CDS, custom fields, custom logic, custom business objects, UI changes, etc.)
Communication Arrangements are not part of key user extensibility; therefore, they don’t appear in software collections.

This is explained in the SAP 3‑System Landscape transport overview.

Object Type	Can appear in Software Collection?	Transport Method
Custom CDS (Key User)	Yes	Software Collection
Custom Business Objects	Yes	Software Collection
UI Flex Changes	Yes	Software Collection
Custom Communication Scenarios (ADT)	No	Developer Transport
SQL Service Bindings (ADT)	No	Developer Transport

For this simple reason:

👉 Communication Arrangements do not appear in Software Collections
👉 Communication Arrangements do not move inside developer transports
👉 Communication Arrangements must be created manually in every system

SAP’s official help states Communication Arrangements must be configured through the Communication Arrangements app, per system.

Clean and Simple summary:

Object	Transportable	Moves Automatically?	Appears in TEST?	Action needed
Custom Communication Scenario (ADT)	Yes (developer transport)	Yes	Visible	Nothing
Communication Arrangement (client 100)	No	No	Not Visible	Should be created in each client

So, What Must You Do Now? (Correct Next Step)

In the TEST system, you must now manually recreate the Communication Arrangement:

Log in to TEST system
Open Communication Arrangements app
Click New
Select your transported scenario
Create the arrangement
Re-select:
Communication System
Communication User
Authentication method
Any inbound/outbound parameters
Save

Conclusion:

Transporting developer extensibility artifacts in SAP Public Cloud requires a clear understanding of what can and cannot be moved automatically. While custom CDS views, service definitions, and communication scenarios created in ADT are transportable through developer transports, communication arrangements remain system-specific and must be recreated manually in each environment. This distinction is crucial for ensuring secure and consistent integration across the landscape.

By following the outlined steps: creating CDS views, service bindings, and communication scenarios in the development tenant, then configuring communication arrangements in the customizing tenant, you can successfully expose your CDS data via OData services and make it consumable for integration tools like SAP CPI.

Ultimately, this process reinforces the importance of separating extensibility artifacts from environment-specific configurations, ensuring both flexibility and compliance in SAP’s cloud transport model.

Live Demos at the SAP BTP ABAP Environment Customer & Partner Roundtable – 03 March 2026

2026-02-17T09:22:16.939000+01:00

Join our next SAP BTP ABAP Environment Customer & Partner Roundtable on 03.03.2026 (10:00–11:00 CET)

Packed with live demos and product insights:

🔹Fiori Elements development with building blocks (Katrin Polloczek & Marcel Wächter)

🔹New My Home (Caroline Welsh)

🔹Product Updates (Frank Jentsch)

The roundtable is a monthly series taking place on the first Tuesday of every month (10:00–11:00 CET).

👉Download the .ics calendar file for the full 2026 series and import it directly into your calendar.
Each calendar entry already includes the Microsoft Teams meeting link.

Microsoft Teams meeting link (valid for the entire 2026 series): Microsoft Teams meeting link

All agendas, slides, recordings, and updates from past and current sessions are published centrally via the
SAP Community – SAP BTP ABAP Environment Customer & Partner Roundtable.

We’re looking forward to seeing you there!

Setting the right expectations around AI for code generation and getting past the inherent limits

2026-02-17T11:02:11.670000+01:00

With over two decades of working on AI, starting with my master's thesis on multi-layer perceptrons, I’m excited about the recent innovations in this area, especially as related to code generation. In this blog post, I want to share my perspective on using AI in a very specific context: coding with AI agents based on transformer models, as these are the primary tools we have at our disposal for this purpose today. I’ll start with why I use AI and then share some limitations of AI models and how to get around these pitfalls. Let’s start with a quick definition…

Generative AI is Only One Form of Artificial Intelligence

There's a lot of buzz around Artificial Intelligence (AI) these days, and it feels like every conversation about technology eventually lands on this topic. However, the term "AI" is often automatically conflated with "Generative AI" (GenAI). It's important to make a quick distinction. AI is the broad field of making machines smart. Machine Learning (ML) is a subset of AI that uses data to train models, and Deep Learning (DL) is a further subset of ML using neural networks. GenAI, which creates new content, is the latest evolution that has captured everyone's imagination.

Why I Use AI

AI is Practical

Large Language Models (LLMs) have provided us with an unprecedented natural language interface. This makes them incredibly powerful for tasks like web search and information retrieval, where a human can quickly verify the results. Coding is a domain where outputs are verifiable, which makes AI agents a significant efficiency booster. They aren't here to replace us, but to augment our abilities.

It's crucial to remember that LLMs have zero semantic understanding. They are masters of syntax, predicting the next word (or token) in a sequence through an auto-regressive process. They don't "understand" code; they predict what code should look like.

AI Adds Value to My Work

From my experience, AI brings tangible benefits to my development workflow. Here’s how:

Understanding Codebases: When jumping into a new or complex project, I use AI to get a quick summary of how different parts of the code interact.
Project Planning: Through agent orchestration, AI can help outline project structures, suggest potential components, and map out dependencies.
Code Documentation: This is a huge one. AI is exceptionally good at generating boilerplate documentation, docstrings, and comments, which frees me up to focus on the more complex descriptions.
Enforcing Guidelines: We can use AI to enforce Clean Core principles and other coding guidelines, ensuring that our code remains compliant and release-ready.

My History with AI

My journey with AI didn't start with the recent hype. It goes back to my college days, long before I entered the SAP ecosystem. My master's thesis was on multi-layer perceptrons and scaled conjugate gradient descent methods. Ever since then, I've been independently researching and following the advancements in this fascinating field.

Potential Pitfalls with AI and Take-aways

Differences Between Prompts and Target Language

Natural language is inherently ambiguous, imprecise, and often not concise. Science, and by extension software development, is about making formal, unambiguous statements. The greatest leaps in scientific history, like the formalization of algebra by Leibniz and Newton, came from moving away from rhetorical natural language and towards formal paradigms. The programming languages we use today are a natural evolution of this.

So-called "vibe coding," where one tries to build complex systems using only conversational language, is great for keynotes and simple examples but falls apart for enterprise-grade systems. I've seen attempts to "formalize" prompts to make agents more reliable, but this is a self-defeating exercise. You end up re-inventing a formal programming language, the very thing you were trying to avoid.

Take-away: This is a fundamental problem that won't be solved by simply scaling models. My practical advice is to iteratively update your agent's prompts and instructions as you code. Let the agent update its own instructions when it runs into issues. And most importantly: never commit code without verifying it yourself. Human experience is still an absolute necessity.

Predicting Syntax vs. Understanding Semantics

As mentioned, all modern coding agents are based on a transformer architecture. They predict syntax, token by token, without any semantic intelligence or understanding of programming metaconcepts. They operate on a vast joint probability distribution and can generalize well within that distribution.

However, when faced with an out-of-distribution (OOD) prompt, they "hallucinate." While syntax prediction without semantic understanding is often "good enough" to boost the efficiency of an experienced software engineer, it's irresponsible to leave critical design decisions to these agents without human oversight.

Take-away: Until a new paradigm emerges that gives AI true semantic understanding, human oversight is paramount. Used responsibly, AI is an incredibly rewarding tool that greatly supports our daily work.

Hallucinations (First and Higher Order)

OOD prompts lead to what I call "first-order hallucinations," where the LLM itself can't generalize and essentially makes things up. The answers are unreliable and require verification. Methods to minimize this include training on more data (scaling) or grounding the LLM with symbolic systems like databases or knowledge graphs.

This leads to what I term "higher-order hallucinations." The grounded data source might be perfectly accurate. However, to access it, the agent must translate your natural language prompt into a formal query. If it hallucinates during this translation, it can create an invalid query (getting no data) or a faulty query that retrieves the wrong correct data. The source is clean, but the retrieval is flawed.

Take-away: In the absence of a new paradigm, it's best to use simpler query sequences instead of one complex one. Simplify the toolset available to your agents and bundle related tasks into a single tool to minimize these translation errors.

Non-Determinism in Answers

While the forward-pass of a transformer is deterministic, the token decoding phase is not. This means if you prompt an LLM five times, you might get five different answers. For coding, this is problematic. Even with the temperature parameter set to zero, non-determinism persists.

Take-away: You never know if you've received the "best" possible generated code, and neither does the AI. This makes human verification absolutely critical, always. For mass refactoring, a robust review process is essential. Interestingly, review agents can help here, but the final decision must rest with a human.

Explainability & Verifiability

LLMs are notoriously black boxes. Billions of floating-point numbers don't offer a semantic explanation for why a particular answer was generated. Research into making these models more transparent is still in its infancy. The lack of semantic understanding, paired with non-determinism, makes true explainability incredibly difficult.

Take-away: For now, the only option for users is to wait for new research and paradigms to emerge.

TL;DR

Human oversight is critical until AI gains a true semantic understanding, which it currently lacks.
Use generative AI to speed your coding, but…
Never commit code without verifying it yourself.
Use simpler query sequences instead of one complex one.
Have a robust code-review process with humans making the final decision.

Next Steps

It is irresponsible for any serious software engineer to ignore the current suite of AI tools, despite their shortcomings. Demonizing them is counter-productive. For those who know what they're doing, these tools are massive efficiency boosters. With responsible use and human oversight, they can be successfully integrated into enterprise workflows and offer many opportunities to improve the human-machine interface.

Outlook

We should not believe all the hype or inflate our expectations of what AI can realistically do today. At the same time, we shouldn't refrain from engaging with these tools in a meaningful way. We, the developers, are still the ones with the creativity, innovation, and semantic understanding. Let's use these tools to amplify that.

Happy coding!

What are your thoughts? Share your experiences with AI in the comments below!

All that you love to know about SRMPROTOCOL

2026-02-19T09:33:37.572000+01:00

Please note that the term SRM used here stands for SAP Records Management.

Managing SAP database growth is a constant balancing act between system performance and compliance. If you’ve noticed the SRMPROTOCOL table climbing to the top of your "Top Growth" charts, you aren't alone. With some systems housing billions of records, understanding and managing this table is critical for a healthy SAP environment.

Here is a guide on what SRMPROTOCOL does, how to control it, and how to reclaim your space.

1. Understanding SRMPROTOCOL: The "Who, When, and What"

At its core, the SRMPROTOCOL table functions as the audit trail for SAP Records and Case Management. Whenever a case or record or document in SRM is created, modified, or deleted, the system generates an entry here to maintain a history of activity.

Audit Importance: This table is vital for legal and regulatory requirements. It ensures that businesses can track the lifecycle of a document or case for accountability.
Data Content: It stores the "SPS ID" (Service Provider Selection ID) and timestamps that link back to specific business objects.

Because these logs track every granular change, the table can grow exponentially in high-volume environments, eventually impacting database performance and backup times.

2. How to Control Log Growth

You don't have to let the table grow indefinitely. SAP provides built-in mechanisms to define how long these logs should live before they are eligible for removal.

Check Your Current Configuration

To see how your system is currently handled, follow these steps:

Execute Transaction SRMREGEDIT.
Locate the SPS ID relevant to your business (you can find these IDs within the SRMPROTOCOL table itself).
Double-click the SPS Element ID.
Navigate to the Classification tab to view the specific logging parameters.

Define "Log Keep Days"

Every organization has different audit requirements. SAP allows you to customize the expiry time for these logs. By setting a specific "retention period," you ensure that the system only flags entries for deletion once they are no longer legally or operationally required.

More details available in the Records Management Logging product documentation page.

3. Cleaning Up and Reducing Space

Once you have defined your retention policies, there are two primary methods to reduce the size of the SRMPROTOCOL table: Deletion or Archiving.

Feature	Option A: Deletion	Option B: Archiving (Recommended for Compliance)
Primary Tool	FM - SRM_PROTOCOL_DELETE_EXPIRY SAP Note 795613	If you are using Records Management as a standalone product, t-code ORGANIZER, consider referring to Archiving in Records Management to handle logs related to documents and records. Case Management: If you are using the framework of Case Management, t-code SCASE, consider referring to Archiving in Case Management for logs specifically tied to cases.
Data Retention	Data is permanently removed from the system.	Data can be moved to long-term storage (external files).
Best Use Case	When logs are past their legal "Keep Days" and no longer needed.	When logs must be kept for 5–10 years for audit/legal compliance.
System Impact	Immediate reduction in table row count; requires a "Reorg" to shrink disk files.	High initial effort to set up, but provides a sustainable long-term solution.
Accessibility	Logs are deleted forever once the function module is processed.	Logs remain accessible via archive search tools if needed.
Handling Large Volumes	If you have a massive table, do not run the FM online. Instead, wrap the Function Module in a custom report and execute it as a background job to avoid timeouts and system strain.	Archiving is handled within the archiving framework. Each step is ideally scheduled as background job

Understanding the Basic Terminologies of SAP Cloud World : A Beginner ‑ Friendly Guide

2026-02-19T10:03:58.866000+01:00

𝗗𝗲𝗺𝘆𝘀𝘁𝗶𝗳𝘆𝗶𝗻𝗴 𝗦/𝟰𝗛𝗔𝗡𝗔, 𝗕𝗧𝗣, 𝗥𝗔𝗣 & 𝗖𝗔𝗣, 𝗥𝗜𝗦𝗘 𝗪𝗜𝗧𝗛 𝗦𝗔𝗣, 𝗖𝗹𝗲𝗮𝗻 𝗖𝗼𝗿𝗲, 𝗖𝗙𝗟, 𝗦𝗶𝗱𝗲 𝗯𝘆 𝗦𝗶𝗱𝗲 𝗘𝘅𝘁𝗲𝗻𝘀𝗶𝗯𝗶𝗹𝗶𝘁𝘆 - 𝗔 𝗣𝗿𝗮𝗰𝘁𝗶𝗰𝗮𝗹 𝗝𝗼𝘂𝗿𝗻𝗲𝘆 𝗳𝗼𝗿 𝗔𝗕𝗔𝗣 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀

𝟭. 𝗦/𝟰𝗛𝗔𝗡𝗔 𝗗𝗲𝗽𝗹𝗼𝘆𝗺𝗲𝗻𝘁 𝗠𝗼𝗱𝗲𝗹𝘀 𝗘𝘅𝗽𝗹𝗮𝗶𝗻𝗲𝗱

𝗢𝗻-𝗣𝗿𝗲𝗺𝗶𝘀𝗲

✔ You own/manage servers like ECC

✔ Full ABAP Freedom - Custom Code, Debug, SE80/ADT

𝗣𝗿𝗶𝘃𝗮𝘁𝗲 𝗖𝗹𝗼𝘂𝗱

✔ SAP Manages Servers for you(𝗦𝗶𝗻𝗴𝗹𝗲 𝗧𝗲𝗻𝗮𝗻𝘁)

✔ Limited Custom Code - Must Follow Clean Core Principles

𝗣𝘂𝗯𝗹𝗶𝗰 𝗖𝗹𝗼𝘂𝗱

✔ Shared Infrastructure(𝗠𝘂𝗹𝘁𝗶 𝗧𝗲𝗻𝗮𝗻𝘁)

✔ No Custom ABAP - Extensions Via BTP only

𝟮. 𝗦𝗶𝗻𝗴𝗹𝗲 𝗧𝗲𝗻𝗮𝗻𝘁 𝗩𝘀 𝗠𝘂𝗹𝘁𝗶 𝗧𝗲𝗻𝗮𝗻𝘁 : 𝗧𝗵𝗲 𝗛𝗼𝘂𝘀𝗶𝗻𝗴 𝗔𝗻𝗮𝗹𝗼𝗴𝘆

𝗨𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝗶𝗻𝗴 𝘁𝗵𝗲 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 𝗗𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝗰𝗲

■ 𝗣𝗿𝗶𝘃𝗮𝘁𝗲 𝗖𝗹𝗼𝘂𝗱( 𝗦𝗶𝗻𝗴𝗹𝗲 𝗧𝗲𝗻𝗮𝗻𝘁 )

𝗛𝗼𝘂𝘀𝗶𝗻𝗴 𝗔𝗻𝗮𝗹𝗼𝗴𝘆 : You Rent an entire independent house - SAP is your Landlord who Maintains it, but you're the only resident.

𝗪𝗵𝗮𝘁 𝘁𝗵𝗶𝘀 𝗠𝗲𝗮𝗻𝘀 :

✔ Your Data is Completely isolated from other companies

✔ You get your own dedicated hardware/software stack

✔ SAP manages infrastructure ( Servers, OS, backups )

✔ You still control configurations and some customizations

𝗘𝘅𝗮𝗺𝗽𝗹𝗲:

Company A : Server 1 Running S/4 HANA Instance A

Company B : Server 2 Running S/4 HANA Instance B

Company C : Server 3 Running S/4 HANA Instance c

Each Company has their own 𝗦𝗲𝗽𝗮𝗿𝗮𝘁𝗲 𝗶𝗻𝘀𝘁𝗮𝗹𝗹𝗮𝘁𝗶𝗼𝗻.

■ 𝗣𝘂𝗯𝗹𝗶𝗰 𝗖𝗹𝗼𝘂𝗱

𝗛𝗼𝘂𝘀𝗶𝗻𝗴 𝗔𝗻𝗮𝗹𝗼𝗴𝘆: You rent an apartment in a shared building - many families live in the same building, sharing elevators/parking but have separate locked units.

𝗪𝗵𝗮𝘁 𝗧𝗵𝗶𝘀 𝗠𝗲𝗮𝗻𝘀:

✔ Your data is logically separated (like database partitions)

✔ Same software version for all customers (no custom patches)

✔ Shared infrastructure (like AWS/Azure multi-tenancy)

✔ No custom ABAP allowed (everyone uses same codebase)

𝗘𝘅𝗮𝗺𝗽𝗹𝗲:

Single Server → Single S/4 Instance

├── Company A Data (Tenant ID: 001)

├── Company B Data (Tenant ID: 002)

└── Company C Data (Tenant ID: 003)

𝗥𝗲𝗮𝗹-𝗪𝗼𝗿𝗹𝗱 𝗖𝗼𝗺𝗽𝗮𝗿𝗶𝘀𝗼𝗻

𝗣𝗿𝗶𝘃𝗮𝘁𝗲 𝗖𝗹𝗼𝘂𝗱 𝗶𝘀 𝗹𝗶𝗸𝗲:

Having your own ECC system but SAP hosts the servers

✔ You still get your own environment (DEV/QAS/PRD)

✔ Can have some customizations (within clean core limits)

𝗣𝘂𝗯𝗹𝗶𝗰 𝗖𝗹𝗼𝘂𝗱 𝗶𝘀 𝗹𝗶𝗸𝗲:

✔ Using Gmail - Google's servers, everyone uses same version

✔ You can't modify Gmail's code - only configure it

✔ Cost-effective but zero flexibility

𝗪𝗵𝗶𝗰𝗵 𝗖𝗼𝗺𝗽𝗮𝗻𝗶𝗲𝘀 𝘂𝘀𝗲 𝘄𝗵𝗮𝘁 ?

Manufacturing(Large) - Private Cloud/ On premise ( Heavy Customizations )

Retail(Small/mid) - Public Cloud ( Standard Process, Fast Deployments )

Start ups - Public cloud ( Cost Effective )

𝟯. 𝗪𝗵𝗮𝘁 𝗶𝘀 𝗥𝗜𝗦𝗘 𝘄𝗶𝘁𝗵 𝗦𝗔𝗣 ?

𝗥𝗜𝗦𝗘 𝗶𝘀 𝗡𝗢𝗧 𝗮 𝗽𝗿𝗼𝗱𝘂𝗰𝘁 - 𝗶𝘁'𝘀 𝗮 𝘀𝘂𝗯𝘀𝗰𝗿𝗶𝗽𝘁𝗶𝗼𝗻 𝗽𝗮𝗰𝗸𝗮𝗴𝗲 like buying a car with insurance/maintenance bundled.

𝗥𝗜𝗦𝗘 = 𝗦/𝟰𝗛𝗔𝗡𝗔 𝗖𝗹𝗼𝘂𝗱 (𝗣𝗿𝗶𝘃𝗮𝘁𝗲/𝗣𝘂𝗯𝗹𝗶𝗰) + 𝗕𝗧𝗣 + 𝗦𝘂𝗽𝗽𝗼𝗿𝘁 + 𝗠𝗶𝗴𝗿𝗮𝘁𝗶𝗼𝗻 𝗧𝗼𝗼𝗹𝘀

For you as a developer: It's just a licensing model. Your actual work doesn't change drastically unless your company chooses Public Cloud.

𝟰. 𝗪𝗵𝗮𝘁 𝗶𝘀 𝗕𝗧𝗣? 𝗧𝗵𝗲 𝗦𝗶𝗺𝗽𝗹𝗲 𝗧𝗿𝘂𝘁𝗵

𝗕𝗧𝗣 (𝗕𝘂𝘀𝗶𝗻𝗲𝘀𝘀 𝗧𝗲𝗰𝗵𝗻𝗼𝗹𝗼𝗴𝘆 𝗣𝗹𝗮𝘁𝗳𝗼𝗿𝗺) is SAP's cloud platform where you build apps that extend S/4HANA without touching its core code.

𝗢𝗹𝗱 𝗘𝗖𝗖 𝗪𝗮𝘆 (𝗬𝗼𝘂𝗿 𝗖𝘂𝗿𝗿𝗲𝗻𝘁 𝗪𝗼𝗿𝗹𝗱):

" Customer asks: "We need a custom approval workflow for purchase orders"

" 𝗬𝗼𝘂 𝗱𝗼 𝘁𝗵𝗶𝘀:

1. Create Z-table (SE11)

2. Write custom ABAP program (SE38/SE80)

3. Modify standard SAP transaction (User Exit/BADI)

4. Add custom fields to EKKO table

𝗥𝗲𝘀𝘂𝗹𝘁: System becomes "dirty" → upgrades break your code

𝗦/𝟰 + 𝗕𝗧𝗣 𝗪𝗮𝘆 (𝗡𝗲𝘄 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵):

You do this:

1. Keep S/4HANA standard (no modifications)

2. Build approval app on BTP (separate system)

3. Connect to S/4 via APIs

4. Store custom data in BTP database

𝗥𝗲𝘀𝘂𝗹𝘁: S/4 stays "clean" → smooth upgrades

𝟱. 𝗥𝗔𝗣 𝘃𝘀 𝗖𝗔𝗣

✔ 𝗥𝗔𝗣 = 𝗔𝗕𝗔𝗣-𝗯𝗮𝘀𝗲𝗱 (𝗿𝘂𝗻𝘀 𝗜𝗡 𝗦/𝟰𝗛𝗔𝗡𝗔)

• RAP runs inside S/4HANA system - whether Public or Private Cloud.

𝗥𝗔𝗣 𝗶𝗻 𝗣𝗿𝗶𝘃𝗮𝘁𝗲 𝗖𝗹𝗼𝘂𝗱

• Create custom database tables (Z-tables)

• Access standard SAP tables directly

• Some custom ABAP classes (within clean core guidelines)

• Traditional debugging in ADT

𝗥𝗔𝗣 𝗶𝗻 𝗣𝘂𝗯𝗹𝗶𝗰 𝗖𝗹𝗼𝘂𝗱

• NO direct table access (VBAK, KNA1, etc.) - must use released CDS views (I_* views)

• NO custom database tables in S/4

• Only released APIs/BAPIs allowed

• Cannot use SE11/SE80 - only Eclipse ADT

✔ 𝗖𝗔𝗣 = 𝗡𝗼𝗱𝗲.𝗷𝘀/𝗝𝗮𝘃𝗮-𝗯𝗮𝘀𝗲𝗱 (𝗿𝘂𝗻𝘀 𝗢𝗡 𝗕𝗧𝗣 - 𝘀𝗲𝗽𝗮𝗿𝗮𝘁𝗲 𝗳𝗿𝗼𝗺 𝗦/𝟰)

• CAP is completely separate from S/4HANA - runs on BTP only.

𝗖𝗔𝗣 𝘄𝗶𝘁𝗵 𝗣𝗿𝗶𝘃𝗮𝘁𝗲 𝗖𝗹𝗼𝘂𝗱 𝗦/𝟰
𝗖𝗼𝗻𝗻𝗲𝗰𝘁𝗶𝘃𝗶𝘁𝘆:
• Uses SAP Cloud Connector (secure tunnel to on-premise/private)
• Can call any OData service you expose from S/4
• More flexible integration (can use custom RFCs if needed)

𝗖𝗔𝗣 𝘄𝗶𝘁𝗵 𝗣𝘂𝗯𝗹𝗶𝗰 𝗖𝗹𝗼𝘂𝗱 𝗦/𝟰
𝗥𝗲𝘀𝘁𝗿𝗶𝗰𝘁𝗶𝗼𝗻𝘀:
• Can only use SAP's released APIs (API Business Hub)
• No custom OData services from S/4 (since you can't create custom code there)
• Direct internet connectivity (no Cloud Connector)

𝟲. 𝗖𝗹𝗲𝗮𝗻 𝗖𝗼𝗿𝗲

𝗪𝗵𝗮𝘁 𝗶𝘁 𝗶𝘀: A principle that keeps your SAP system's standard code unchanged and upgrade-safe.

Simple explanation: Don't modify SAP's delivered code directly. Keep the "core" clean.

𝗘𝘅𝗮𝗺𝗽𝗹𝗲 :

𝗢𝗹𝗱 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵 :

Third Party System → Inbound IDoc → BADI/Customer Exit ( Data Mapping for Idoc segments ) → SAP Standard Processing

𝗖𝗹𝗲𝗮𝗻 𝗰𝗼𝗿𝗲 :

Third Party System → IDoc → AIF Layer → Data Mapping → SAP Standard Processing

𝗕𝗲𝗻𝗲𝗳𝗶𝘁𝘀 𝗼𝗳 𝗔𝗜𝗙 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵:

✅𝗖𝗹𝗲𝗮𝗻 𝗖𝗼𝗿𝗲 𝗖𝗼𝗺𝗽𝗹𝗶𝗮𝗻𝗰𝗲:

• No code in customer exits/BADIs

• Configuration-driven transformations

• Standard AIF framework handles processing

𝟳. 𝗕𝗧𝗣 𝗦𝗶𝗱𝗲-𝗯𝘆-𝗦𝗶𝗱𝗲 𝗘𝘅𝘁𝗲𝗻𝘀𝗶𝗯𝗶𝗹𝗶𝘁𝘆

𝗪𝗵𝗮𝘁 𝗶𝘁 𝗶𝘀: Building custom applications on SAP Business Technology Platform (BTP) that work alongside your SAP system.

𝗦𝗶𝗺𝗽𝗹𝗲 𝗲𝘅𝗽𝗹𝗮𝗻𝗮𝘁𝗶𝗼𝗻: Create new apps on the cloud that connect to SAP via APIs, without touching the core system.

𝗕𝗲𝗻𝗲𝗳𝗶𝘁𝘀: Innovation without risking core stability, use modern cloud technologies

𝟴. 𝗖𝗙𝗟 (𝗖𝘂𝘀𝘁𝗼𝗺 𝗙𝗶𝗲𝗹𝗱𝘀 & 𝗟𝗼𝗴𝗶𝗰)

𝗪𝗵𝗮𝘁 𝗶𝘁 𝗶𝘀: SAP's embedded extensibility framework for adding custom fields and business logic without code modifications.

𝗦𝗶𝗺𝗽𝗹𝗲 𝗲𝘅𝗽𝗹𝗮𝗻𝗮𝘁𝗶𝗼𝗻: Point-and-click tool to add fields and simple logic to standard SAP objects.

Add simple extensions inside SAP using key user tools.

SAP BTP ABAP Environment - Release 2602

2026-02-19T10:47:10.350000+01:00

SAP BTP ABAP Environment - Release 2602

On February 14, the new 2602 release was delivered as the successor to the 2511 release. In this blog post, we provide a detailed overview of the new features and enhancements included in this release, highlighting the key improvements and innovations introduced with 2602. Some highlights in the new release include the My Home as your new personalized entry page in SAP Fiori Launchpad, the CDS Embedded Analytics Star Schema Generator and the RAP recommendations for input assistance based on the user input and interaction history.

The list of all new features including more information can be found on the What's New for SAP BTP ABAP environment page. The new AI-related features are listed separately on the What's New for ABAP Generative AI in ABAP Cloud.

ABAP Development Tools (ADT)

New Grouping Option Effect on transports in ATC Problems View
ABAP Testability: Enhancements to Test Double Frameworks (details)
Global User ID for ATC Exemptions
Displaying the Used Objects of CDS Service Definitions in the Relation Explorer

ABAP RESTful Application Programming Model (RAP)

Collaborative Draft, now also works in cross-business object scenarios if both business objects are collaborative draft-enabled, and if the cross-business object scenario is fully draft scope-enabled (details)
Recommendations, previously, business users had to fill out input fields manually and choose the right values. The new RAP recommendations standardize and ease this process: In RAP applications on an SAP Fiori user interface, RAP recommendations provide input assistance by proposing field values for input fields based on the user input and interaction history. RAP recommendations can be implemented using deterministic rules or using generative AI, which predicts the most likely values for each input field based on the context of the data. By integrating the ABAP AI SDK powered by Intelligent Scenario Lifecycle Management, you can embed AI capabilities into the application, enriching traditional value help with context-aware suggestions (details)
Embedded Analytics Star Schema Generator, the Star Schema Generator Wizard streamlines the creation of star schema models using ABAP Core Data Services. It empowers you to build comprehensive analytical models with ease. This tool guides you through the entire generation process, ensuring a consistent and efficient workflow. The wizard supports the following key components: Transactional Scenario, Analytical Cube and Dimension Views (details)

Identity and Access Management

IAM App Assignment: So far, it was only possible to assign access to Fiori apps to business users indirectly via business catalogs. Now, it's also possible to directly create business roles based on IAM apps for SAP-delivered business catalogs
Maintain Business Roles, you can now directly assign IAM apps in the Maintain Business Roles app. This supports you in handling authorizations more flexibly. You can also use the Mass Change Wizard if you need to add or remove multiple IAM apps at once (details)
App References, the following apps now contain references to IAM apps: Maintain Business Roles, Manage Business Role, Changes After Upgrade, Display Restriction Types, Business Catalogs, Business Role Templates, IAM Information System (details)
Information System, the main entity Application is now deprecated. The successor will be the IAM app, which is now contained in the Main Entity dropdown list (details)
App Authorization Variant, you can now use the IAM app of the App Authorization Variant type. This gives you more flexibility in managing restrictions because it allows you to activate or deactivate app authorization variants to define different access rights per business role (details)

Manage API Snapshots

As a provider for released APIs, you can now download and upload API snapshots using the Manage API Snapshots app. This way, you can download API snapshots from the test system and upload them in the development system, thus preventing incompatible changes to your released objects early in the development process (details)

SAP Fiori Launchpad

My Home in SAP BTP ABAP environment
Launching an App with a Transaction Code (details)
Download and Upload of Spaces
Removal of Business Groups

Landscape Portal

Publish Product: Publish up to Two Product Versions (details)
Deploy Product: System multi-select supported and performance improved (details)

Infrastructure

Optional Integration with SAP Key Management Service, SAP BTP ABAP environment provides an optional integration with the SAP Key Management Service (KMS). With this integration, it's possible to manage the SAP HANA Cloud database of an ABAP environment instance via SAP KMS (details)