SAP Community - SAP BTP, ABAP environment

ABAP development tools for Visual Studio Code: Patch 1.0.1 released

2026-06-12T07:41:59.469000+02:00

What happened since the first release?

First of all, thanks to all the ABAP developers who have already tried out the new extension! You provided a lot of positive feedback & constructive criticism over the last two weeks and can be assured that we read every single one. When looking at the overall feedback three things stand out:

1. Trouble with setting up system connections. Because the extension ships with a new way for configuring system destinations, some of you had trouble configuring ABAP system access. We have already published improved documentation and we are also looking into how we can further improve the usability of these user flows in the upcoming releases.

2. Missing support for Windows ARM hardware. We added this to our backlog and already made some progress. However, further testing needs to be done until we can release it to the public.

3. Missing support for RFC + password. We communicated openly and proactively across multiple channels that RFC + password support would arrive in the next major release, and we were aware of its importance. Even so, we were still surprised by how many users are relying on classic passwords. That’s why we reacted quickly. Since the mandatory security review of such a critical change was already done, we are pleased to add support for passwords via a patch.

We also received general feedback that the community would appreciate more how-to guides. Here are some links for getting started and learning more about the extension. We are planning to provide more guides in the future.

RAP130 tutorial. A tutorial that walks you through using the ADT MCP server together with an AI agent.
Setup guide how to get started with GitHub Copilot. Björn Schulz published a nice guide for configuring the initial setup.
Podcast on the ADT for VS Code extension. Rich Heilman did a podcast with some members of the ADT team. It covers a lot of technical aspects of the extension but also provides some insights into the plan for the next releases.

What gets shipped with this release?

RFC System logon via password

You can create RFC destinations with password access.

AGENTS.md template

The documentation already provides a template for an AGENTS.md file. With the update the same file gets shipped with the VS Code extension. This makes it easier to get started. We still recommend duplicating the template and adding your own company/team/project-specific instructions. The more time you spend on onboarding the agent into your project the better results it will produce.

What's next?

The next release is currently planned for next month. The planned features remain unchanged from the previous blog post:

Support of more core development object types: RAP behavior extensions, DDIC tables, DDIC structures, DDIC enqueue objects, DDIC type groups, CDS entity buffers, programs/includes, function groups and modules, ...
MCP tools: Unified diff tool for transports, ABAP test cockpit tools, …

Follow the ABAP Cloud Roadmap if you are interested in knowing what comes next.

Provide feedback and influence our product backlog!

We welcome your feedback! Feel free to use the comment section or create a customer influence request to let us know which features you are missing the most. Your input will help us prioritize the feature backlog for the next releases.

SAP Joule for Developers, ABAP AI capabilities including agentic capabilities is now available!

2026-06-12T17:18:40.414000+02:00

The re-invented SAP Joule for Developers, ABAP AI capabilities including agentic capabilities is now offered as a service across SAP BTP ABAP Environment, SAP S/4HANA Cloud Public Edition, and SAP S/4HANA Cloud Private Edition for releases 2021 and higher.

Joule speaks ABAP, and now it speaks more than ever before.

SAP Joule for Developers, ABAP AI capabilities have already generated strong interest across the SAP ecosystem, enabling customers to achieve remarkable results, as demonstrated by the success story from Bosch.

Following our Sapphire announcements, detailed in Sonja Lienard's blog post Sapphire 2026: GA announcement for agentic ABAP AI and in the blog post Sapphire 2026: ABAP AI - Chapter 3: We go agentic! by Alexander Rother, we are now entering the agentic era of ABAP development.

In addition, we have received valuable feedback from many of you on the existing ABAP AI capabilities. Building on this feedback, we are proud to announce that our re-invented ABAP AI capabilities, including new agentic capabilities, are now officially available.

Beyond these enhancements, we have also expanded support for SAP S/4HANA Cloud Private Edition, extending the supported releases down to 2021.

Please note : For SAP S/4HANA On-Premise 2025, 2023, 2022, and 2021, availability is subject to the special RISE with SAP contract conditions announced at SAP Sapphire. Please verify your entitlement and contract status with your account executive before planning adoption.

In this blog, we will cover the following aspects:

How to obtain the required commercial license for SAP Joule for Developers, ABAP AI capabilities.
How to configure your backend systems and enable SAP Joule for Developers, ABAP AI capabilities in ABAP Development Tools for Eclipse and ABAP Development Tools for Visual Studio Code including an overview of the capabilities supported

New Commercial model for SAP Joule for Developers, ABAP AI Capabilities

The introduction of the new ABAP AI Hub Service , which exposes our re-invented ABAP AI capabilities running side by side to your ABAP systems, marks a strategic step toward making AI capabilities more accessible, scalable, and future-ready across diverse SAP landscapes. With a single commercial license, customers can purchase once and leverage these capabilities across supported SAP products, independent of their underlying release versions.

One of the key advantages is simplified adoption. Customers can now enable ABAP AI capabilities through a more streamlined onboarding process using SAP for Me reducing setup effort while ensuring consistent lifecycle management across environments.

Another major benefit is release-independent access. Instead of being tightly coupled to specific SAP S/4HANA release cycles, customers can consume ABAP AI services side by side with their existing systems. This enables even customers on lower releases to leverage the latest AI innovations without waiting for a system upgrade.

In short, the ABAP AI Hub service is not just an architecture shift, it is an innovation enabler, helping customers adopt ABAP AI faster, more flexibly, and with greater future readiness.

Commercial model & AI Units

SAP Joule for Developers, ABAP AI capabilities are embedded in the Joule Premium package and offered with separate licenses for customers and partners. Pricing follows a consumption-based model, meaning you only pay for actual usage. Customers and partners purchase AI Units and activate the required packages via SAP for Me. Authorization for developer access is managed through Cloud Identity Services, while AI requests are executed and metered in the ABAP AI Hub Service on SAP BTP.

What is an SAP AI Unit?

SAP AI Units are a form of virtual currency that customers purchase to activate and use premium AI capabilities within SAP Cloud Services. They are consumption-based credits that can be used flexibly across multiple SAP solutions and are not tied to a specific product or line of business. This allows customers to draw from a central pool of AI Units as they use AI-powered features across their SAP landscape. AI Units are purchased annually and expire after 12 months if not used. Customers can track their usage and remaining balance in real time via SAP for Me.

How do I know how many units I should purchase?

SAP provides guidance and estimation tools to help determine the right amount of AI Units. Your SAP Account Executive or Partner can support you in defining the appropriate quantity and help model different usage scenarios.

How to Purchase the License and activate the packages?

For Customers
Purchase AI Units using SKU 8019164 via SAP for Me to begin the Premium AI activation process.
For more Information refer to the SAP Note 3740750.

For Administrators: Steps to configure SAP Joule for Developers, ABAP AI Capabilities.

Prerequisites

You are an administrator with full access to SAP for Me.

Procedure

Open SAP for Me and navigate to Portfolio & Products.
Select the tab My Product Packages and choose the package Joule.
Select the tab Applications and choose the application SAP Joule for Developers, ABAP AI capabilities.
Now you can Start Provisioning.
- Enter the solution details. Provide a display name and select a resource group. If no resource group exists, you will be prompted to create one.
- Select a Cloud Identity Services system.
- Select your region.
- Choose a Formation Name (the name is mandatory but has no further technical relevance).
- Review and finish the setup. The provision process might take a few moments to complete. Click on View in Resources to view the status of the generated resources.
- The new solution will achieve the Ready status when all tenants are successfully provisioned, and integrations are fully established.
To activate the feature in SAP Central Business Configuration. Navigate to SAP for Me> Click on Portfolio & Provisioning > Business AI.
Click on Configure to launch the Central Business Configuration application.
Ensure user access is available for the Central Business Configuration tenant. To access your SAP Central Business Configuration tenant.You will need to have your user account set up with the readFeatureActivationStatus & writeFeatureActivationStatus policies on your account with the connected SAP Cloud Identity Services tenant.
On the dashboard, a list of features is provided and grouped by the product name. Select “SAP Joule for Developers, ABAP AI Capabilities”.
Click on Activate to proceed with the activation process. Once the activation is complete, ensure that the status is displayed as Active.
Assign named users through SAP Cloud Identity Services (IAS) to enable access for authorized users. Navigate to SAP Cloud Identity Services.
Under Users & Authorizations Select the user and assign the group “j4d_abap-enterprise-user”
In the tab Resources you will find a new tenant providing its Main URL (which will lead to the UI of the application).

Provide that URL to the developers so they can configure SAP Joule for Developers, ABAP AI capabilities for side-by-side use in ABAP Development tools for Eclipse or in ABAP Development tools for Visual Studio Code.

For Developers Using ABAP Development Tools (ADT) for Eclipse: Steps to configure SAP Joule for Developers, ABAP AI Capabilities.

Prerequisites

Your SAP administrator provides you with a URL that refers to the SAP BTP.

You have applied the relevant SAP notes below:

To enable ABAP development tools for Eclipse (ADT) for SAP Joule for Developers, ABAP AI capabilities refer to SAP Note 3752299 .
AI Functionality in SAP S/4HANA Cloud Private Edition - SAP Note 3558794
When working on SAP S/4HANA Cloud Private Edition also follow the instructions in the SAP Note 3751297 .
To enable AI Capabilities for ATC Findings follow the SAP Note 3721223 - AI Capabilities for ATC findings - SAP for Me
If you are unfamiliar how to implement an SAP note with TCI instructions, please refer to https://me.sap.com/notes/3437407

Configure the SAP Joule for Developers, ABAP AI capabilities for Specific ABAP Projects

Note: ADT Client version 3.58.3 or higher is required for the new AI setup based on AI Units. Ensure that your Eclipse ADT plug-in is updated accordingly before proceeding with the configuration.

Home page for installation: https://tools.hana.ondemand.com/#abap
ADT client URL: https://tools.hana.ondemand.com/latest

To use the latest SAP Joule for Developers, ABAP AI capabilities in specific ABAP projects in your ABAP Development Tools for Eclipse.

In the Project Explorer, select the relevant ABAP project and Choose Properties from the context menu.
Select make the input available, select the Enable project-specific settings checkbox.
Beneath the Use Joule side-by-side radio button, enter the URL to the subscription of the central BTP service on the SAP BTP.
Optional: Choose the Check Connection button to control if the connection works.
Confirm with Apply.

You can now use the SAP Joule for Developers, ABAP AI capabilities side-by-side in the selected ABAP project.
Click here to explore what’s in it!

For Developers Using ABAP Development Tools (ADT) for Visual Studio Code: Steps to configure SAP Joule for Developers, ABAP AI Capabilities.

Prerequisites

Your SAP administrator provides you a URL that refers to the SAP BTP.

Configure the SAP Joule for Developers, ABAP AI capabilities for all ABAP Projects

As an ABAP developer, you want to use the latest SAP Joule for Developers, ABAP AI capabilities for all of your ABAP projects in your ADT client.

To enable the SAP Joule for Developers, ABAP AI capabilities side-by-side, open the settings. To do this, use the File > Preferences >Settings menu.
Navigate to the Extensions >ABAP Development settings group.
Open the Adt> Joule> Url setting.
Enter the URL for SAP Joule for Developers, ABAP AI capabilities to the subscription of the central BTP service on the SAP Business Technology Platform.

In ADT for Visual Studio Code, you can now use the SAP Joule for Developers, ABAP AI capabilities side-by-side in all of your supported ABAP projects.

Overview of SAP Joule for Developers, ABAP AI capabilities supported in SAP products including lower releases of SAP S/4HANA Cloud Private Edition

Currently using ABAP Development Tools for Eclipse, the following ABAP AI capabilities are supported in the different products and releases:

ABAP AI CAPABILITY	SAP BTP ABAP ENVIRONMENT	SAP S/4HANA Cloud Public Edition	SAP S/4HANA Cloud Private Edition 2025	SAP S/4HANA Cloud Private Edition 2023	SAP S/4HANA Cloud Private Edition 2022	SAP S/4HANA Cloud Private Edition 2021
Predictive Code Completion	Supported	Supported	Supported	Supported	Supported	Supported
ABAP/CDS code explanation	Supported	Supported	Supported	Supported	Supported	Supported
ABAP Unit Test Generation	Supported	Supported	Supported	Supported	Supported	Supported
CDS Test Generation	Supported	Supported	Supported	Supported	Supported	Supported
Documentation Chat	Supported	Supported	Supported	Supported	Supported	Supported
OData UI Service from Scratch	Supported	Supported	Supported	No	No	No
RAP Business Logic Prediction	Supported	Supported	Supported	No	No	No
Custom Code Migration Assistant	NA	NA	Supported	Supported	Supported	Supported

In addition, of course, all capabilities offered by your coding agent of choice are supported and driven by our ADT MCP Server.

With the introduction of the ADT MCP Server, developers can unlock a truly agentic ABAP development experience. The ADT MCP Server makes ABAP development tools easily accessible to AI systems, streamlining development tasks, simplifying workflows, and improving efficiency.

To learn more about the available MCP tools in ADT for eclipse, see: Model Context Protocol Tools | SAP Help Portal

Furthermore, step by step, we will achieve a similar level of ABAP AI capabilities support in ADT for Visual Studio Code.

To learn more about the available MCP tools in ADT for Visual Studio Code, see: Model Context Protocol Tools | SAP Help Portal

With that, go and explore the re-invented ABAP AI offering!

Coauthors,

 @karl_kessler @niloofar_naseri

Troubleshooting Section:

409 Conflict Error
This error occurs during Joule logon if Joule tenant activation is not done in CBC.

403 Conflict Error
This error occurs if the j4d_abap - enterprise-user group assignment is not done in the CIS.

For the AI Configuration - SAP Central Business Configuration, AI-Assisted Scoping and Configuration Services
In SAP Central Business Configuration, AI-assisted scoping and configuration services, you can centrally manage business AI features of SAP cloud solutions. SAP Central Business Configuration, AI-assisted scoping and configuration services, is a centralized hub which enables you to manage SAP's AI solution features via SAP Central Business Configuration.

Please refer -User Setup | SAP Help Portal- for the user setup

Please Note - The CBC tenant is always mapped to the production CIS. So while provisioning the Joule Solution if the Test CIS is selected, then the J4D Tenant is created in the Test Landscape while the CBC(UMS) Application is by default mapped to the production CIS.

Joule not supported issue in ADT - for the private cloud customers refer to - 3558794 - AI Functionality in SAP S/4HANA Cloud Private Edition - SAP for Me

SAP BTP ABAP Environment – Pre-Upgrade Option for Release 2608

2026-06-12T22:39:08.716000+02:00

Overview

Providing a significant number of new features is an important goal of release upgrades to deliver innovations to our customers and partners. There are four major release upgrades per year following a predefined schedule as described in this blog post.

An upgrade is intended as a “no event” for customers and partners. For example, only compatible changes of released objects (APIs) will be delivered. We recommend performing a test of the custom-built productive apps in a test environment for the new release. The complexity of the technical dependencies between the custom-built apps and the underlying environment cannot be tested isolated, only including the ABAP environment on SAP-side. Therefore, we offer you to pre-upgrade selected systems 29 days in advance to test the applications prior to the planned standard-upgrade. Each ABAP environment release is connected to a fixed UI5 major version. As a consequence, the pre-upgrade tests include the upcoming UI5 version as well. Please refer to this blog post for further details.

Purpose

This option enables a customer or partner to test the applications they have already developed on top of the new release a couple of days before the standard-upgrade. With SAP BTP ABAP Environment (aka "Steampunk"), we follow the approach of keeping released objects stable and provide all enhancements in a compatible fashion. Early testing is an additional measure to ensure proper software quality and might be used to detect unforeseen regressions. However, this option is not intended to test new features or to consume new features earlier.

Approach

The standard-upgrade of all systems to release 2608 is planned for August 15/16.

A customer or partner can nominate one or more already existing systems for the pre-upgrade. A nominated system will be upgraded on July 17 within a planned downtime from 8:00 to 16:00 CET. Depending on the system settings, the actual technical downtime might be only ~20 min within the mentioned timeframe. Please refer to this blog post about the downtime-optimized upgrade.

We recommend nominating a non-development system, such as a test system. The nomination of a development system is technically also possible, but fixes or other changes must not be imported into another system with a lower release. The nomination of a productive system doesn’t make sense because the purpose of the pre-upgrade is the re-test of the existing application before the productive system gets the new release.

According to the approach explained above, this offer is only relevant for customers or partners having at least two systems.

There might be situations where a correction of custom objects needs to be deployed. Such corrections are possible if the development / correction system is on the older release and is imported into the pre-upgraded system with the higher release.

Except potential fixes, the pre-upgrade is based on the same version as the standard-upgrade. It is planned to perform the pre-upgrade based on hotfix collection 2. The pre-upgrade systems will get the import of hotfix collection 3 after 2 weeks in the middle of the entire pre-upgrade test phase. It is planned to perform the standard-upgrade based on hotfix collection 3 plus potentially additonal patches and import these potentially additional fixes to the pre-upgrade systems prio to the upgrade weekend on August 14.

Costs

This offering is optional and free of any additional charges.

Planned New Features

The planned new features will be published on the What's New for SAP BTP ABAP Environment on July 10. This list gives you an overview of potential areas for re-testing. The purpose of the pre-upgrade is not to consume these features before the standard-upgrade, because the documentation on help.sap.com will be delivered later before the standard-upgrade. It would also not be possible to transport code of such an adoption, because subsequent systems are not yet on the new release during the pre-upgrade phase.

Independent of the upgrades of the SAP BTP ABAP Environment, we recommend developing automated tests for the custom-built apps to detect regressions early on and without manual effort for re-testing. Such automated tests are perfectly suited to be run in the pre-upgrade test phase.

Time Schedule

The following figure summarizes the general approach:

Milestones for release 2608:

June 16: Nomination of system(s) is possible in the Landscape Portal
July 10: Announcement of the planned new features
July 13: Pre-upgrade systems are known
July 17: Pre-upgrade (with hotfix collection 2)
July 31: Import of hotfix collection 3 into pre-upgrade systems
August 12: Potential decision to postpone the upgrade
August 14: Import of additional patches for collection 3 into pre-upgrade systems
August 15/16: Standard-upgrade (with hotfix collection 3 and additonal patches)

System Nomination

To nominate a system, please register the system(s) by July 13 (EOB) latest by using the Landscape Portal. You can find further information about Accessing the Landscape Portal and about Manage SAP System Upgrade. Please do not create customer tickets for system nomination like in previous pre-upgrades.

With such a nomination, the customer agrees to an extraordinary planned maintenance on July 17 for the pre-upgrade and on July 31 and August 14 for the import of hotfix collections resp. additional patches (see above). You can find information about the required system downtimes in this blog post.

Report an Issue

Issues should be reported as part of the regression test phase by July 31 (EOB) to allow for a sufficient time frame for issue analysis and potential corrections on SAP-side.

Please create a customer ticket by using component BC-CP-ABA.

If a detected issue is likely to endanger the productive use after the standard-upgrade, you should use ticket priority very high despite the fact that the pre-upgrade system is not a productive system.

Exceptional Process in Case of Unresolved Priority Very High Issues

In case of the aligned decision on Wednesday, August 12 (based on unresolved priority very high tickets) to postpone the upgrade, a dedicated mitigation process needs to be started together with the respective customer or partner, with the following boundary conditions:

Resolving the open priority very high issues remains the highest priority for both, SAP and the customer or partner, as it is also the prerequisite for the upgrade.
According to the estimated issue resolution, catching up the upgrade needs to be planned.
The upgrade leads to a business downtime. Please refer to this blog post.
The upgrade must be scheduled within 7 calendar days the latest after fixing all remaining open priority very high issues.
We will not provide any fixes for the old release after the original date of the standard-upgrade to the new release.

In case business-critical issues are detected after the upgrade:

Issues need to be reported as priority very high issues and will be processed accordingly.
Going back to the release before upgrade is not an option. Therefore, resolving the issues in the new release with the appropriate priority is the required approach.

Summary

We recommend performing regression tests in pre-upgraded test systems to avoid day-1 impacts of productive custom apps after the standard-upgrade.

Unmanaged RAP application for Excel File Upload and CDS Custom Entity with Unmanaged Query Implement

2026-06-14T15:02:55.897000+02:00

Intro

Nowadays, finding information is easier than ever. Although, the experience still remains the key differentiator. And that’s what I would like to share through this blog – my experience in implementing the Excel File Upload in a RAP application in BTP ABAP environment. RAP application was implemented with an unmanaged behavior, supporting also the editing of multiple items at the same time. Additionally, the data model is based on custom entities with unmanaged queries.

Use-case

RAP application for maintaining Bonus Plans; allow the editing of multiple records at the same time; allow mass upload from an Excel file.

Data Model

The data model for my scenario is based on 2 DB tables (ZIP_BONUS_PLAN and ZIP_BP_UPLOAD) and 3 CDS Custom Entities (ZCE_BP_SINGLETON, ZCE_BONUS_PLAN and ZCE_BP_UPLOAD). Refer to Custom Entities | SAP Help Portal.

The root entity is a singleton entity aiming to implement multi-inline-edit. Refer to Developing Transactional Apps with Multi-Inline-Edit Capabilities | SAP Help Portal.

All 3 Custom Entities implement the retrieval logic in the same ABAP class ZCL_BP_UNMNG_QUERY.

In the attachment you can find the files containing the most interesting parts of coding:

2 Database Tables
3 CDS views
Unmanage Query implementation
Processing logic
RAP Behavior Definition
RAP Behavior Implementation

Implementation of Excel Upload

The implementation of File Upload is based on large objects (LOBs), providing end users the option to incorporate external files when editing entity instances. To make it work with Excel files you have to implement XCO_CP_XLSX. Refer to Working with Large Objects | SAP Help Portal and XLSX | SAP Help Portal.

Service Binding

For Service Binding I’ve chosen “OData V2 – UI” because if I go for “OData V4 – UI” some parts are missing and I get the following notification in the Service Binding itself “oData V4 services with no draft capability will be primarily READ-ONLY”.

Fiori UI Preview

The preview starts with the root entity ZCE_BP_SINGLETON for which the if_rap_query_provider builds a dummy record during runtime:

Here I have implemented a custom action “Drop all Data” to be able to clear my demo tables.

When I select the singleton record, the application navigates to the page with Bonus Plan Grid:

Here we start with the “Mass Upload” functionality, by executing the “Create New Upload Template”. As a result, a new record is created in the table ZIP_BP_UPLOAD, containing a template file attachment.

When you enter into the details of this record, you can download the template:

Maintain the Excel file data and upload it back:

Now, the file is uploaded and the record is updated:

Once the file is uploaded, it can be processed:

Successfully processed file will create records in the table ZIP_BONUS_PLAN. The UI allows editing multiple records:

Final words

In an era where AI helps us find answers faster than ever, the craft still lies in how we turn those answers into working solutions. This Excel upload journey—unmanaged behavior for bulk editing, custom entities with unmanaged queries—was my way of shaping RAP to the problem, not the other way around. If my experience saves you a few hours, a few pitfalls, or inspires a cleaner design, then sharing it was worth it. The rest is practice—and I’m looking forward to hearing about your experience in the comments below.

Building an Inventory System with RAP on BTP Trial — CDS Views Explained

2026-06-17T11:55:35.487000+02:00

Introduction

When people talk about RAP (RESTful ABAP Programming Model), the conversation usually jumps straight to behavior definitions, actions, and determinations. The CDS layer gets a brief mention and everyone moves on.

That's a mistake.

The CDS view architecture is the contract your entire application is built on. Get it right and everything above it — behaviors, OData services, Fiori UIs — falls into place naturally. Get it wrong and you'll spend hours debugging problems that were actually design issues.

In this post I'll walk through the complete CDS layer of a Mini Inventory & Stock Movement System I built on SAP BTP Trial, covering four entities across three business objects. I'll explain the design decisions, not just the code.

The System at a Glance

The application manages warehouse stock movements. Three business objects cover the full domain:

Business Object Interface View Database Table

Material Master	ZI_MiniMM_Material	ZRMZ_MM_MATERIAL
Storage Location	ZI_MiniMM_Storage	ZRMZ_MM_STORAGE
Stock Document (Header)	ZI_MiniMM_StockDocument	ZRMZ_MM_DOC_HDR
Stock Document (Item)	ZI_MiniMM_StockDocumentItem	ZRMZ_MM_DOC_ITEM
Current Stock (read-only)	ZI_MiniMM_CurrentStock	ZRMZ_MM_STOCK

Each entity has a matching projection view (ZC_ prefix) used to expose the OData service.

The Two-Layer Architecture

RAP enforces a clean separation between two CDS view types. Understanding why this separation exists is more important than understanding the syntax.

Interface views (ZI_) are the authoritative source of truth. They sit directly on the database tables and carry everything the framework needs to understand your data: semantic annotations, associations, compositions, and quantity/currency references. These views should be stable — changing them has downstream impact.

Projection views (ZC_) consume the interface views and add presentation concerns: the provider contract, @Metadata.allowExtensions for metadata extensions, and the redirection of compositions so that OData navigation points to the correct projection layer. Projection views can evolve more freely.

A useful mental model: ZI_ is the API contract, ZC_ is the UI adapter.

Composition: Stock Document Header and Item

The most important structural relationship in this model is the header-item composition between ZI_MiniMM_StockDocument and ZI_MiniMM_StockDocumentItem.

In the header (root entity):

abap

composition [0..*] of ZI_MiniMM_StockDocumentItem    as _Items

In the item (child entity):

abap

association to parent ZI_MiniMM_StockDocument  as _Header  on $projection.DocumentID = _Header.DocumentID

The [0..*] cardinality means a document can have zero or more items — appropriate here since a newly created document starts empty. The parent association on the item side creates the back-navigation link.

Why does this matter? Composition in RAP is not just a modelling convenience. It has runtime implications: the managed runtime treats the composition tree as a single transactional unit. When you delete a header, items are automatically deleted. When you lock a header for editing, the entire tree is locked. This is the correct behaviour for a stock document.

Associations: Two Aliases, One Target View

The item view introduces an interesting challenge: a stock movement can have both a source storage location and a target storage location, and both must be validated against the same ZI_MiniMM_Storage entity.

The solution is two separate associations pointing to the same underlying view:

abap

association [1..1] to ZI_MiniMM_Material as _Material  on $projection.MaterialID = _Material.MaterialID
association [0..1] to ZI_MiniMM_Storage as _SourceStorage  on $projection.SourceStorage = _SourceStorage.StorageID
association [0..1] to ZI_MiniMM_Storage as _TargetStorage  on $projection.TargetStorage = _TargetStorage.StorageID

A few design points worth noting here.

The _Material association is [1..1] — every item line must reference a valid material. _SourceStorage and _TargetStorage are both [0..1] because not every movement type uses both. A goods receipt (GR) has no source; a goods issue (GI) has no target. Making both optional at the CDS level correctly reflects the business reality.

The alias names (_SourceStorage, _TargetStorage) are different even though both navigate to ZI_MiniMM_Storage. This is required by the framework — CDS does not allow two associations with identical names on the same view, even if the target differs.

Semantic Annotations: Free Administrative Data

RAP's managed runtime will auto-populate administrative fields if you annotate them correctly. No custom code required.

abap

@Semantics.user.createdBy: truecreated_by      as CreatedBy,

@Semantics.systemDateTime.createdAt: truecreated_at      as CreatedAt,

@Semantics.user.lastChangedBy: truelast_changed_by as ChangedBy,

@Semantics.systemDateTime.lastChangedAt: truelast_changed_at as ChangedAt

These annotations go on the interface view, not the projection. The framework reads them at runtime and fills the mapped database columns on every create and update operation.

The only requirement is that the underlying database table columns have compatible data types (SYUNAME, TIMESTAMPL respectively) and that you declare with_draft or standard managed behaviour in the behavior definition. If those conditions are met, this is genuinely zero-effort audit trail data.

Projection Views: What Most Tutorials Skip

Every interface view has a corresponding projection view. The projection view adds three things that the interface view cannot provide: the provider contract transactional_query declaration (required for OData V4 exposure), @Metadata.allowExtensions: true (required for metadata extensions to attach), and — crucially — the composition redirect.

The composition redirect is the step that most beginner tutorials either skip or explain poorly.

In the projection header:

abap

_Items : redirected to composition child ZC_MiniMM_StockDocumentItem

In the projection item:

abap

_Header : redirected to parent ZC_MiniMM_StockDocument

Without this redirect, OData navigation from the header to its items would traverse back to the interface entities (ZI_), not the projection entities (ZC_). The service binding would still activate, but navigation in Fiori would either fail silently or return data without the metadata annotations your UI depends on.

Value Help Annotations

The final piece of the CDS layer is the value help definitions, which live in the metadata extension of the item projection view.

abap

@Consumption.valueHelpDefinition: [{
  entity.name: 'ZC_MiniMM_Material',
  entity.element: 'MaterialID' }]MaterialID;
@Consumption.valueHelpDefinition: [{
  entity.name: 'ZC_MiniMM_Storage',
  entity.element: 'StorageID' }]SourceStorage;
@Consumption.valueHelpDefinition: [{
  entity.name: 'ZC_MiniMM_Storage',
  entity.element: 'StorageID' }]TargetStorage;

The annotation always points to the projection view (ZC_), not the interface view. This is because the value help dropdown in Fiori is itself an OData call, and OData services are generated from projection views. Pointing at ZI_ would fail at activation or produce no results.

Both SourceStorage and TargetStorage reference the same ZC_MiniMM_Storage projection — same entity, same element, different field. The framework handles this correctly.

Running This on BTP Trial

Everything described in this post runs on a free SAP BTP Trial account with the ABAP environment service instance. No S/4HANA system required. No license. The ABAP Development Tools (ADT) in Eclipse is the only tool you need locally.

If you've been waiting for the right time to start learning ABAP Cloud and RAP, a BTP trial account is genuinely the right place to start. The constraints of the cloud environment (no classic ABAP, no access to SAP standard tables directly) force you to learn the correct patterns from the beginning.

ArchitectureMaterial View InterfaceMaterial Create InterfaceStock Movement Interface

The Missing Layer in Every SAP Go-Live: Why Hypercare Should Be Built Before Go-Live, Not After!

2026-06-20T14:52:43.762000+02:00

The fifth time I watched a warehouse operative stand frozen in front of a red error screen at 6 AM on go-live day — waiting for a support consultant who wasn't there — I stopped thinking about the symptom and started thinking about the cause.

I have lived this exact scene across five SAP EWM implementations — frozen food, automotive, pharmaceutical, building products, tires. Different industries, different warehouses, different error messages. The same scene every time. A worker who was trained three weeks ago, on a process that has slightly changed since, hits an error the training never covered. The shift supervisor doesn't know the answer. The consultant who configured that exact process rotated off the project last week, or is asleep in a different time zone, or is on another call. The truck is waiting at the dock. And the person who is supposed to keep goods moving is standing still, holding an RF gun, looking at a screen they don't understand.

This is hypercare. And after living it five times, I've concluded we've been solving it the wrong way.

Why Hypercare Keeps Failing — Structurally

The standard answer to a rough go-live is "throw more consultants at it." More floor support. Longer hypercare window. Round-the-clock coverage. I no longer believe that's the answer, because the failures aren't random — they're structural. Six causes show up on every project:

Consultant rotation. The person who configured your wave logic, your POSC/LOSC routing, your putaway strategy, your PPF output — they are not on the floor at 6 AM on day one. The knowledge that would resolve the error in thirty seconds has already walked out the door.

The 24/7 coverage gap. Warehouses run three shifts. Hypercare staffing rarely does. The night shift hits the same errors as the day shift, with even less support.

Accent and language barriers. A global implementation means the support consultant and the floor worker often don't share a first language. Under time pressure, on a noisy dock, that gap becomes a wall.

Knowledge walkout. When hypercare ends, the consultants leave — and every hard-won resolution they discovered leaves with them. The next project rediscovers the same errors from scratch.

The same errors, every project. Across five implementations I have watched teams independently rediscover the identical handful of go-live errors — a missing PPF condition, a queue stuck in /SCWM/MON, an exception code nobody assigned. We never built an institutional memory.

The screenshot barrier. When a worker can't describe an error in words, they photograph it. That photo gets forwarded to a consultant, who interprets it, who replies. The whole support loop already runs on screenshots — we just haven't built anything to receive them.

An Embedded AI Agent — Built in Parallel With Testing

The concept is an AI hypercare agent embedded in the implementation. Plenty of people have proposed an "AI chatbot for SAP support," so let me be precise about the design principles that make this different — because the difference is the whole point.

1. Built in parallel with testing — not after UAT. This is the headline. Every AI support tool I have seen is deployed after go-live, then slowly trained on real incidents while real people suffer. This agent is trained during the testing phase — every SIT defect, every UAT resolution, every project-specific configuration quirk feeds it as the project happens. It arrives at go-live already 90% ready, not as a blank slate that learns while the warehouse bleeds.

2. Solution-Architect-curated, weekly. A human quality gate sits in the knowledge pipeline. Each week during testing, the SA reviews what the agent has ingested and validates it. This is what stops the noise problem that makes generic chatbots useless — the agent learns verified resolutions, not every wrong guess from a test cycle.

3. Multimodal — screenshot first. The primary interface is the photograph of the error screen, because that is already how the floor communicates. The worker shows the agent what they see, exactly as they would show a consultant.

4. A non-negotiable contracted deliverable. This is a commercial reframing, not just a technical one — and I'll come back to it, because it's the part that makes the whole thing actually happen.

5. Self-learning with a validation gate. Resolved tickets feed back into the knowledge base — but only after a Solution Architect signs off, never automatically. This principle matters enough that I give it its own section below, because it is what separates this from a chatbot that confidently repeats wrong answers.

6. Built for the human factors. Accent-independent, anxiety-aware, available to a worker who was rotated onto this line yesterday. These aren't technical features. They're the reason the gap exists, and only someone who has watched it five times would design for them.

7. A controlled, always-current knowledge surface. Beyond resolving errors, the bot is trained on the project's own documentation library — OPLs, work instructions, process guides — and returns only the latest approved version of any document. It becomes the single place the floor can ask, in plain English, "what do I do when X happens?" and trust the answer is current.

The Bot Is a System Object — So It Gets Signed Off Like One

Here's a principle I'd argue is non-negotiable: on go-live day, this bot cannot be a surprise.

In a new SAP S/4HANA embedded EWM deployment, no warehouse process reaches production without passing through the full validation chain — unit test, SIT, UAT, regression, cutover sign-off — approved by the relevant process owners. A wave release strategy is signed off by the outbound lead. A production staging flow is signed off by the manufacturing and warehouse leads. An inbound GR process is signed off by the receiving lead.

The hypercare bot must be treated as exactly that kind of object. It moves through the same gates as every warehouse process:

SIT — the bot's resolutions are validated against the same test scripts the processes are validated against. If a resolution it gives would fail the SIT script, it doesn't ship.
UAT — the actual business users — the shipping clerk, the production supervisor, the receiving specialist — interact with the bot during UAT, not for the first time on go-live morning. They sign off that its answers match how they will actually work.
Regression and cutover — the bot's knowledge base is version-controlled and frozen at cutover alongside the configuration, with the same change-control discipline.

And critically: the bot is trained and socialized by the Organizational Change Management (OCM) team, not dropped in by IT. The same OCM workstream that runs the training, builds the work instructions, and manages the floor's readiness is the workstream that introduces the bot. So when the shipping clerk, the production supervisor, or the inbound receiving specialist opens it at 5 AM on day one, it is a familiar tool they were trained on and helped shape during UAT — not a random, fancy, surprise bot that nobody trusts. Trust is the entire game in hypercare. A tool the floor met for the first time on go-live day has zero trust. A tool they helped validate for six weeks has earned it.

What It Actually Looks Like — Four Real Scenarios

Let me make it concrete across the warehouse flows, in an embedded S/4HANA 2025 EWM deployment. These are representative of the exact class of issues that consume hypercare on every project — and each one shows a different capability the bot needs.

Outbound — the shipping coordinator and the "stock is there, but it isn't" problem. The coordinator runs the wave simulator in the shipping cockpit and it fails — the wave won't simulate. They check the warehouse monitor and the stock shows as F2, unrestricted-use in the warehouse, so by every signal on their screen the stock is available. The real cause is upstream: the batch is restricted because the QM team never released it, and the standard simulator doesn't surface that as the reason it failed. This is a genuine product gap — the simulator tells you it failed, not that a QM batch status is the cause. The bot closes that gap. The coordinator describes the failure in plain English; the bot, trained on this project's QM-EWM batch-release interplay, immediately points to the batch's QM status as the thing to check rather than the warehouse stock type — turning a forty-minute "but the stock is right there" investigation into a thirty-second answer. The same finding is also logged as a candidate enhancement to the simulator itself.

Outbound — the one-off scenario and the right version of the right document. A truck comes back to the yard because it was overloaded — a rare exception the coordinator handles maybe twice a year and has no memorized procedure for. There is an OPL for it, sitting in a shared drive among hundreds of other documents, and quite possibly in three slightly different versions. The bot was trained to reference that document library and tested to return only the latest approved version of any requested procedure. The coordinator simply asks, in plain English, what to do when a loaded truck returns — and gets the current OPL, not a superseded one, without hunting through folders or pinging a consultant to find out which version is live. This is the bot as a controlled, always-current knowledge surface over documentation that already exists but nobody can find under pressure.

Inbound — the receiving specialist who packed it wrong and needs to start over. The specialist realizes they packed an inbound delivery incorrectly on the first pass and needs to repack. The bot walks them through the recovery step by step: delete the existing handling units, use the Change Inbound Deliveries Fiori app to repack cleanly, then collect the new HU labels that print automatically from the assigned printer. This is the bot as a patient, step-by-step floor guide for a correction the specialist was never specifically trained on. And here is the important part — the bot knows the boundary of its own competence. If the new label does not come out of the Zebra printer automatically, and the bot was not designed or tested to troubleshoot printer output, it does not guess. It raises a ticket at the appropriate priority, assigns it to the right team, and tells the specialist it has done so. The specialist isn't left re-framing the same question to a hypercare consultant three times — the escalation happens cleanly and the resolution pace improves.

Production — the supervisor whose stock won't appear in MES. The production supervisor cannot see stock in their MES that should have synced from the EWM monitor. This is one of the most common and most painful go-live issues in a manufacturing landscape — an integration failure across the ERP–MES–EWM chain, where a posting in one system doesn't propagate to the next. The bot is trained to do exactly what a consultant would do to triage it: it takes a screenshot and/or the relevant data, optionally a line or two of context, and works through the integration checkpoints — did the material document post, did the EWM stock update, did the message reach MES — to isolate where the chain broke. If it can resolve it, it does. If it can't fully resolve it, the request routes to a real person already engaged on the project, with the triage already done.

The Bot Learns Only When a Trusted Human Signs Off

Those last two scenarios carry the most important design principle in the whole concept, so I want to state it plainly.

When a consultant resolves an escalated ticket, they cannot simply comment "issue fixed" and close it. That is how knowledge gets lost today. For the bot, a resolution only enters its knowledge base when a Solution Architect — or a peer of equivalent standing and trajectory — signs off that the resolution is correct, complete, and safe for the bot to repeat. Then the bot is retested against it, exactly as a configuration change would be retested.

This is the validation gate that separates this concept from a chatbot that confidently amplifies wrong answers. The bot relearns continuously — but only verified, signed-off knowledge, never an unreviewed "fixed" comment. A wrong resolution learned at machine speed and repeated to every shift is far more dangerous than no resolution at all. The human sign-off is not bureaucracy. It is the safety mechanism that makes self-learning trustworthy.

In all four scenarios: the error never had to be described in a second language, the consultant who built the config didn't have to be awake, the boundary of the bot's competence was respected, and every genuinely new resolution was captured — under human sign-off — for the next worker who hits it.

On the Architecture — Briefly

I'm keeping the stack high-level on purpose, because the originality here is when you build the agent and who curates it, not the technology. At a glance: a vision-capable LLM layer for the screenshot interpretation; a vector knowledge store trained on the project's own SIT/UAT defects, resolutions, and configuration documentation; integration into the implementation's ticketing system (the standard enterprise ITSM tool) so resolved incidents feed back through the SA validation gate; and a floor-friendly channel the workers already use. In an embedded EWM landscape it reads the same error and application-log surfaces the consultants already read — the difference is that it reads them at 5 AM, in every language, for every shift, and never forgets a resolution. The architecture is the easy part. The discipline of building and validating it alongside the warehouse processes is the hard part — and the valuable one.

Make It Non-Negotiable

Here's why this stays a concept unless the commercial model changes: as long as an AI hypercare agent is an optional add-on, it gets value-engineered out of the SOW on every budget-constrained project — which is all of them.

So don't make it optional. Price it into the implementation as a contracted hypercare deliverable, the same way you'd price the cutover plan or the training material. The economics are not subtle: the build cost of the agent is less than two weeks of a single floor consultant's hypercare time. One avoided week of go-live chaos pays for it. The argument to the client isn't "buy our AI" — it's "your hypercare will cost less and work better, and here's the line item."

That single reframing — from add-on to contracted deliverable — is what turns this from a nice idea into something that ships.

The Tool Does Not Yet Exist. That Is the Point.

I want to be clear and honest: I have not built this. What I have is five go-lives of watching the same preventable failure, a design that addresses each of its structural causes, and the conviction that the field is about to need it.

Every meaningful innovation in SAP consulting started as a named concept before it became a product. So I'm naming this one. An AI hypercare agent — built in parallel with testing, SA-curated, signed off through SIT and UAT like any warehouse process, socialized by OCM so the floor already trusts it, screenshot-first, and contracted as a deliverable — is, as far as I can find across SAP Community, SAP's roadmap, and the major SI tooling, not something anyone has yet put together this way.

I'd genuinely like to be challenged on that. If you've seen this built, tell me where — I want to learn from it. If you've lived the 6 AM frozen-screen scene too, tell me what you would add to the design. And if you're a Solution Architect or a delivery lead reading this before your next go-live: ask whether your hypercare plan is a stack of rotating consultants and hope, or something that actually holds the knowledge and stands in front of your floor as first-level support from hour one.

The scene I described plays out on warehouse floors every single week. We have the tools to end it. We've just been building them at the wrong time.

Yogesh Agarwal is an Enterprise Logistics Execution Specialist with 15+ years across SAP EWM and TM implementations in food, automotive, pharmaceutical, building products, and industrial sectors. He writes about SAP supply chain execution on SAP Community and LinkedIn.

SAP BTP ABAP Environment - Build Partner Products and Bring Them to SAP Store

2026-06-30T14:19:53.788000+02:00

Do you want to offer your ABAP Cloud solution to your customers as a cloud product?

SAP BTP ABAP Environment enables partners to build cloud products and side-by-side extensions with ABAP Cloud on SAP BTP and bring them to market via SAP Store. These products run on SAP BTP and can integrate with SAP S/4HANA, other SAP solutions and non-SAP solutions.

To support this journey, SAP BTP ABAP Environment Product Management offers a free-of-charge engagement for partners who want to build and commercialize products on SAP BTP ABAP Environment.

Who is this for?

This engagement is intended for SAP partners who:

want to offer a product to multiple customers
are planning a side-by-side solution on SAP BTP instead of an on-stack SAP S/4HANA extension
are considering SAP BTP ABAP Environment as their product platform
want to publish their solution via SAP Store

To commercialize and publish a partner product via SAP Store, an SAP PartnerEdge Build agreement is required. If you are not yet part of SAP PartnerEdge Build, we can discuss the required next steps in the initial conversation.

Supported delivery options

We currently support two delivery options for partner products on SAP BTP ABAP Environment:

Multitenant SaaS: The partner offers and operates the solution as a cloud service. Customers subscribe to the service and receive their own tenant in the partner's provider system.

Add-On Product: The partner offers the solution as software. Customers run their own SAP BTP ABAP Environment instance and consume the partner product in their own landscape, with the option to extend it according to their needs.

Both options enable partners to productize cloud solutions depending on their target customers, operating model and business model. Partners can also offer both delivery options in parallel, as most of the underlying steps are identical.

How we support you

As part of the engagement, SAP BTP ABAP Environment Product Management can support you with:

choosing the right delivery option
validating your product scenario and architecture
answering technical questions during implementation
sharing reference materials and tutorials
preparing your solution for SAP Store publication
moving towards go-live

The goal is to help partners bring their products live on SAP BTP ABAP Environment faster.

Interested?

If your company is planning to build a partner product on SAP BTP ABAP Environment, we would be happy to hear from you.

Please contact us: sap_btp_abap_environment@sap.com

To help us prepare the first discussion, please include a short description of your product idea or existing solution, your target customer segment, current development stage, and preferred delivery option if already known.

We will then set up a remote session to better understand your scenario and discuss how we can support your journey.

Helpful resources

To get started, you may find the following resources useful:

Bypassing the List Report in SAP Fiori Apps: BCMO, Static Keys, and Dynamic Keys

2026-07-03T09:09:19.145000+02:00

If you've ever generated a Business Configuration Maintenance Object (BCMO) app or built a standard List Report Fiori app for a table with just one relevant record, you've probably run into the same annoyance: the app insists on showing you a list page first, even when there's really only one record, or one record per user, that anyone should ever land on.

In this post, I'll walk through the complete flow: generating a BCMO app for a custom table, getting rid of the pointless singleton list report, and then bypassing the list page in a regular List Report app using both a static key and a dynamic key, such as the logged-in username.

What is a BCMO App, and How Does It Relate to Table Maintenance Generator (TMG)?

Before we jump into the how, a quick primer for anyone new to this.

A Table Maintenance Generator (TMG) is the classic SAP GUI way of generating a maintenance screen for a customizing table, using transaction SE11/SE54. You get a generated SM30 style screen where users can create, edit, and delete entries in a table.

BCMO, Business Configuration Maintenance Object, is essentially the RAP and Fiori based evolution of the same idea. Instead of generating an SM30 style dynpro, ADT generates a full RAP based application stack, behavior definition, behavior implementation, service definition, and service binding, for your custom table, and exposes it as a modern Fiori app. You get the same core purpose as TMG, maintaining configuration or master data in a table, but with a UI5 based List Report and Object Page instead of a classic table control screen.

So think of BCMO as: you want the SM30/TMG experience, but as a proper Fiori Elements app, generated automatically from your table.

You can access a BCMO app in two ways:

Through the Custom Business Configurations (CBC) app, where all the configuration and settings are automatically applied.
As a standalone app, published separately to your Fiori Launchpad or SAP Build Work Zone. In this case, the actual table maintenance appears on the object page, but you also get a singleton list report page in front of it, which is usually unnecessary.

That useless singleton list report is exactly what we're going to eliminate below.

Part 1: Creating a BCMO App

Prerequisites on the Database Table

Before ADT will let you generate a BCMO app, your custom table needs to satisfy a few conditions. If you skip these, generation will fail, and you'll typically see errors pointing you toward three things:

The table's delivery class needs to be set to C, since BCMO is meant for customizing tables, not regular application data.
Data maintenance needs to be explicitly allowed on the table, via the AbapCatalog.dataMaintenance annotation.
Character-like key fields need to be based on a domain, rather than a plain built-in type, so the generator can derive proper value help and type information.

Once these three conditions are met, ADT will happily generate the BCMO stack for you. Here's an example table definition that satisfies all of them:

@EndUserText.label : 'Product Industry Mapping'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #C
@AbapCatalog.dataMaintenance : #ALLOWED
define table zsac_t_prod_ind {

  key client          : abap.clnt not null;
  key industry_sector : mbrsh not null;
  unit_of_measure     : meins;
  currency_code       : abap.cuky;

}

Generating the BCMO Objects

Right-click on the table in ADT, click Generate ABAP Repository Objects, select Business Configuration Maintenance Object, and click Next.

Enter the package.

In the Configure Generator step, you decide the naming of the generated objects and which features to enable. For this example, we'll set Transport Selection to No Transport and uncheck "Enable Transport Selection Strip" to keep things simple. Depending on your landscape, you may want this enabled instead.

Here's the full list of objects that get generated for us:

After selecting your transport request, or choosing No Transport, click Finish, and sip a cup of tea while ADT does its thing.

Once generation completes, this is what you get in ADT:

Accessing the BCMO App

You can access your BCMO app in two ways:

Through the Custom Business Configurations (CBC) app, where all the standard settings are already applied for you.
As a standalone app, published separately to your SAP Fiori Launchpad or SAP Build Work Zone.

If you go the standalone route, the actual table maintenance will appear correctly on the object page, but you'll also get an unnecessary singleton list report page in front of it, which is exactly the problem we're solving in the next section.

Now open the service binding, publish it, and test it.

A Note on Authorizations

You may notice that an access control object gets automatically generated as part of BCMO. If the authorization object S_TABU_NAM is not assigned to your user role, you may see no data in the output, or the Edit button may be disabled.

In that case, you have two options:

Delete the access control on your root entity, or
Assign the required authorizations to your user ID.

While testing this, I also had to comment out the global authorization check in the generated behavior implementation just to see data, due to missing authorizations in my BTP trial account. Obviously, don't do this in a real system, it's purely a local testing workaround.

Part 2: Getting Rid of the Singleton List Report for a BCMO App

Now that our BCMO app is ready, let's get rid of the singleton list report. It doesn't add any value, there's only ever one relevant "list," so why make the user click through it every time?

Step 1: Create a New Project in BAS

Go to SAP Business Application Studio and create a new project from the available templates.

Select SAP Fiori Generator.

Select List Report Page and click Next.

Select the Data Source and Service.

Note: If your system isn't logged in yet, log in first. If you're on an SAP BTP trial account, you'll need to connect BAS to Cloud Foundry before you can see the available Service Bindings.

To do that, open the top search bar and type:

>CF: Login to Cloud Foundry

Once logged in, you should now be able to see the service. Look for your Service Binding for the BCMO app and select it.

Select the entity.

If you're planning to deploy the app immediately, make sure to check "Add Deployment Configuration" and "Add SAP Fiori Launchpad Configuration." For this demo, I'm keeping both unchecked since we're only focused on getting rid of the list report page, not deployment.

Click Finish, and go have another cup of tea while the project scaffolds.

Step 2: Remove the List Report Route from the Manifest

With the project created in BAS, let's get to the main task.

Open manifest.json under the webapp folder and remove the list report route and its corresponding target.

We do this because the default routing configuration always points the app to the list report as the landing page first. By removing this route and target pair, we prevent the router from ever resolving to the list report on initial load, which sets us up to redirect straight to the object page instead.

Step 3: Auto-Navigate to the Object Page in Component.js

Now go to Component.js under the webapp folder and add the following code so the app routes directly to the object page of our singleton record whenever it loads:

init: function () {
    Component.prototype.init.apply(this, arguments);
    this.getRouter().navTo("ProductIndSingletonObjectPage", { key: "(1)" }, true);
}

Step 4: Test It

Run the following command in the terminal to preview the app:

npm run start

And voilà, the first page that opens is no longer the singleton list report, but the actual object page we wanted users to land on directly.

From here, you can continue with deployment as per your requirement, including Fiori Launchpad configuration and transport.

Part 3: Bypassing the List Report for a Standard List Report App

The technique above works great for a true singleton, a table with essentially one record. But what if you're working with a regular List Report app on a table with multiple records, and you want to skip the list page in favor of a specific object page, based on a static key or a dynamic key like the logged-in user? Let's look at both.

Deploying the Base List Report App

As before, start by creating a new project in SAP BAS or VS Code, selecting SAP Fiori Application, then List Report as the template.

In the template wizard, select your Data Source, System, and Service, then click Next. Select the correct main entity and navigation entity, and choose Yes to automatically add table columns and a section to the object page.

Enter your project attribute details, choose Yes for deployment configuration, click Finish, and wait for the dependencies to install. Don't refresh the page while you see "Installing Dependencies" at the bottom right of VS Code.

Once deployed, remove the singleton list report the same way described above: strip the route and target from the manifest, and add the navTo call in Component.js.

The difference this time is what key you pass into that navTo call.

Option A: Bypassing with a Static Key

If you always want the app to open a specific, known record, hardcode the key directly:

init: function () {
    Component.prototype.init.apply(this, arguments);
    this.getRouter().navTo("TableGroupAllObjectPage", { key: "(1)" }, true);
}

This is the simplest approach and works well when there's genuinely one record everyone should see, similar to the BCMO singleton pattern above, but applied manually to a regular List Report app.

Option B: Bypassing with a Dynamic Key (Logged-in Username)

Often, though, you don't want everyone landing on the same record. You want each user routed to their own record, based on who's logged in. For this, we fetch the current username first, then use it to construct the key dynamically before navigating.

init: function () {
    Component.prototype.init.apply(this, arguments);

    var sUser = sap.ushell.Container
        ? sap.ushell.Container.getUser().getId()
        : "DEFAULT_USER";

    this.getRouter().navTo("TableGroupAllObjectPage", { key: "('" + sUser + "')" }, true);
}

A few things to keep in mind with the dynamic key approach:

Make sure the key field in your entity actually corresponds to something like a username, or a field you can reliably derive from the logged-in user, for example, mapped via a custom table or CDS view.
If no record exists for that user yet, decide upfront how your app should behave: show an empty object page in create mode, show a "no data" message, or fall back to a default record.
Test this thoroughly with multiple user IDs before deploying, since the whole point is that different users see different landing records.

For Multi-Level Apps

If your app has more than two navigation levels, for example, a list report page, then an object page showing a related sub-entity's list, then a further object page for that sub-entity's own details, you'll need to add another navigation node to the page map.

To do this, right-click on the app's folder in BAS and select Show Page Map. You'll see the existing levels, with a plus icon enabled on the deepest Object Page. Click it, select the correct navigation property, and add the new page.

Once your routing is set up correctly, deploy using:

npm run deploy

Wrapping Up

Whether you're working with a BCMO app generated straight from ADT, or a hand-built List Report Fiori app, the pattern for bypassing the list page is fundamentally the same:

Remove the list report's route and target from the manifest.
Add a navTo call in Component.js's init function that routes straight to the object page.
Decide whether that route needs a static key, same record for everyone, or a dynamic key, per-user record, typically derived from the logged-in username.
If you have deeper navigation levels, extend the page map accordingly before deploying.

This small change removes a genuinely pointless click for your end users, and it's one of those RAP and Fiori details that separates a generated-and-shipped app from a genuinely polished one.

If deployment configuration for RAP apps to SAP BTP is something you'd like a refresher on before trying this end to end, it's worth reading up on that step separately once you're ready to move beyond local testing.

Chat-based RAP Business Object Generation in VS Code

2026-07-03T14:28:10.192000+02:00

With ABAP Development Tools (ADT) for VS Code, you can now generate complete RAP Business Objects directly from chat prompts. Describe your business scenario in natural language, and GitHub Copilot generates the corresponding RAP artifacts in your ABAP system.

The generated artifacts include:

Database tables
CDS views
Behavior definitions
Service definitions
Service bindings

This feature is enabled by the extension’s built-in MCP (Model Context Protocol) server, which exposes ABAP backend APIs as tools that AI agents can invoke directly. This lets them create and connect the necessary RAP artifacts on your behalf.

Getting Started

For more information about setting up ADT for VS Code, configuring GitHub Copilot Agent Mode, using the ADT MCP server, and troubleshooting common issues, refer to the guide.

Prerequisites:

Before you begin, ensure that you have the following:

ABAP Development Tools for VS Code installed from the VS Code Marketplace
An ABAP system connection configured in the extension (steps shown below)

Figure 1. Adding an ABAP system to the workspaceFigure 2. Selecting a destinationFigure 3. Log on with your credentials

GitHub Copilot with Agent Mode enabled

Figure 4. GitHub Copilot in agent mode

Enable the ADT MCP Server

First, verify that the ADT MCP server is enabled. To do so:

Open the Settings and Search for ADT MCP Server in the search bar
Check the box Enable ADT MCP Server

Figure 5. Enabling ADT MCP Server in settings

Configuring ADT MCP Server

The ADT MCP server is not automatically configured for GitHub Copilot. To configure the ADT MCP Server, open the Command Palette and run MCP: List Servers, then start the ADT MCP server.

Figure 6. Listing the available MCP servers

Figure 7. Starting the ADT MCP Server (part 1)Figure 8. Starting the ADT MCP Server (part 2)

When the ADT MCP server is running and successfully connected, the following notification appears in the lower-right corner:

Figure 9. Success message

Once connected, the available ABAP MCP tools appear in GitHub Copilot. You can verify this by opening Configure Tools in the GitHub Copilot chat, where you can view and select the tools that are active for your session.

Figure 10. Verifying the connection to the ABAP MCP Server (part 1)Figure 11. Verifying the connection to the ADT MCP Server (part 2)

If MCP tools don't appear after setup please refer to troubleshooting

Generating a RAP Business Object

Note: Before running the generation, ensure that your target package already exists. Currently, new packages must be created in ADT for Eclipse. Creating packages directly from ADT for VS Code will be supported in a future release.

With the ADT MCP server running, open GitHub Copilot Chat in Agent Mode and describe the RAP Business Object you want to generate. For best results you can take a look at agent prompt best practices.

An example prompt would be:

“ Generate a RAP Business Object for conference and tech event management, including a database table, CDS views,

behavior definition, and an OData V4 UI service.

Use the Package TEST_BB_CONFERENCE_MGT
Use the following specification:
- Entity 1: Event (root entity)
- Entity 2: Session, child of Event
- Entity 3: Speaker, child of Event
- Entity 4: Registration, child of Session“

Figure 12. Entering a prompt in the chatFigure 13. GitHub Copilot response to the prompt

After your prompt, Copilot will:

List available destinations (abap_list_destinations)
Retrieve the schema (abap_generators-get_schema)
Validate (abap_creation-run_validation)
Create a transport request (abap_transport-create)
Generate all objects (abap_generators-generate_objects)
Activate objects (abap_activate_objects)

After the generation completes, refresh your ABAP project by opening the Command Palette (Ctrl+Shift+P) and running ABAP: Refresh. The generated RAP artifacts will then appear in your workspace under the target package.

Figure 14. RAP artifacts displayed under the defined package

Once the service binding appears in your workspace, use the Publish CodeLens action to publish the service directly from VS Code. After publishing, the OData service is available for consumption.

Figure 15. Publishing the service bindingFigure 16. Success message

Then, use the Preview CodeLens to launch a live preview of your Fiori elements application directly in your browser:

Figure 17. Launching the application previewFigure 18. Selecting the entity for preview

Your generated application is then displayed in the browser:

Figure 19. Application preview

All generated artifacts are created directly in your ABAP system as standard repository objects. They are identical to the RAP artifacts you would create manually, fully editable in ADT for VS Code, and can be extended using the standard RAP development workflow.

Summary

Chat-based RAP Business Object generation enables you to create complete RAP Business Objects directly from natural language prompts in ADT for VS Code. Combined with GitHub Copilot Agent Mode and the ADT MCP server, it automates the creation of the required RAP artifacts while keeping them fully editable as standard ABAP repository objects.

For more information, including setup instructions and configuration details, see the ABAP Development Tools for Visual Studio Code | SAP Help Portal

How to Connect Claude Code to ABAP with Zero-Config MCP

2026-07-05T13:39:48.252000+02:00

Before We Start - What This Post Deliberately Skips

- What is Claude Code, and what are the available models?

- What is MCP (Model Context Protocol) and how it works conceptually?

- What is vibe coding and why AI-assisted development matters?

- What are the benefits of using AI in SAP development?

- What development platforms are available (Web, Desktop, CLI)?

If you need more details, you can find these topics in sap community portal. Read that, then come back here.

What This Post Covers - and Why It Matters?

This post walks you through connecting Claude Code to a live SAP system using the ABAP Remote Filesystem extension's native MCP server - no external Node.js setup, no manual JSON editing, just a single toggle.

What this changes for SAP development:

No more hand-typed routine code. TYPE declarations, SELECT statements, ALV setup - written directly into the SAP object from a single prompt.
No more AI guesswork. Without a live connection, AI tools hallucinate tables and function modules that don't exist. With MCP, every suggestion is grounded in your actual system.
No more setup overhead. What used to require a custom Node.js project now takes one checkbox and one command - open to any developer with VS Code.
Clean Core by default. Claude works through the same ADT API and released objects that Eclipse uses, so generated code fits your governance model instead of fighting it.

This is the point where AI-assisted ABAP stops being a chat-window experiment and starts being a real part of your IDE.

Goal: I will cover the entire topic in 4 parts:

|Part 1| Installing Claude Code on Windows and setting up the VS Code extension |

|Part 2| Connecting VS Code to your live SAP system via the ABAP FS extension |

|Part 3| Enabling the native MCP server with a single toggle - no Node.js setup, no JSON editing |

|Part 4| A live demo: one plain-English prompt creates a real, running ABAP report on SAP |

If you're here, you already know why this matters. Let's get to the actual steps.

Pre-requisite: This guide assumes you already have an active Claude subscription (Pro, Max, Team, or Enterprise). If not, sign up at claude.ai before proceeding

Part 1 - The Setup: Getting Claude Code Running on Windows

Step 1.1 - Install Claude Code CLI

Open PowerShell (the built-in Windows command-line shell) and run:

This downloads Anthropic's official installer and executes it in one step. 'irm' fetches the script, 'iex' runs it.

> ⚠️ Common Error - Git Bash Not Found

> Claude Code needs a bash shell to run on Windows. If you see this error, install Git for Windows from [git-scm.com/downloads/win](https://git-scm.com/downloads/win). During setup, select: Git from the command line and also from 3rd-party software. Then re-run the install command above.

Step 1.2 — Verify the Installation

Close PowerShell and open a fresh window. Run:

You should see a version number like 'claude 1.x.x'. If PowerShell says claude is not recognized, the PATH wasn't set automatically. Fix it manually:

1. Start → search Environment Variables in system settings

2. Edit the environment variables for your account

3. Select Path → Edit → New → paste ( in this case path can be taken from powershell commnad prompt)

for eg:

4. Close and reopen PowerShell, then re-run claude --version.

> Run claude doctor - this command checks your PATH, authentication, Node.js version, and config in one shot. Always the first step when something isn't working.

Step 1.3 - Launch Claude Code and the VS Code Extension

Navigate to your project folder and launch Claude Code.

The first launch opens your browser to authenticate with your Anthropic account (Pro, Max, Team, or Enterprise all work).

For everyday ABAP work, the VS Code extension is where you'll spend most of your time.

Download and Install VS code from code.visualstudio.com for windows if you don't already have it. Once it is installed.Open VS Code, press 'Ctrl+Shift+X', search for Claude Code (published by Anthropic), and install it. Once installed, the Claude icon appears in the Activity Bar and connects automatically to your account.

The extension gives you a persistent chat panel inside VS Code - ask Claude about the file you have open, highlight any ABAP block and ask it to explain or refactor, and switch between ABAP and CAP projects in the same session. No terminal switching required.

> Note on Software Center installs: If your organization restricts installations, Claude Code for VS Code is typically available via your company Software Center / Company Portal.

Part 2 - Connecting VS Code to Your SAP System via ABAP FS

This is where the magic begins. The ABAP Remote Filesystem (ABAP FS)extension - built by Marcello Urbani - connects VS Code to your SAP system using the same ADT REST API that Eclipse uses. Once connected, your ABAP objects (programs, classes, CDS views, behavior definitions) appear as files in VS Code. Claude Code can then read, write, and review them like any local code file.

Pre-requisites Before You Connect

You'll need these four things from your SAP system before starting:

| Hostname or IP | The address of your SAP server (hostname preferred - IP causes SSL issues explained below) |

| ADT Service active | Go to transaction SICF → '/sap/bc/adt' must be activated |

| Client number| e.g. '100' - visible in the SAP logon screen |

|Username & Password| Your regular SAP development user |

| Port | HTTPS: '44300' (typical) | HTTP: '8000' for instance 00, '8001' for instance 01 |

Step 2.1 - Install and Configure ABAP FS

1. In VS Code Extensions ('Ctrl+Shift+X'), search ABAP remote filesystem by Marcello Urbani → Install.

2. Press 'Ctrl+Shift+P' → type ABAP FS: Connection Manager → open it.

3. Add a new connection and fill in the fields:

- Name: anything you like (e.g. DEV or SANDBOX)

- Server URL:'https://<hostname>:44300'

- ⚠️ Do NOT add '/sap/bc/adt' to the URL - the extension adds this automatically. If you include it, the path doubles and the connection fails.

- Client, Username, Language: 'EN'

4. Save.

5. Press 'Ctrl+Shift+P' → ABAP FS: Connect to an SAP system→ select your connection → enter password.

> ⚠️ SSL Certificate Error (very common on internal systems)

> If you see IP does not match certificate's altnames - this is because your SAP system's SSL certificate was issued with a hostname, not the IP. The fix: Get the hostname (e.g. 'https://sapdev.company.com:44300') and use that instead of the IP.

> ⚠️ADT Service Not Found

> If you see Resource /sap/bc/adt does not exist - the ADT service isn't activated. Run tcode SICF → navigate to default_host → 'sap/bc/adt' → right-click → Activate Service.

Step 2.2 - Navigating ABAP Objects

ABAP FS gives you two ways to find objects. Object Search lets you find anything by name instantly. If you prefer a tree view like Eclipse ADT, enable SAP GUI Integration in your connection settings - this gives you a full package tree (Dictionary, Source Code Library, Transactions) and even embeds SAP GUI for HTML directly inside VS Code, so you can run transactions without leaving the editor.

1. Click OBJECT SEARCH in the left sidebar

2. Type the object or package name (e.g. 'ZCL_MY_CLASS' or 'Z_MY_PACKAGE')

3. Double-click any result to open it as a text file in VS Code

4. To edit: right-click → edit → save (changes push back to SAP automatically)

Once an object is open in VS Code, open the integrated terminal (Ctrl+) and run claude. Some prompts that immediately pay off:

Part 3 -The Game Changer: Enabling the Native MCP Server

This is the step that changes everything - and the reason this post exists.

Why ABAP FS Alone Isn't Enough?

With only ABAP FS connected, Claude can see only the one file you currently have open. Ask it to create a new class and it might invent table names, function modules, or BAdI definitions that don't exist on your system. It's helpful, but it's guessing.

ABAP FS Only ABAP FS + MCP

Claude sees what we search Manually	Claude autonomously searches any object on the system
Hallucinates objects it hasn't seen	Grounded in live SAP system data
You copy-paste code manually	Claude reads, writes, activates autonomously
No transport awareness	Creates & assigns transports via ADT

The MCP (Model Context Protocol) server gives Claude Code a live connection to your SAP system's ADT API - the same backend Eclipse uses. Claude stops guessing and starts knowing.

Step 3.1 - Enable the MCP Server (One Toggle)

This is where the zero-config part comes in. You don't need to install anything extra, clone a Node.js repo, or edit JSON files manually.

Press 'Ctrl+Shift+P' → search ABAP FS MCP → select it → enable Autostart.

That's it. The ABAP FS extension spins up a local MCP server on your machine (default port 4847). You'll see a VS Code notification confirming it's running:

> ABAP MCP Server running on port 4847. External AI clients can connect to http://localhost:4847/mcp

Step 3.2 - Register the MCP Server with Claude Code

Now tell Claude Code where to find the ABAP tools. Run this in the VS Code integrated terminal:

This registers the local MCP server with Claude Code. The configuration is saved to your '.claude.json' file and persists across sessions - you only need to do this once.

Step 3.3 - Verify the Connection

open the terminal and run this command once the MCP server is added

You should see:

Claude Code will confirm when the server is registered:

> abap-remote-fs has been added with HTTP transport at http://localhost:4847/mcp"*

The Complete Architecture

Claude Code can now autonomously:

- Search and read any ABAP object on the live SAP system

- write → syntax check → activate → unlock objects

- Create transport requests and assign objects

- Run ATC checks and read short dumps - all from a plain-English prompt

> Golden - In Auto mode, Claude will write, syntax check, and activate without pausing - that's the power of the agentic workflow. If you want to review before anything is activated, switch to Plan mode shift+tab to cycle modes) Claude will show you the full plan and wait for your approval. For production-adjacent systems, always run in Plan or Step mode.

Part 4 - Live Demo: One Prompt, One Real ABAP Program on SAP

Disclaimer: This is my first time setting up all this and explore, so i just started with a very simple scenario. Going forward will create RAP objects and other complex artifacts and see the efficiency.

Let me show you what all of this enables. Here's the exact prompt I used:

> Create a new ABAP executable program ZCL_DEMO_REPORT_01 in my ZVS_DEMO package. Fetch data from MARA for a user-specified Material Number (select-option) and display Material Number, Type, and Created By in an ALV grid. Write in ABAP 7.5 syntax.

One prompt. No templates. No copy-paste. Here's what Claude did.

Act 1 - Claude Plans Before It Codes

Claude didn't immediately start writing code. It:

1. Confirmed the target package ('ZVS_DEMO') exists on the system

2. Detected that the program creation triggered a **transport request dialog** — and recognised it was the likely source of a cancellation

3. Called the SAP ADT API via Bash to **list existing open transports**

4. Selected the correct transport and retried the creation

There was a little bit delay on my end to confirm the transport. and it gave me this message.

> Package confirmed. The cancellation is likely a transport request dialog. Let me check for existing transports, then retry.

This is the part that impresses ABAP developers most. Claude handled a real SAP workflow quirk .

Act 2 - The Program Appears on SAP

Claude then created the program on the live system. You can watch its autonomous todo list mid-execution:

- Create ABAP program ZCL_DEMO_REPORT_01 in ZVS_DEMO package via MCP

- Get workspace URI for the new program

- Write ABAP source code into the program

- Activate the program and check diagnostics

'ZCL_DEMO_REPORT_01' appeared in the VS Code Explorer sidebar - a real, registered ABAP program on the SAP system, not a local file.

You can see initially there was no program created in my package

After few seconds, the program is created

Act 3 - Full ABAP 7.5 Source Code Written

With the object created, Claude fetched the workspace URI and wrote the complete source code directly into the SAP program. What it generated:

No placeholder code. Real, working ABAP in the correct syntax release, referencing actual MARA field types from the live system.

Act 4 - Running the Program

After activation, there are two ways to run it:

Option A - Classic SAP GUI:Log in to SAP GUI →run the program → Execute

Option B - Embedded SAP Web GUI(what I used): VS Code can open the SAP Web GUI directly in a browser tab, embedded inside the IDE. No separate login or window switching required.

Enter selection criteria:

The selection screen appeared with the Matnr field exactly as specified. I entered a range of 11to 21. The value help (F4) shows the available materials in the system

Material Number, Material Type, and Created By - exactly what was asked for. Live data from MARA. Report running.

Summary:

|Claude understands SAP context| It identified the transport dialog, queried existing transports via ADT, and handled a real SAP workflow quirk autonomously

| It created a real SAP object| 'ZCL_DEMO_REPORT_01' exists on the live system, created via ADT REST API through MCP - not a file on disk

| Production-quality ABAP 7.5 | TYPE declarations referencing actual MARA field types, correct naming conventions, modern SQL syntax

| Minutes, not hours| The developer's job shifts to reviewing - not writing skeletons, hunting transport dialogs, or looking up field types

| Fully iterative| Once created, you can ask Claude to add authority checks, error handling, ALV field catalogues, or additional filters - each iteration in seconds

| You stay in control | Claude's todo list is transparent - you see every step it plans. You review the code. You decide what activates

Where to Go from Here?

Here are five things to try once you have the setup working:

1. Understand inherited code - Explain the purpose and flow of report Z_*_REPORT. Include tables accessed, authority checks, deprecated patterns like SELECT .

2. Generate a CDS view - Create a CDS view hierarchy for Sales Order analysis: interface view joining VBAK+VBAP, projection view with Fiori Elements. UI annotations for a List Report.

3. Build a Travel Request POC - RAP Business Object with CRUD, approve/reject action, draft handling, OData V4 binding, Fiori Elements UI.

4. Write ABAP Unit tests - Generate a unit test class

5. Code review and modernization - Review this class for Clean ABAP violations, missing authority checks, SELECT * usage, and SELECT inside LOOP. Propose S/4-equivalent replacements.

The bottom line: The integration that used to require manual Node.js setup, JSON editing, and external package management now takes a single Ctrl+Shift+P toggle and one terminal command.

The ABAP Remote Filesystem team has done the hard work. Claude Code does the coding. You do the review.

Give it a try - and let me know in the comments what use case you tackle first.

A personal note : This is my first time diving deeper into vibe coding and MCP concepts. I come from a classic ABAP background, and everything covered here - from the VS Code setup to the MCP server to the live demo - I explored and built from scratch over the past few weeks. The scenario is intentionally simple. The goal was to get the fundamentals right, document them honestly, and share what works. There is a lot more ground to cover - RAP generation at scale, Clean Core extensibility patterns, ATC pre-checks via Claude Code, and deeper agentic workflows. I'll be going further in the posts ahead. If you're also just getting started with this, I hope this gives you a solid, working foundation to build on. And if you're already further ahead - I'd love to hear what you've learnt in the comments.

Note: All screenshots in this post are taken from a live S/4HANA development system. Code generated by Claude Code should always be reviewed and tested in a sandbox environment before activation in any productive system.

Join Us Tomorrow: SAP BTP ABAP Environment Customer & Partner Roundtable – July 2026

2026-07-06T11:59:12.566000+02:00

Dear customers and partners,

Join us tomorrow for the next session of our SAP BTP ABAP Environment Customer & Partner Roundtable, taking place on July 07, 2026, from 10:00–11:00 CET.

Our roundtable is a monthly virtual meeting where we share the latest updates from the product team and showcase selected topics from our experts. It is a great opportunity to stay up to date with the latest capabilities of the SAP BTP ABAP Environment, ask questions, and engage with the community.

Join the session

📅 Date: July 07, 2026
⏰ Time: 10:00–11:00 CET

Agenda

🔹 Product Updates – Frank Jentsch

🔹 New ABAP Language Features - Cedric Becker, Rolf Hammer

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!

SAP BTP ABAP Environment Team

Lernen verbindet – Entdecke unsere 🇩🇪 deutschsprachigen 🇩🇪 Live Sessions in Q3

2026-07-06T18:19:45.569000+02:00

Q3 ist in vollem Gange. Welche Themen möchtest du dieses Quartal noch entdecken?

Vielleicht gibt es ein Thema, das schon länger auf deiner Lernliste steht. Vielleicht möchtest du dein Wissen vertiefen oder einfach neue Impulse mitnehmen.

Unsere deutschsprachigen SAP BTP Live Sessions bieten die Gelegenheit dazu. Von Grundlagen über Integration und Entwicklung bis hin zu Architektur- und Automatisierungsthemen wartet ein vielfältiges Lernangebot auf dich.

Vielleicht ist genau die Session, die dich weiterbringt, bereits Teil des aktuellen Programms:

https://community.sap.com/t5/technology-platform-learning-group-blog-posts/new-sap-btp-live-sessions-auf-deutsch/ba-p/14415241

Also welches Thema möchtest du in Q3 noch entdecken?

Wir sehen uns in den Live Sessions!

How to Implement SAP Change Document

2026-07-09T17:19:07.404000+02:00

Introduction:

If you have ever been asked the question — who changed that field, and when — you will immediately appreciate why change documents matter. In any serious SAP implementation, traceability is not a nice-to-have. It is a business requirement, often driven by audit, compliance, or simply the need to investigate data quality issues after the fact.

SAP provides a standard, reliable framework for exactly this purpose: Change Documents. Once set up, every create, update, and delete operation on your custom tables produces a detailed, timestamped record of exactly what changed, written automatically to two standard SAP tables — CDHDR and CDPOS. No custom logging table, no triggers, no background jobs. The framework handles it all.

In this blog series, we will walk through a complete implementation from scratch. We will use a realistic example — a customer master with header information and associated bank accounts — to show how change documents work in practice, and how to build a clean, reusable ABAP class that wraps both the database operations and the change document recording in a single, easy-to-call interface.

What are Change Documents?

Change Documents are SAP’s built-in audit trail mechanism for custom business objects. When correctly implemented, every time a record in your custom table is created, modified, or deleted, SAP automatically captures:

Who made the change — the SAP user name
When the change was made — date and time
Which transaction or program triggered the change
Which fields changed — at field level
What the old value was
What the new value is

This information is stored across two standard SAP tables that you never need to create or manage yourself.

How does the Framework Work?

The change document framework does not intercept your database calls automatically. You have to call it explicitly. The framework works as follows:
Everything starts with the creation of the Change Document Object. This can be done in ADT or in transaction SCDO. Here, you define a named Change Document Object and assign your custom tables to it. Whether the field change will be tracked or not depends on the flag set in the Data Element. In ADT, as soon as you activate the object, it generates a class with a method WRITE. If you are using SAP GUI transaction(SCDO), you have the option to generate either a class or a function module.

Your Responsibility

The generated class method (WRITE) does one thing only — it compares the old and new versions of your data that you pass to it, and writes the differences to CDHDR and CDPOS. It does not touch your Z tables at all. That means your code is responsible for two things in the correct order:

Write to your Z tables using INSERT, MODIFY, or DELETE
Call the generated class method/FM, passing it both the old and new versions of the data

In the case of a Managed RAP application, the call is handled automatically by the framework. We do have to specify the Change Document Object in the Behaviour Definition.

Both operations must happen within the same Logical Unit of Work, so they commit together. If the database update succeeds but the FM call fails, you want a rollback – not a situation where your data changed, but no change document was recorded.

This is the most important point to understand. The method cannot read old values from the database itself — by the time you call it, your MODIFY statement may have already overwritten the old data. You must read the old values from the database before making any changes, hold them in memory, and pass them to the FM alongside the new values.

In the case of a Managed RAP application, the call is handled automatically by the framework. We do have to specify the Change Document Object in the Behaviour Definition.

Tables

We are going to work with two tables ZZCUSTOMER and ZZCUSTOMER_BANK. This is a typical header item table. I am going to work with UUID as key as I will extend these to the RAP application later. I have used SAP Data Elements for fields. These Data Elements for fields NAME, STREET, CITY, POSTAL_CODE, COUNTRY etc. have ‘Change Document Logging’ checked.

@EndUserText.label : 'Customer'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #A
@AbapCatalog.dataMaintenance : #RESTRICTED
define table zzcustomer {
 
  key client            : abap.clnt not null;
  key customer_id       : sysuuid_x16 not null;
  name                  : ad_name1;
  street                : ad_street;
  city                  : ad_city1;
  postal_code           : ad_pstcd1;
  country               : land1;
  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_lastchange_tstmpl;
  last_changed_at       : abp_lastchange_tstmpl;
}

@EndUserText.label : 'Customer Bank Details'
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #A
@AbapCatalog.dataMaintenance : #RESTRICTED
define table zzcustomer_bank {
 
  key client            : abap.clnt not null;
  key bankid            : sysuuid_x16 not null;
  customer_id           : sysuuid_x16;
  bank_country          : banks not null;
  bank_key              : bankk not null;
  bank_account          : bankn;
  currency              : waers;
  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_lastchange_tstmpl;
  last_changed_at       : abp_lastchange_tstmpl;
}

Change Document Object

Create Change Document Object in ADT or in transaction SCDO (I’ve used ADT). Add tables ZZCUSTOMER and ZZCUSTOMER_BANK. Check ‘Log Multiple Changes’ in both tables. Activate. You will notice it will create a class (ZCL_ZZCUSTOMER_CHDO) and show it just under the Change Document.

Wrapper Class

This class acts as a combined repository and audit layer — all database INSERT, MODIFY, DELETE operations on ZZCUSTOMER and ZZCUSTOMER_BANK go through this class, which also records the change document automatically. The caller simply calls the method and then COMMIT WORK.

Definition

CLASS zcl_customer_change_wrapper DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .
 
  PUBLIC SECTION.
 
    METHODS create
      IMPORTING
        is_hdr TYPE zzcustomer
        it_dtl TYPE zzcustomerbank_t
      RAISING
        cx_sy_open_sql_error.
 
    METHODS update
      IMPORTING
        is_hdr TYPE zzcustomer
        it_dtl TYPE zzcustomerbank_t
      RAISING
        cx_sy_open_sql_error.
 
    METHODS delete
      IMPORTING
        iv_customer_id TYPE zzcustomer-customer_id
      RAISING
        cx_sy_open_sql_error.
 
  PROTECTED SECTION.
  PRIVATE SECTION.
 
    METHODS call_write_document
      IMPORTING
        iv_customer_id          TYPE zzcustomer-customer_id
        object_change_indicator TYPE if_chdo_object_tools_rel=>ty_cdchngindh
        it_hdr_new              TYPE zcl_zzcustomer_chdo=>tt_zzcustomer
        it_hdr_old              TYPE zcl_zzcustomer_chdo=>tt_zzcustomer OPTIONAL
        it_dtl_new              TYPE zcl_zzcustomer_chdo=>tt_zzcustomer_bank
        it_dtl_old              TYPE zcl_zzcustomer_chdo=>tt_zzcustomer_bank OPTIONAL.
 
 
    METHODS read_current_customer
      IMPORTING
        iv_customer_id TYPE zzcustomer-customer_id
      RETURNING
        VALUE(rs_hdr)  TYPE zzcustomer.
 
    METHODS read_current_customer_bank
      IMPORTING
        iv_customer_id TYPE zzcustomer-customer_id
      RETURNING
        VALUE(rt_dtl)  TYPE zzcustomerbank_t.
ENDCLASS.

Class Implementation

Method `CREATE`

METHOD create.
  SELECT SINGLE customer_id FROM zzcustomer
      WHERE customer_id = @IS_hdr-customer_id
      INTO @DATA(lv_exists).
 
  IF sy-subrc = 0.
    RAISE EXCEPTION TYPE cx_sy_open_sql_error.
  ENDIF.
 
  DATA it_hdr_new TYPE zcl_zzcustomer_chdo=>tt_zzcustomer .
  DATA it_dtl_new TYPE zcl_zzcustomer_chdo=>tt_zzcustomer_bank .
 
  APPEND INITIAL LINE TO it_hdr_new ASSIGNING FIELD-SYMBOL(<chgdoc_hdr>).
  MOVE-CORRESPONDING is_hdr TO <chgdoc_hdr> .
  <chgdoc_hdr>-kz = 'I' .
 
  LOOP AT it_dtl ASSIGNING FIELD-SYMBOL(<new_record>) .
    APPEND INITIAL LINE TO it_dtl_new ASSIGNING FIELD-SYMBOL(<chgdoc_dtl>) .
    MOVE-CORRESPONDING <new_record> TO <chgdoc_dtl> .
    <chgdoc_dtl>-kz = 'I' .
  ENDLOOP.
 
 
  INSERT zzcustomer FROM @IS_hdr.
  INSERT zzcustomer_bank FROM TABLE @IT_dtl.
 
  " Change doc
  call_write_document(
    object_change_indicator = 'U'
    iv_customer_id          = is_hdr-customer_id
    it_hdr_new              = it_hdr_new
    it_dtl_new              = it_dtl_new ).
 
ENDMETHOD.

The object_change_indicator was passed value ‘U’ instead of ‘I’ to align with how the change document works in RAP.

Method `UPDATE`

METHOD update.
 
  " Read old state from DB before modifying
  DATA(ls_hdr_old) = read_current_customer( is_hdr-customer_id ).
  DATA(lt_dtl_old) = read_current_customer_bank( is_hdr-customer_id ).
 
  DATA it_hdr_old TYPE zcl_zzcustomer_chdo=>tt_zzcustomer .
  DATA it_dtl_old TYPE zcl_zzcustomer_chdo=>tt_zzcustomer_bank .
  DATA it_hdr_new TYPE zcl_zzcustomer_chdo=>tt_zzcustomer .
  DATA it_dtl_new TYPE zcl_zzcustomer_chdo=>tt_zzcustomer_bank .
 
  APPEND ls_hdr_old TO it_hdr_old .
  APPEND LINES OF lt_dtl_old TO it_dtl_old .
 
  APPEND INITIAL LINE TO it_hdr_new ASSIGNING FIELD-SYMBOL(<chgdoc_hdr>).
  MOVE-CORRESPONDING is_hdr TO <chgdoc_hdr> .
  <chgdoc_hdr>-kz = 'U' .
  <chgdoc_hdr>-client = sy-mandt .
 
  LOOP AT it_dtl ASSIGNING FIELD-SYMBOL(<new_record>) .
    APPEND INITIAL LINE TO it_dtl_new ASSIGNING FIELD-SYMBOL(<chgdoc_dtl>) .
    MOVE-CORRESPONDING <new_record> TO <chgdoc_dtl> .
    <chgdoc_dtl>-kz = 'U' .
    <chgdoc_dtl>-client = sy-mandt .
  ENDLOOP.
 
  MODIFY zzcustomer FROM @IS_hdr.
  MODIFY zzcustomer_bank FROM TABLE @IT_dtl.
 
  " Change doc
  call_write_document(
    object_change_indicator = 'U'
    iv_customer_id          = is_hdr-customer_id
    it_hdr_new              = it_hdr_new
    it_hdr_old              = it_hdr_old
    it_dtl_new              = it_dtl_new
    it_dtl_old              = it_dtl_old  ).
 
ENDMETHOD.

Method `DELETE`

METHOD delete.
 
  "Read old state from DB before modifying
  DATA(ls_hdr_old) = read_current_customer( iv_customer_id ).
  DATA(lt_dtl_old) = read_current_customer_bank( iv_customer_id ).
 
  DATA it_hdr_old TYPE zcl_zzcustomer_chdo=>tt_zzcustomer .
  DATA it_dtl_old TYPE zcl_zzcustomer_chdo=>tt_zzcustomer_bank .
  DATA it_hdr_new TYPE zcl_zzcustomer_chdo=>tt_zzcustomer .
  DATA it_dtl_new TYPE zcl_zzcustomer_chdo=>tt_zzcustomer_bank .
 
  APPEND ls_hdr_old TO it_hdr_old .
  APPEND LINES OF lt_dtl_old TO it_dtl_old .
 
  "Delete detail first, then header (referential integrity)
  DELETE FROM zzcustomer WHERE customer_id = @iv_customer_id.
  DELETE FROM zzcustomer_bank WHERE customer_id = @iv_customer_id.
 
  " Change doc
  call_write_document(
    object_change_indicator = 'D'
    iv_customer_id          = iv_customer_id
    it_hdr_new              = it_hdr_new
    it_hdr_old              = it_hdr_old
    it_dtl_new              = it_dtl_new
    it_dtl_old              = it_dtl_old  ).
 
ENDMETHOD.

Private helpera methods `CALL_WRITE_DOCUMENT`, `READ_CURRENT_CUSTOMER`, `READ_CURRENT_CUSTOMER_BANK`

METHOD call_write_document.
  TRY .
      zcl_zzcustomer_chdo=>write(
        EXPORTING
                      objectid                = CONV cdobjectv( iv_customer_id )
                      tcode                   = sy-tcode
                      utime                   = sy-uzeit
                      udate                   = sy-datum
                      username                = sy-uname
                      object_change_indicator = object_change_indicator
                      xzzcustomer             = it_hdr_new
                      yzzcustomer             = it_hdr_old
                      upd_zzcustomer          = 'U'
                      xzzcustomer_bank        = it_dtl_new
                      yzzcustomer_bank        = it_dtl_old
                      upd_zzcustomer_bank     = 'U'
        IMPORTING
                      changenumber            = DATA(change_number)
      ).
 
    CATCH cx_chdo_write_error.
  ENDTRY.
ENDMETHOD.
 
 
METHOD read_current_customer_bank.
  SELECT * FROM zzcustomer_bank
    WHERE customer_id = @iv_customer_id
    INTO TABLE @RT_dtl.
ENDMETHOD.
 
METHOD read_current_customer.
  SELECT SINGLE * FROM zzcustomer
    WHERE customer_id = @iv_customer_id
    INTO @RS_hdr.
ENDMETHOD.

Usage Example

Testing: Create a New Customer

DATA: current_time TYPE timestampl,
      customer_id  TYPE zzcustomer-customer_id,
      bank_id      TYPE zzcustomer_bank-bankid.
 
GET TIME STAMP FIELD current_time.
"Get UUIDs for keys
customer_id = cl_system_uuid=>create_uuid_x16_static( ).
bank_id     = cl_system_uuid=>create_uuid_x16_static( ).
 
DATA(lo_cust) = NEW zcl_customer_change_wrapper( ).
 
lo_cust->create(
            is_hdr = VALUE zzcustomer(
                              customer_id           = customer_id
                              name                  = 'ABC Company'
                              street                = 'Long Street'
                              city                  = 'London'
                              postal_code           = 'EC10 5GH'
                              country               = 'GB'
                              local_created_by      = sy-uname
                              local_created_at      = current_time
                              local_last_changed_by = sy-uname
                              local_last_changed_at = current_time
                              last_changed_at       = current_time
                           )
            it_dtl = VALUE zzcustomerbank_t(
                                ( bankid = bank_id
                                  customer_id           = customer_id
                                  bank_country          = 'GB'
                                  bank_key              = '123456'
                                  bank_account          = '123456789'
                                  currency              = 'GBP'
                                  local_created_by      = sy-uname
                                  local_created_at      = current_time
                                  local_last_changed_by = sy-uname
                                  local_last_changed_at = current_time
                                  last_changed_at       = current_time
                            )
         )
  ).
 
COMMIT WORK.

Check table ZZCUSTOMER, ZZCUSTOMER_BANK, CDHDR and CDPOS.

Testing: Update Customer

DATA: current_time TYPE timestampl.
 
GET TIME STAMP FIELD current_time.
 
DATA(lo_cust) = NEW zcl_customer_change_wrapper( ).
 
  "Get customer_id and bank_id UUIDs from table ZZCUSTOMER and ZZCUSTOMER_BANK
lo_cust->update(
        is_hdr = VALUE zzcustomer(
                          customer_id = '005056A3C6531FD18AECAF7C7E10D978'
                          name                  = 'XYZ Company'        "<< Change
                          street                = 'New Long Street'    "<< Change
                          city                  = 'London'
                          postal_code           = 'EC10 5GH'
                          country               = 'GB'
                          local_created_by      = sy-uname
                          local_created_at      = current_time
                          local_last_changed_by = sy-uname
                          local_last_changed_at = current_time
                          last_changed_at       = current_time
                        )
        it_dtl = VALUE #(
                            ( bankid                = '005056A3C6531FD18AECAF7C7E10F978'
                              customer_id           = '005056A3C6531FD18AECAF7C7E10D978'
                              bank_country          = 'GB'
                              bank_key              = '30-40-50'   "<< Change
                              bank_account          = '123456789'
                              currency              = 'GBP'
                              local_created_by      = sy-uname
                              local_created_at      = current_time
                              local_last_changed_by = sy-uname
                              local_last_changed_at = current_time
                              last_changed_at       = current_time
                            )
                         )
 ).
 
COMMIT WORK.

Check table ZZCUSTOMER, ZZCUSTOMER_BANK, CDHDR and CDPOS.

Testing: Delete Customer

DATA(lo_cust) = NEW zcl_customer_change_wrapper( ).
 
"Get customer_id UUID from table ZZCUSTOMER
lo_cust->delete( iv_customer_id =  '005056A3C6531FD18AECAF7C7E10D978' ) .
COMMIT WORK.

Check table ZZCUSTOMER, ZZCUSTOMER_BANK, CDHDR and CDPOS.

Conclusion

Implementing a reliable audit trail doesn't require complex custom logging logic or performance-heavy database triggers. As shown in this guide, leveraging SAP’s standard Change Document Framework (SCDO) gives you a robust, compliant, and optimized solution right out of the box.

By wrapping both the database persistence layers (INSERT, MODIFY, DELETE) and the tracking mechanisms inside a single ABAP wrapper class, we successfully encapsulate the business logic. This pattern ensures that:

Data consistency is maintained via atomic operations (both the Z-tables and the CD tables update within the same Logical Unit of Work).
Code reusability is enhanced, hiding the boilerplate logic of tracking old vs. new memory states from caller programs.
Future readiness is built-in, paving a clean path if you decide to extend these custom tables into a Managed RAP (RESTful Application Programming) architecture down the line.

With CDHDR and CDPOS tracking your field-level changes seamlessly behind the scenes, answering "who changed what, and when" becomes a trivial task rather than a development headache.

Start remote Process/Actions in BTP ABAP via Task Chains from SAP Datasphere

2026-07-14T16:00:19.634000+02:00

Modern cloud architectures allow for versatile and open interoperability. So does SAP Datasphere and SAP BTP ABAP, too. This example outlines some essentials how Datasphere can kick-off actions defined on the ABAP Cloud side, beyond system boundaries.

Starting a Task/Process in BTP ABAP remotely from SAP Datasphere using Task Chains opens up new scenarios for interoperability and integration. The goal is to orchestrate remote tasks initiated by SAP Datasphere — securely, programmatically, and fully automated.

We will cover the below points:

Creating a Task Chain in Datasphere including an API Call to ABAP Cloud
Connection in Datasphere to ABAP Cloud (for direct API call)
Setting up Communication System & Arrangement in ABAP Cloud
Executing the Task Chain in Datasphere: Trigger actions in ABAP Cloud

1 Architecture Overview

Architecture

The SAP Datasphere Task Chain API Task: Datasphere acts as the caller. ABAP Cloud exposes an endpoint (inbound Web Api) to trigger an action.

Option (2) and (3) complete the picture of possible solution approaches. Main differences as well as pros & cons are outlined further down in one of the last sections.

The Solution Architecture displays 3 different options:

(1) Use Direct API Integration

Straightforward
Minimal cost and complexity
Perfect for nightly batch orchestration, event-driven data loads, or simple API-driven analytical data refresh

(2) Integration Suite

Integration involves complex message transformations, protocol mediation, multiple target systems, or when centralized API governance and monitoring across the enterprise are required.
Especially appropriate where iFlow reusability justifies the additional cost and setup effort or when integration suite is already in place and a common tool.

(3) CAP Application

Custom application logic is needed beyond what a direct API call/iFlow can provide
E.g. multi-source data aggregation, advanced parsing, enrichments
Additional persistence required
Well-suited for reusable microservice-style integrations on BTP

2 Prerequisites

You need

SAP Datasphere tenant with developer + admin access
Task Chain to design the flow of events
SAP BTP ABAP Environment (ABAP Cloud) with developer access
BTP ABAP: Authorization for OAuth clients, Communication Arrangements, ABAP development of Web APIs

3 Creating Communication Artifacts in ABAP Cloud

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

Communication Arrangement

Communication System

Communication System 1

Communication/Connection User:

Create a User for Inbound Communication and use the same in the subsequent step on Datasphere level for the creation of a generic HTTP connection.

4 ABAP Cloud Artifacts

For the sake of simplicity I won't go into the details of all of the development artifacts and configuration settings.

For sure, you will create:

Inbound Service
Service Binding
Communication Scenario BTP ABAP
Service Definition
Entity
Class implementation

An example of an action definition processData (ZI_DEMO_SERVICE):

managed implementation in class zbp_i_demo_service unique;

define behavior for ZI_DEMO_SERVICE alias DemoService
persistent table zdemoservice
lock master
{
  field ( readonly ) Id;
  field ( numbering : managed ) Id;

  create;
  update;
  delete;

  action processData result [1] zdemoservice;

  mapping for zdemoservice
  {
    Id = id;
    Name = name;
    Description = description;
    Status = status;
    CreatedBy = created_by;
    CreatedAt = created_at;
    LastChangedBy = last_changed_by;
    LastChangedAt = last_changed_at;
    LocalLastChanged = local_last_changed;
  }
}

An example of an ABAP Class with an action implementation:

CLASS lhc_DemoService DEFINITION INHERITING FROM cl_abap_behavior_handler.
  PUBLIC SECTION.
 
    PRIVATE SECTION.
 
    METHODS processData FOR MODIFY
      IMPORTING keys FOR ACTION DemoService~processData result result.
 
ENDCLASS.
 
CLASS lhc_DemoService IMPLEMENTATION.
  
  METHOD processData.
    " Your business logic implementation her
  ENDMETHOD.
ENDCLASS.

Service Definition:

@EndUserText.label: 'Demo Service Definition'
define service ZUI_DEMO_SERVICE {
  expose ZC_DEMO_SERVICE as DemoService;
}

Inbound Service:

Communication Scenario:

5 Create a Connection

The first step is creating a generic HTTP connection to the endpoint exposed by ABAP Cloud. In order to do so, consider the following details. Take the connection host from the BTP ABAP instance key. The credentials must be taken from the connection user as defined in the communication arrangement.

An alternative to Username/Password is an OAuth based authentication mechanism.

6 Creating a Task Chain in SAP Datasphere

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

In the given example:

The Task Chain starts with a API Task
Sends an email in case of success

Task Chain

In the API Task details, define the following:

Method POST
API Path - the path to the service endpoint of your ABAP Web API that you want to trigger
Mode Synchronous

API Task Details 1

Make sure to fetch the CSRF Token. The URL which I've used is simply the $metadata path of the service endpoint:

https://<ABAP_HOST>.abap.eu10.hana.ondemand.com/sap/opu/odata/sap/ZUI_DEMO_SERVICE_O4/$metadata

7 Execution Results

The Task Chain in Datasphere successfully executed the ABAP Web API call:

Task Chain API successfully executed

For monitoring and troubleshooting purpose, individual API calls can be traced from BTP ABAP side. The HTTP trace can be turned on for granular levels.

8 Solution Options - Comparisons

The following comparison outlines the key aspects per solution/architecture option as depicted in the initial architecture diagram. I have prototyped all of the below and all options are working flawlessly. Especially w.r.t. to the CAP based solution, there is a wide open room to play with.

Option	Pros (+)	Cons (-)
(1) Direct API	Simplest setup & fewest components & lowest cost No middleware latency Lightweight and developer-friendly	Limited transformation capability Less suitable for multi-step or conditional routing logic
(2) Integration Suite	Supports complex transformations, multiple protocols and error handling in iFlows Centralized API governance via API Management Recommended for complex mediated flows	Two-step connectivity required (Integration Suite + Datasphere) Additional licensing cost Higher setup and maintenance effort
(3) CAP CF App	Maximum flexibility for custom logic (parsing, filtering, enrichment, retry) CAP integrates natively with HANA Cloud/Datasphere HDI Supports secure credential management Reusable microservice pattern	Requires application development and BTP CF deployment skills Higher operational overhead More BTP resource consumption CAP app lifecycle must be managed independently

9 Conclusion/Outlook & Further aspects:

Overview of the major building blocks:

Capability	Result
No hardcoded secrets	via Communication Arrangements/System
Remote orchestration	Creating an end-to-end orchestrated chain of tasks, bidirectional if required
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)
API-driven (transactional/analytical) data refresh

Limitations:

The Task Chain/API Task can't be parameterized dynamically with runtime parameters to e.g. initiate calls that have a variable payload in header or body
Moreover, the write-back/storing of HTTP responses is limited too

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/274f2736465c4c48a091c67588...

This blog entry complements my other blog on Triggering SAP Datasphere/BDC Task Chains from SAP BTP ABAP Cloud using the Task Chain REST API.

In case of questions feel free to raise them and please leave a comment if you found something incorrect - thanks for any help on that. I'm hoping this blog can support somebody out there and may facilitate some problem solving.

The paging catastrophe

2026-07-20T05:50:04.703000+02:00

Introduction

In the late 19th century, the scientific community started to face unexpected issues, some of them quite serious, upon proven experiments for which no accepted formula was able to produce reasonable prediction or explanation. This originated the entire collapse of the current physics, now called ‘classic physics’, into a new frame ignited by the quantum mechanics. The game-changing problem was named ‘the ultraviolet catastrophe’.

Similarly to what happened back then –hopefully less ontologically problematic–, the SAP transition from classic to Fiori-oriented development brings about some anomalies not especially easy to overcome without a systemic revolution of the technology itself. One of the problems we have experienced regards the paging mechanism when rendering a Fiori list report via back-end OData service.

Context

Let’s assume the following scenario:

On-premise OData service.
BTP Fiori list report application consuming the back-end service via custom entity.
1. Respecting the Clean Core principles, the report combines information from the back-end –only read–, and local BTP tables. To ensure integrity, the key fields are the same on both sides.
2. Consequently, the selection filters can refer to both back-end and BTP fields.
The BTP application, fields and tables underneath dominate the entire execution engine. This is to say, BTP-located filtering, if any, must lead the back-end selection.

Case 1: No BTP pre-filtering or post-filtering

Scenario

No BTP-located filter fields are set, so there is no need to implement BTP filtering before or after the service call. In real executions, this is not very likely to happen, but anyway interesting to start exposing the problem.

Behaviour

All pages are correctly delivered through scrolling. Considering n items are hit in the back-end, when reaching the last page, all of them are rendered.

Case 2: BTP post-filtering

Scenario

Here, BTP-located filter fields are set. The idea is to retrieve matching information from the back-end and, next, filter by the BTP conditions.

Behaviour

If the page is not reduced during the post filtering, i.e., no line is impacted by the BTP filtering, then it is correctly shown and the scroll for the next one continues to be enabled.

Else, if the page size is reduced, the system considers it is the last so no more scrolling is enabled; even trying to scroll down no more service calls are run. The page cropping leads then to missing information.

Case 3: BTP pre-filtering

Scenario

If the post-filtering does not work, why not first filter in BTP and then use the key fields to retrieve from the back-end only exactly what is needed?

Behaviour

Here, x items are pre-filtered in BTP. If, additionally, back-end filtering is set, the final number of retrieved items, say n, can potentially be less than x.

Anyway, the strategy seems finely focused but the problem arises when too many items are pre-filtered so the URL to call the service is too long to be accepted and leads to an exception.

Case 4: Split BTP pre-filtering

Scenario

Considering some trust was put in the previous step, maybe we could split the filtering and manually call the service in small packages to avoid problems with the URL.

Behaviour

To avoid the cropped page problem, the main purpose is to always build complete pages to keep the execution alive; otherwise, it stops. The challenge is to seamlessly advance through packages as if no additional calls were executed.

In BTP, x items are filtered and supposed to be sent to the back-end. The URL length is first checked:

If it is short enough to be accepted, then no split is needed and the call can be executed as conventionally.
In other case, the logic will split the x items into small packages of s; the package size must be greater than the page size so as to avoid the scroll disabling.

For the first call, the s items hit n back-end items, so the report counter shows n as the total number of items, but this value is not correct, as there are more items waiting to be sent.

By scrolling down, the complete list of n items related to the first package is delivered correctly, so for now no need to process other packages.

If the current page size is less than the determined size, i.e., if the page is cropped, this means we have reached the end of the package, so the next one can be processed.

The next package is then processed making sure the skip is reset to retrieve all back-end hits from the beginning. The cropped page is then completed with p - q items from the new package.

For next page the skip is automatically set to the page size and because there is no option to keep track of the actual index we are in –stateless processing–, a gap of missing information can occur.

Conclusions

The development of BTP reports via custom entities where local filtering is supposed to restrain the information coming from the back-end introduces a series of problems not easy to overcome. Business may claim classic development where all the data and logic was set on-premise did not carry this type of problems.

As it happened to physics, the transition to modern SAP development presents by comparison some obstacles for which quick adaptation is needed. The answer to this problem, something like quantum mechanics in our recurrent reference, goes through using a more powerful technology; for the time being, external entities based on HANA virtual tables are the best alternative to avoid the paging catastrophe.

Parallel Processing in ABAP using SPTA Framework

2026-07-20T05:53:27.534000+02:00

Introduction:

During my SAP ABAP development experience, I have worked on reports and interfaces that process large volumes of business data. One challenge I frequently noticed is that even well-written ABAP programs can become slow when they process thousands of records sequentially. As data volume grows, runtime increases significantly, affecting overall system performance and the user experience.

While exploring different performance optimization techniques, I came across the SPTA (SAP Parallel Task Administration) framework. What interested me most was that SAP already provides a standard mechanism to execute workloads in parallel instead of requiring developers to build a custom parallel processing solution from scratch. The framework takes care of distributing work packets, managing parallel tasks, utilizing available work processes, and collecting the results after processing is complete.

To better understand how SPTA works internally, I built a simple prototype instead of directly using a business scenario. The example generates random data, splits it into multiple work packets, processes each packet in parallel, and finally combines the results. This hands-on exercise helped me understand the complete flow of parallel processing and how the framework manages task execution behind the scenes.

In this blog, I will walk through the same example step by step, explain the key components involved, and share the learnings I gained while implementing the SPTA framework. I hope this practical approach helps anyone who is getting started with parallel processing in SAP ABAP.

What is SPTA Framework?

SPTA is a standard SAP framework designed to execute independent units of work in parallel. It internally manages:

Allocation of available work processes

Load balancing across application servers

Asynchronous RFC execution

Work packet management

Error handling and task synchronization

Collection of results after task completion

Instead of manually creating asynchronous RFC tasks using STARTING NEW TASK, developers can leverage the SPTA framework to simplify implementation and improve maintainability.

Solution Overview-

The program follows the below execution flow:

The framework repeatedly executes these callback routines until all records are processed.

TYPE-POOLS: spta.
TYPES: BEGIN OF ty_final,
        number TYPE char3,
        index TYPE char3,
       END OF ty_final.

TYPES: BEGIN OF ztest_random_data,
         number TYPE char3,
         index  TYPE char3,
       END OF ztest_random_data.

TYPES ztest_random_data_t TYPE STANDARD TABLE OF ztest_random_data
                          WITH EMPTY KEY.
DATA:
      it_random TYPE ztest_random_data_t,
      it_final TYPE STANDARD TABLE OF ty_final,
      v_max_no_of_tasks TYPE syindex.

* Create random numbers
PERFORM f_create_random_no.
* Write random numbers before calling parallel processing
PERFORM f_write_random_rec.

 "Fetch the server group
  SELECT SINGLE classname
  INTO @DATA(lv_server_grp)
  FROM rzllitab
  WHERE grouptype = 'S'.

  IF sy-subrc NE 0.
    RETURN.
  ENDIF.

* Calling the function module to invoke parallel processing
* framwork

CALL FUNCTION 'SPTA_PARA_PROCESS_START_2'
  EXPORTING
    server_group             = lv_server_grp
    before_rfc_callback_form = 'BEFORE_RFC'
    in_rfc_callback_form     = 'IN_RFC'
    after_rfc_callback_form  = 'AFTER_RFC'
    callback_prog            = 'ZTEST_SPTA_FRAME_WORK'
  CHANGING
    user_param               = it_random
  EXCEPTIONS
    invalid_server_group     = 1
    no_resources_available   = 2
    OTHERS                   = 3.

*&---------------------------------------------------------------------*
*&      Form  BEFORE_RFC
*&---------------------------------------------------------------------*
* In this routine work packets are prepared for parallel processing   *
* also check the variable for downstream processing                    *
*----------------------------------------------------------------------*
FORM before_rfc
    USING    is_before_rfc_imp     TYPE spta_t_before_rfc_imp
    CHANGING es_before_rfc_exp     TYPE spta_t_before_rfc_exp
             it_rfcdata            TYPE spta_t_indxtab
             ct_failed_objects     TYPE spta_t_failed_objects
             et_objects_in_process TYPE spta_t_objects_in_process
             it_data               TYPE ztest_random_data_t.

  DATA: l_counter     TYPE i,
        l_no_of_items TYPE i,
        it_final TYPE ztest_random_data_t,
        wa_data TYPE ztest_random_data.

* Create small work packets for parallel processing
* This is custom logic
  l_no_of_items = 10.    " One work packet will contain 10 records

  LOOP AT it_data INTO wa_data.
* Read and move specified number of records
    IF ( l_counter < l_no_of_items
      AND wa_data IS NOT INITIAL ).
      APPEND wa_data TO it_final.
      DELETE it_data INDEX 1.
      l_counter = l_counter + 1.
    ELSE.
      EXIT.
    ENDIF.
  ENDLOOP.

* Convert the input data into the INDX structure that is needed for the RFC
  CALL FUNCTION 'SPTA_INDX_PACKAGE_ENCODE'
    EXPORTING
      data    = it_final
    IMPORTING
      indxtab = it_rfcdata.

* This is mandatory step
* inform task manager that an rfc can be started from the data compiled
  IF it_final IS NOT INITIAL.
    es_before_rfc_exp-start_rfc = 'X'.
  ELSE.
    CLEAR es_before_rfc_exp-start_rfc.
    RETURN.
  ENDIF.

ENDFORM.                    " BEFORE_RFC_CALLBACK_FORM
*&---------------------------------------------------------------------*
*&      Form  IN_RFC
*&---------------------------------------------------------------------*
*  In this routine create own RFC enabled FM or write logic in this    *
*  routine                          *
*----------------------------------------------------------------------*
FORM in_rfc
         USING is_in_rfc_imp         TYPE spta_t_in_rfc_imp "#EC NEEDED
         CHANGING es_in_rfc_exp      TYPE spta_t_in_rfc_exp
                  it_rfcdata         TYPE spta_t_indxtab.

  DATA: it_final TYPE ztest_random_data_t.

* Decode the data from the INDX Structure into the process work list
  CALL FUNCTION 'SPTA_INDX_PACKAGE_DECODE'
    EXPORTING
      indxtab = it_rfcdata
    IMPORTING
      data    = it_final.

* Simple logic to sort data
  SORT it_final BY number.

* Again Encode output data for AFTER_RFC form
  CALL FUNCTION 'SPTA_INDX_PACKAGE_ENCODE'
    EXPORTING
      data    = it_final
    IMPORTING
      indxtab = it_rfcdata.

ENDFORM.                    "in_rfc
*&---------------------------------------------------------------------*
*&      Form  AFTER_RFC
*&---------------------------------------------------------------------*
* In this routine we have to collect date after parallel processing    *
*----------------------------------------------------------------------*
FORM after_rfc
     USING it_rfcdata            TYPE spta_t_indxtab
           if_rfcsubrc           TYPE sy-subrc
           if_rfcmsg             TYPE spta_t_rfcmsg
           it_objects_in_process TYPE spta_t_objects_in_process "#EC NEEDED
           is_after_rfc_imp      TYPE spta_t_after_rfc_imp  "#EC NEEDED
  CHANGING es_after_rfc_exp      TYPE spta_t_after_rfc_exp  "#EC NEEDED
           cs_user_param         TYPE ztest_random_data_t.

  DATA: wa_final TYPE ztest_random_data.

* Decode RFC output data and add RFC-results to global data
  CALL FUNCTION 'SPTA_INDX_PACKAGE_DECODE'
    EXPORTING
      indxtab = it_rfcdata
    IMPORTING
      data    = it_final.

* After parallel processing write all the records
  LOOP AT it_final INTO wa_final.
    WRITE:/ wa_final-number, 10 wa_final-index.
    CLEAR wa_final.
  ENDLOOP.
  WRITE: sy-uline.

ENDFORM.                    "after_rfc
*&---------------------------------------------------------------------*
*&      Form  F_CREATE_RANDOM_NO
*&---------------------------------------------------------------------*
*       text
*----------------------------------------------------------------------*
*  -->  p1        text
*  <--  p2        text
*----------------------------------------------------------------------*
FORM f_create_random_no.

  DATA: lcl_random TYPE REF TO cl_abap_random_int,
        l_index TYPE sytabix,
        lwa_data TYPE ztest_random_data,
        l_min TYPE i,
        l_max TYPE i.
  l_min = 10.
  l_max = 90.
  TRY.
      lcl_random = cl_abap_random_int=>create( min = l_min
                                               max = l_max ).
    CATCH cx_abap_random.
  ENDTRY.

  DO 100 TIMES.
*   Get the Random Number:
    lwa_data-number = lcl_random->get_next( ).
    l_index = l_index + 1.
    lwa_data-index = l_index.
    APPEND lwa_data TO it_random.
  ENDDO.

ENDFORM.                    " F_CREATE_RANDOM_NO
*&---------------------------------------------------------------------*
*&      Form  F_WRITE_RANDOM_REC
*&---------------------------------------------------------------------*
*       text
*----------------------------------------------------------------------*
*  -->  p1        text
*  <--  p2        text
*----------------------------------------------------------------------*
FORM f_write_random_rec.

  DATA: wa_final TYPE ztest_random_data.
  WRITE:/ 'Before parallel processing start'.
  LOOP AT it_random INTO wa_final.
    WRITE:/ wa_final-number, 10 wa_final-index.
    CLEAR wa_final.
  ENDLOOP.
  WRITE:/ 'After end parallel processing'.

ENDFORM.                    " F_WRITE_RANDOM_REC*&---------------------------------------------------------------------*

Generate Sample Data-

FORM f_create_random_no. 
 
  DATA: lcl_random TYPE REF TO cl_abap_random_int, 
        l_index TYPE sytabix, 
        lwa_data TYPE ztest_random_data, 
        l_min TYPE i, 
        l_max TYPE i. 
  l_min = 10. 
  l_max = 90. 
 
  TRY. 
      lcl_random = cl_abap_random_int=>create( min = l_min 
                                               max = l_max ). 
    CATCH cx_abap_random. 
  ENDTRY. 
 
  DO 100 TIMES. 
*   Get the Random Number: 
    lwa_data-number = lcl_random->get_next( ). 
    l_index = l_index + 1. 
    lwa_data-index = l_index. 
    APPEND lwa_data TO it_random. 
  ENDDO. 
 
ENDFORM.                    " F_CREATE_RANDOM_NO

This routine generates 100 random records and stores them in IT_RANDOM.

Example:

NUMBER INDEX
------------------------
45 1
72 2
18 3
63 4

At this point, all records are available for processing.

Determine Server Group-

 "Fetch the server group 
  SELECT SINGLE classname 
  INTO @DATA(lv_server_grp) 
  FROM rzllitab 
  WHERE grouptype = 'S'.

  IF sy-subrc NE 0. 
    RETURN. 
  ENDIF.

The SPTA framework requires an RFC Server Group.

Server groups are configured in transaction: RZ12

The framework uses this server group to determine where parallel tasks can run.

Start the SPTA Framework-

* Calling the function module to invoke parallel processing 
* framwork 
CALL FUNCTION 'SPTA_PARA_PROCESS_START_2' 
  EXPORTING 
    server_group             = lv_server_grp 
    before_rfc_callback_form = 'BEFORE_RFC' 
    in_rfc_callback_form     = 'IN_RFC' 
    after_rfc_callback_form  = 'AFTER_RFC' 
    callback_prog            = 'ZTEST_SPTA_FRAME_WORK' 
  CHANGING 
    user_param               = it_random 
  EXCEPTIONS 
    invalid_server_group     = 1 
    no_resources_available   = 2 
    OTHERS                   = 3.

This is the entry point of the framework.

The entire table IT_RANDOM is passed through:

user_param = it_random

Internally, SPTA passes this table to BEFORE_RFC, where work packets are created.

The framework then repeatedly executes:

BEFORE_RFC

IN_RFC

AFTER_RFC

Until all records have been processed.

BEFORE_RFC: Create Work Packets-

This callback prepares the data packets that will be processed in parallel.

*&---------------------------------------------------------------------* 
*&      Form  BEFORE_RFC 
*&---------------------------------------------------------------------* 
* In this routine work packets are prepared for parallel processing   * 
* also check the variable for downstream processing                    * 
*----------------------------------------------------------------------* 
FORM before_rfc 
    USING    is_before_rfc_imp     TYPE spta_t_before_rfc_imp 
    CHANGING es_before_rfc_exp     TYPE spta_t_before_rfc_exp 
             it_rfcdata            TYPE spta_t_indxtab 
             ct_failed_objects     TYPE spta_t_failed_objects 
             et_objects_in_process TYPE spta_t_objects_in_process
             it_data               TYPE ztest_random_data_t. 
 
  DATA: l_counter     TYPE i, 
        l_no_of_items TYPE i, 
        it_final TYPE ztest_random_data_t, 
        wa_data TYPE ztest_random_data. 
 
* Create small work packets for parallel processing 
* This is custom logic 
  l_no_of_items = 10.    " One work packet will contain 10 records 
  LOOP AT it_data INTO wa_data. 
* Read and move specified number of records 
    IF ( l_counter < l_no_of_items 
      AND wa_data IS NOT INITIAL ). 
      APPEND wa_data TO it_final. 
      DELETE it_data INDEX 1. 
      l_counter = l_counter + 1. 
    ELSE. 
      EXIT. 
    ENDIF. 
  ENDLOOP. 
 
* Convert the input data into the INDX structure that is needed for the RFC 
  CALL FUNCTION 'SPTA_INDX_PACKAGE_ENCODE' 
    EXPORTING 
      data    = it_final 
    IMPORTING 
      indxtab = it_rfcdata. 
 
* This is mandatory step 
* inform task manager that an rfc can be started from the data compiled 
  IF it_final IS NOT INITIAL. 
    es_before_rfc_exp-start_rfc = 'X'. 
  ELSE. 
    CLEAR es_before_rfc_exp-start_rfc. 
    RETURN. 
  ENDIF. 
 
ENDFORM.                    " BEFORE_RFC_CALLBACK_FORM

Each work packet contains 10 records.

For 100 records:

Packet 1 -> Records 1 to 10
Packet 2 -> Records 11 to 20
Packet 3 -> Records 21 to 30
...
Packet 10 -> Records 91 to 100

The framework passes the remaining data in IT_DATA.

This logic:

Copies 10 records into IT_FINAL

Removes them from IT_DATA

Leaves the remaining records for the next callback execution

Example:

Before:

IT_DATA = 100 records

After first packet:

IT_FINAL = 10 records
IT_DATA = 90 records

Convert Packet into RFC Format-

SPTA transfers data between work processes using INDX structures.

This function serializes the packet into a format suitable for RFC communication.

Signal Framework to Start Processing-

This informs the framework that a work packet is ready, and a new RFC task can be started.

IN_RFC: Execute Business Logic-

This routine runs in a separate work process.

*&---------------------------------------------------------------------* 
*&      Form  IN_RFC 
*&---------------------------------------------------------------------* 
*  In this routine create own RFC enabled FM or write logic in this    * 
*  routine                          * 
*----------------------------------------------------------------------* 
FORM in_rfc 
         USING is_in_rfc_imp         TYPE spta_t_in_rfc_imp "#EC NEEDED 
         CHANGING es_in_rfc_exp      TYPE spta_t_in_rfc_exp
                  it_rfcdata TYPE spta_t_indxtab. 

  DATA: it_final TYPE ztest_random_data_t. 
 
* Decode the data from the INDX Structure into the process work list 
  CALL FUNCTION 'SPTA_INDX_PACKAGE_DECODE' 
    EXPORTING 
      indxtab = it_rfcdata 
    IMPORTING 
      data    = it_final. 
 
* Simple logic to sort data 
  SORT it_final BY number. 
 
* Again Encode output data for AFTER_RFC form 
  CALL FUNCTION 'SPTA_INDX_PACKAGE_ENCODE' 
    EXPORTING 
      data    = it_final 
    IMPORTING 
      indxtab = it_rfcdata. 
 
ENDFORM.                    "in_rfc

Decode Packet-

The encoded packet is converted back into an internal table -> process data -> then packet is sorted by the random number.

Encode Results-

The processed data is encoded again so that it can be returned to the caller.

AFTER_RFC: Collect Results-

Once a parallel task is complete, the framework invokes AFTER_RFC.

*&---------------------------------------------------------------------* 
*&      Form  AFTER_RFC 
*&---------------------------------------------------------------------* 
* In this routine we have to collect date after parallel processing    * 
*----------------------------------------------------------------------* 
FORM after_rfc 
     USING it_rfcdata            TYPE spta_t_indxtab 
           if_rfcsubrc           TYPE sy-subrc 
           if_rfcmsg             TYPE spta_t_rfcmsg 
           it_objects_in_process TYPE spta_t_objects_in_process "#EC NEEDED 
           is_after_rfc_imp      TYPE spta_t_after_rfc_imp  "#EC NEEDED 
  CHANGING es_after_rfc_exp      TYPE spta_t_after_rfc_exp  "#EC NEEDED 
           cs_user_param         TYPE ztest_random_data_t. 
 
  DATA: wa_final TYPE ztest_random_data. 
 
* Decode RFC output data and add RFC-results to global data 
  CALL FUNCTION 'SPTA_INDX_PACKAGE_DECODE' 
    EXPORTING 
      indxtab = it_rfcdata 
    IMPORTING 
      data    = it_final.
 
* After parallel processing write all the records 
  LOOP AT it_final INTO wa_final. 
    WRITE:/ wa_final-number, 10 wa_final-index. 
    CLEAR wa_final. 
  ENDLOOP. 
  WRITE: sy-uline. 
 
ENDFORM.                    "after_rfc

Decode Returned Data-

The processed packet is reconstructed -> The processed records are displayed.

Example-

Suppose the program generates:

45    1
81    2
23    3
67    4
...

The framework creates:

Packet 1 -> 10 Records
Packet 2 -> 10 Records
Packet 3 -> 10 Records
...
Packet10 -> 10 Records

These packets are distributed among available work processes:

WP1 -> Packet 1
WP2 -> Packet 2
WP3 -> Packet 3
WP4 -> Packet 4

Each work process executes the logic inside IN_RFC independently and returns the results through AFTER_RFC.

Let’s execute and see--

Advantages of SPTA Framework-

Standard SAP framework for parallel processing

Automatic workload distribution

Better utilization of available work processes

Reduced execution time

Simplified task management

Improved scalability

Centralized result collection

Conclusion-

The SPTA framework provides a robust and SAP-standard approach for implementing parallel processing in ABAP. By splitting large datasets into smaller work packets and distributing them across multiple work processes, developers can significantly improve application performance while keeping the implementation manageable.

In this example, we generated random data, divided it into packets of 10 records, processed those packets in parallel, and collected the results using the three core callback routines:

BEFORE_RFC – Creates work packets

IN_RFC – Executes business logic in parallel

AFTER_RFC – Collects and consolidates results

For real-world scenarios involving mass data processing, SPTA offers a scalable and efficient solution that aligns with SAP development best practices.

The refreshed SAP Integration Certification Framework is now available

2026-07-20T10:36:00.052000+02:00

After months of close collaboration with our partner ecosystem, the SAP Integration and Certification Center (ICC) is proud to announce that the refreshed SAP Integration Certification Framework is officially live now.

This is a significant milestone — not just for SAP ICC, but for every partner building solutions on the SAP platform. The refreshed framework is the result of real conversations, real feedback, and a shared commitment to making integration certification more accessible, more relevant, and more aligned with where SAP and its partners are heading.

Why We Refreshed the Framework

The integration landscape has changed fundamentally. The rise of Business AI, the shift to Clean Core, the evolution of SAP Business AI Platform, and the introduction of new API policy all demanded a certification framework that could keep pace.

The previous framework served us well — but it was built for a different era. We set out to build something that reflects today's partner reality: diverse solution types, varied maturity levels, diverse system landscapes and an ecosystem that spans from established global partners to innovative niche specialists entering the market.

The result is a framework that is structured yet flexible, rigorous yet accessible.

Two Paths. One Goal.

At the heart of the refreshed framework is a dual-path model — two transparent paths designed to meet partners where they are.

SAP Partner Solution Certification Framework 2026 — Two transparent paths

Of the two pathways, Integration Certification is more closely aligned with SAP product architecture strategy. It is designed for applications built on SAP Business AI Platform that meet a defined set of technical standards: use of published APIs, adherence to Clean Core principles, connectivity to SAP Business Data Cloud, and — where applicable — built with SAP Business AI.

Integration Certification is based on endorsed use-cases and technical criteria by SAP. SAP ICC certifies against a defined portfolio of scenarios available at SAP Partner Portal, meaning the partner application shall map to one of those scenarios to be eligible.

The updated framework is aligned with SAP API policy. A certified solution is not just technically validated — it is a direct confirmation that the solution adheres to the design time guidelines of the new SAP API policy, giving customers and partners a clear and trusted signal of compliance.

Successfully certified solutions receive the SAP Certified logo and a certificate, are listed in the SAP Certified Solutions Directory, and gain access to go-to-market support through SAP Store — making certification not just a quality mark, but a tangible business advantage. Integration Certification continues to be a mandatory requirement for higher solution progression levels in SAP PartnerEdge (Spotlight+, Endorsed App).

Interoperability Review is a new, purposeful entry point into the integration certification framework — and one of the most requested suggestion from our partner and the broader community. Certain partner solutions are not able to qualify for Integration Certification and fit a predefined certification scenario. That's not a dead end – it's what the Interoperability Review is built for.

Interoperability Review is SAP ICC's open and inclusive validation path, available to partners and non-partners (ISVs) alike, regardless of where you sit in the SAP ecosystem. It is designed for applications that use published APIs correctly but integrate via methods or platforms that fall outside the SAP Integration Certification Framework – and it's open to standard, market-ready products.

SAP ICC assesses your application against interoperability standards: correct use of published APIs as documented, successful authentication and connectivity, correct data exchange, and appropriate error handling. The review confirms technical compatibility – without requiring deep platform alignment.

If the partner solution passes the Interoperability Review, the solution is listed as interoperable on SAP Notes, and receive a Review Summary documenting the outcome of the technical assessment. With these outcomes, partners can demonstrate to joint customers that the solution is compatible with SAP suite of solutions.

These two paths are not competing options. They are complementary instruments that together ensure every partner has a supported route to market for their solution through a technical validation by SAP.

What Happens Next

The framework is now live. Here is how to get started:

Explore the two paths — review the full documentation ICC pages at SAP.com and SAP Partner Portal
Understand the Certification Framework Reference Guide and FAQ
Talk to us — contact the ICC team (icc@sap.com) to discuss which path is the right fit for your solution or apply for our service
Start your journey — the process begins with a short discovery conversation with the ICC team.

A Thank You to Our Partner Community

This framework did not emerge from a room at SAP. It emerged from the conversations we have had with many partners — at partner events, in certification reviews, in feedback sessions, and from the direct input you have shared with us over the years.

To everyone who participated in shaping this: thank you. You will see your contribution reflected in what we have built with the refreshed framework.

We are proud of this framework. We are more proud of what it makes possible for you and your customers. We at SAP ICC are eager to see it go live and really making a change for our partner community.

The SAP ICC Team
SAP Integration and Certification Center

Have questions? Reach out to the ICC team at icc@sap.com

Building CPI Explorer – My Journey to Simplify Searching SAP Integration Suite iFlows

2026-07-20T12:12:08.365000+02:00

Building CPI Explorer – My Journey to Simplify Searching SAP Integration Suite iFlows

Introduction

As an SAP Integration Suite consultant, a large part of my day involves supporting existing integrations, troubleshooting production issues, and understanding how different systems are connected. One challenge kept coming up repeatedly: finding where a particular SFTP directory, HTTP endpoint, ProcessDirect endpoint, or credential was configured across dozens (sometimes hundreds) of Integration Flows.

SAP's Design-Time APIs let you retrieve Integration Packages and Integration Flows, but there's no built-in way to search adapter configurations across an entire tenant. In practice, that meant opening package after package and manually inspecting each iFlow — slow, repetitive, and easy to get wrong in a large landscape.

Instead of continuing to do this by hand, I decided to build a tool to solve it for myself, and hopefully for other developers too.

Where It All Started

I started my career as an ABAP developer, and one feature I relied on constantly was the "Where Used" list. If I needed to know where a table, function module, or field was being used, I could just look it up. It was simple, fast, and always available.

When I moved into PI/PO and later CPI, that convenience disappeared. There's no equivalent way to instantly search where something is used across your integration landscape.

This became a real problem in day-to-day support. An FICO or SD colleague would come to me and say "my file isn't moving, can you check?" Half the time, they weren't even sure whether their interface was flowing through PI/CPI at all — they just knew something was stuck and assumed I'd know where to look. Other times, someone from the infra team would ask "are we using this host anywhere? We need to update it" or "can you find every flow using this username, we're rotating credentials." Each of these meant manually opening iFlow after iFlow, hoping I didn't miss one.

That's where the idea for CPI Explorer actually came from — not as a big architectural vision, but as a way to get back something as basic as the ABAP "Where Used" list, just for CPI.

One real example was during an infrastructure change where we had to update an SFTP host. Before CPI Explorer, the only option was to manually open multiple Integration Flows and inspect every SFTP adapter. With CPI Explorer, I can simply search for the hostname and immediately see every Integration Flow that references it.

The Idea

The question I started with was simple:

Can I build a "Where Used" list for CPI?

I spent quite some time exploring the SAP Business Accelerator Hub and Design-Time APIs to see whether this functionality already existed. The Design-Time APIs gave me metadata, but not the adapter-level detail I needed. So I went a level deeper: download each Integration Flow artifact, extract the .iflw file, parse the XML, and build a local searchable index from it.

Once that was working, I wrapped it in a Chrome Extension so I could search directly from the browser instead of running scripts every time.

How CPI Explorer Works

At a high level, the tool:

Authenticates with SAP Integration Suite using OAuth
Retrieves Integration Packages and Integration Flows via the Design-Time APIs
Downloads Integration Flow artifacts
Extracts and parses the .iflw XML files
Builds a searchable metadata index
Lets you search adapter properties from the Chrome Extension

It currently supports searching for:

SFTP directories
Host names
HTTP endpoints
ProcessDirect endpoints
JMS queues
Credentials
Externalized parameters
Other adapter properties

What I Learned

Building this taught me more than I expected about:

SAP Integration Suite Design-Time APIs
The structure of Integration Flow artifacts
Parsing .iflw XML files
Chrome Extension development
Organizing a Node.js application into reusable modules

The trickiest part was making sure every downloaded artifact mapped back correctly to its source Integration Flow while the index was being built. Getting that mapping right was what made the search results trustworthy across a whole tenant.

Why I'm Sharing This

I built CPI Explorer to solve my own problem, but I believe many SAP Integration Suite developers face the same challenge. That's why I decided to make it open source, so others can use it, contribute ideas, and help improve it over time.

GitHub

The project is available here: https://github.com/lokeshbhukya2019-netizen/cpi-explorer

Feedback, suggestions, and contributions are welcome.

What's Next

A few things I'm planning to add:

Search by adapter type
Multi-tenant support
Export to Excel/CSV
Dependency visualization
Support for additional adapter types

If you have ideas for other useful features, I'd like to hear them.

Closing Thoughts

CPI Explorer started as an attempt to fix a problem I ran into constantly in day-to-day SAP Integration Suite work. Along the way it turned into a good excuse to learn more about SAP's APIs, artifact structures, and browser extension development.

I hope it saves other SAP Integration Suite developers some time during troubleshooting and impact analysis. If you try it, I'd genuinely like to hear how it goes.

Thank you for taking the time to read about CPI Explorer. If you try it out, I'd love to hear your feedback, suggestions, or ideas for new features. I hope it helps make troubleshooting and impact analysis in SAP Integration Suite a little easier for the community.

Happy integrating!

ABAP development tools for Visual Studio Code: Version 1.1 released

2026-07-21T13:53:34.813000+02:00

What happened since the last release?

Link to the extension.

First of all, thanks for the positive feedback regarding the 1.0.1 patch which added the much requested RFC + password support! Please keep providing feedback as it helps us to plan the next releases. A lot of users are asking us how they can provide feedback. We have recently added a new customer influence channel just for the VS Code extension. We recommend using that one.

Last month, ABAPConf 2026 took place in Mannheim. We want to highlight two talks:

Tobias Hofmann provided public feedback regarding the extension and compiled a nice to-do list. I can report that a lot of these to-do items are already part of our internal to-do list. The talk can be found here.
Anne Keller and I gave a talk on the overall ABAP IDE strategy. Of course, it touches the VS Code extension but also aims to provide a broader picture on how we want to support ABAP IDEs via a single technology stack in the future and shares some insights on how the ADT MCP server will evolve in the future. The talk can be found here.

What gets shipped with this release?

Usability improvements for system connection handling

After creating a new destination there was no visual feedback that the destination was created successfully. We added a notification pop-up with a button which directly adds it as a folder to your workspace.

We added a "Log on to Destination..." command. While it was possible to log on to a destination via a right-click menu in the explorer view there was no command available for it.

Now, you can easily log on to a destination using the keyboard via the new command.

A significant improvement of object type support

A lot of requested object types get enabled by this release. Here is the list of added object types:

Classic ABAP source code

Create and Manage Function Groups and Modules
Create and Manage ABAP Programs and Includes
Create and Manage Lock Objects

Data Dictionary

Create and Manage Database Tables
Create and Manage Structures
Create and Manage Type Groups

RESTful Application Programming Model

Creating Behavior Definition Extensions
Enabling more OData Binding Types in Service Binding
Create and Manage CDS Entity Buffers

New MCP tools

Unified diff tool for transports

The unified diff tool generates a git like diff for a given transport request. The tool enables token efficient analysis of the changes contained in a transport request. This enables AI agents to fulfill requests such as:

"Explain transport XYZ"
"Generate a description for transport XYZ documenting what got changed and why"
"How much impact does transport XYZ has on the system? How dangerous is this transport?"

Tools for ABAP Test Cockpit (ATC)

The ATC MCP tools give AI agents access to running the ATC checks for a given change. This enables AI agents to fulfill requests such as:

"Implement [XYZ]. Afterwards, run the ATC checks and fix the reported findings."
"Run ATC checks for object XYZ"

Additional UX improvements

We added a command which allows you to quickly open the SAP Help documentation.

From each occurrence of a CDS annotation in a CDS data definition or CDS metadata extension, you can now navigate to its CDS annotation definition. To navigate, press F3 on the relevant CDS annotation. This helps you to investigate and to understand the use of a CDS annotation.

For more information see the new "What's New" page.

Sidenote: first version of ABAP cleaner VS Code extension available

Lots of community members asked for ABAP cleaner support in VS Code. We are happy to announce that the first version of the ABAP cleaner extension is available, now!

What's next?

From now on, we will stop listing upcoming features directly in the release blogs. Instead we have cleaned up and refreshed our ABAP Cloud Roadmap page. The planned features are listed there.

Provide feedback and influence our product backlog!

Uploading Multi-Sheet Excel Files to Create Bank Master Records in SAP

2026-07-23T13:17:51.638000+02:00

INTRODUCTION

The opening A while back change to your real project type and rough timing (e.g., "During a recent S/4HANA migration project for a client..." or "As part of a support ticket raised by the finance team...").

The bolded sentence about ALSM_EXCEL_TO_INTERNAL_TABLE — delete it if you'd never actually used that older method before If that wasn't your real reaction, replace it with whatever actually confused you about Step 2 — maybe it was the worksheet name lookup, or the ASSIGN COMPONENT syntax itself, or something else entirely Only keep this if you genuinely forgot the commit If your real bug was something else — e.g., a wrong bank key format, a BAPI return error you didn't handle, duplicate records, etc. — delete this sentence and write 1-2 lines describing what actually went wrong for you

Solution Review

The report ZPRG_EXCELSHEET2_CRBAPIREC_RS lets a user upload an Excel file containing Sheet1 and Sheet2, reads both into internal tables, matches records across the two sheets, and creates Bank Master records using the standard BAPI BAPI_BANK_CREATE.

Step 1: Selecting and uploading the Excel file.

This part was straightforward — standard file dialog using cl_gui_frontend_services=>file_open_dialog, then uploading the binary content with GUI_UPLOAD, and converting it to XSTRING with SCMS_BINARY_TO_XSTRING since that's the format CL_FDT_XL_SPREADSHEET expects.

CALL METHOD cl_gui_frontend_services=>gui_upload
  EXPORTING
    filename   = lv_file
    filetype   = 'BIN'
  IMPORTING
    filelength = lv_size
  CHANGING
    data_tab   = lt_binary.

CALL FUNCTION 'SCMS_BINARY_TO_XSTRING'
  EXPORTING
    input_length = lv_size
  IMPORTING
    buffer       = lv_xstring
  TABLES
    binary_tab   = lt_binary.

Step 2: Reading both worksheets.

The program uses the SAP standard class CL_FDT_XL_SPREADSHEET to open the Excel file. It first retrieves the worksheet names and then reads Sheet1 and Sheet2 separately. The data from each worksheet is stored in separate internal tables by mapping the Excel columns to the corresponding ABAP structures.

CALL METHOD lo_excel->if_fdt_doc_spreadsheet~get_itab_from_worksheet
  EXPORTING
    worksheet_name = 'Sheet1'
  RECEIVING
    itab           = lo_ref1.

ASSIGN lo_ref1->* TO <lt_generic1>.

LOOP AT <lt_generic1> ASSIGNING <ls_generic1>.
  ASSIGN COMPONENT 1 OF STRUCTURE <ls_generic1> TO <lv_field>.
  IF sy-subrc = 0. ls_sheet1-bank_ctry = <lv_field>. ENDIF.
  ...
ENDLOOP.

I'll be honest — the first time I saw this "generic table + field-symbol + component index" pattern, it felt like more ceremony than I expected for something as simple as "read column 1, 2, 3." But once I understood why — the class has no way of knowing your target structure in advance, since Excel columns aren't typed — it made a lot more sense.

The one thing that tripped me up initially was column order: CL_FDT_XL_SPREADSHEET maps by column position, not header name, so if someone reorders columns in the Excel file (which, let's be honest, business users do all the time), the mapping silently breaks. That's worth calling out clearly to whoever maintains the Excel template.

Sheet2 follows the exact same pattern, just with four columns instead of three (adding city and SWIFT code).

Step 3: Matching records and creating Bank Master entries.

Once both sheets were in internal tables, I looped through Sheet1 and used READ TABLE ... WITH KEY to find the matching row in Sheet2 based on bank country and bank key:

READ TABLE lt_sheet2 INTO ls_sheet2
     WITH KEY bank_ctry = ls_sheet1-bank_ctry
              bank_key  = ls_sheet1-bank_key.

IF sy-subrc = 0.
  gs_address-city       = ls_sheet2-city.
  gs_address-swift_code = ls_sheet2-swift.
ENDIF.

Then calling BAPI_BANK_CREATE, and — this part I added after an early test run — explicitly committing or rolling back based on the return message:

IF ls_return-type CA 'AE'.
  CALL FUNCTION 'BAPI_TRANSACTION_ROLLBACK'.
ELSE.
  CALL FUNCTION 'BAPI_TRANSACTION_COMMIT'
    EXPORTING
      wait = 'X'.
ENDIF.

I actually forgot the commit in my very first version and spent a few confused minutes wondering why none of the banks were showing up in FI01/FI03 afterward — small reminder that BAPIs in SAP generally don't auto-commit, and it's easy to overlook when you're focused on getting the Excel-reading logic right.

Complete ABAP Source Code

REPORT zprg_excelsheet2_crbapirec_rs.

TABLES: bnka.

TYPES: BEGIN OF ty_sheet1,
         bank_ctry TYPE bnka-banks,
         bank_key  TYPE bnka-bankl,
         bank_name TYPE bnka-banka,
       END OF ty_sheet1.

TYPES: BEGIN OF ty_sheet2,
         bank_ctry TYPE bnka-banks,
         bank_key  TYPE bnka-bankl,
         city      TYPE bnka-ort01,
         swift     TYPE bnka-swift,
       END OF ty_sheet2.

DATA:
  lt_sheet1  TYPE TABLE OF ty_sheet1,
  ls_sheet1  TYPE ty_sheet1,

  lt_sheet2  TYPE TABLE OF ty_sheet2,
  ls_sheet2  TYPE ty_sheet2,

  lt_binary  TYPE solix_tab,
  lv_xstring TYPE xstring,
  lv_size    TYPE i,

  lo_excel   TYPE REF TO cl_fdt_xl_spreadsheet,
  lt_names   TYPE if_fdt_doc_spreadsheet=>t_worksheet_names,

  ls_return  TYPE bapiret2,
  gs_address TYPE bapi1011_address,

  lv_file    TYPE string,

  lt_files   TYPE filetable,
  lv_rc      TYPE i.

PARAMETERS: p_file TYPE rlgrap-filename.

AT SELECTION-SCREEN ON VALUE-REQUEST FOR p_file.
  PERFORM f4_file_selection.

START-OF-SELECTION.
  PERFORM upload_file.
  PERFORM parse_excel.
  PERFORM create_banks.

FORM f4_file_selection.

  CALL METHOD cl_gui_frontend_services=>file_open_dialog
    EXPORTING
      window_title      = 'Select Excel File'
      default_extension = 'XLSX'
      file_filter       = 'Excel Files (*.xlsx)|*.xlsx|All Files (*.*)|*.*'
    CHANGING
      file_table        = lt_files
      rc                = lv_rc
    EXCEPTIONS
      OTHERS            = 1.

  IF sy-subrc = 0 AND lines( lt_files ) > 0.
    READ TABLE lt_files INTO DATA(ls_file) INDEX 1.
    p_file = ls_file-filename.
  ENDIF.

ENDFORM.

FORM upload_file.

  lv_file = p_file.

  CALL METHOD cl_gui_frontend_services=>gui_upload
    EXPORTING
      filename   = lv_file
      filetype   = 'BIN'
    IMPORTING
      filelength = lv_size
    CHANGING
      data_tab   = lt_binary
    EXCEPTIONS
      OTHERS     = 1.

  IF sy-subrc <> 0.
    MESSAGE 'File upload failed' TYPE 'E'.
  ENDIF.

  CALL FUNCTION 'SCMS_BINARY_TO_XSTRING'
    EXPORTING
      input_length = lv_size
    IMPORTING
      buffer       = lv_xstring
    TABLES
      binary_tab   = lt_binary.

ENDFORM.

FORM parse_excel.

  DATA: lo_ref1 TYPE REF TO data,
        lo_ref2 TYPE REF TO data.

  FIELD-SYMBOLS: <lt_generic1> TYPE STANDARD TABLE,
                 <ls_generic1> TYPE any,
                 <lt_generic2> TYPE STANDARD TABLE,
                 <ls_generic2> TYPE any,
                 <lv_field>    TYPE any.

  TRY.
      CREATE OBJECT lo_excel
        EXPORTING
          document_name = lv_file
          xdocument     = lv_xstring.

      CALL METHOD lo_excel->if_fdt_doc_spreadsheet~get_worksheet_names
        IMPORTING
          worksheet_names = lt_names.

      CALL METHOD lo_excel->if_fdt_doc_spreadsheet~get_itab_from_worksheet
        EXPORTING
          worksheet_name = 'Sheet1'
        RECEIVING
          itab           = lo_ref1.

      ASSIGN lo_ref1->* TO <lt_generic1>.

      LOOP AT <lt_generic1> ASSIGNING <ls_generic1>.
        CLEAR ls_sheet1.
        ASSIGN COMPONENT 1 OF STRUCTURE <ls_generic1> TO <lv_field>.
        IF sy-subrc = 0. ls_sheet1-bank_ctry = <lv_field>. ENDIF.
        ASSIGN COMPONENT 2 OF STRUCTURE <ls_generic1> TO <lv_field>.
        IF sy-subrc = 0. ls_sheet1-bank_key = <lv_field>. ENDIF.
        ASSIGN COMPONENT 3 OF STRUCTURE <ls_generic1> TO <lv_field>.
        IF sy-subrc = 0. ls_sheet1-bank_name = <lv_field>. ENDIF.
        APPEND ls_sheet1 TO lt_sheet1.
      ENDLOOP.

      CALL METHOD lo_excel->if_fdt_doc_spreadsheet~get_itab_from_worksheet
        EXPORTING
          worksheet_name = 'Sheet2'
        RECEIVING
          itab           = lo_ref2.

      ASSIGN lo_ref2->* TO <lt_generic2>.

      LOOP AT <lt_generic2> ASSIGNING <ls_generic2>.
        CLEAR ls_sheet2.
        ASSIGN COMPONENT 1 OF STRUCTURE <ls_generic2> TO <lv_field>.
        IF sy-subrc = 0. ls_sheet2-bank_ctry = <lv_field>. ENDIF.
        ASSIGN COMPONENT 2 OF STRUCTURE <ls_generic2> TO <lv_field>.
        IF sy-subrc = 0. ls_sheet2-bank_key = <lv_field>. ENDIF.
        ASSIGN COMPONENT 3 OF STRUCTURE <ls_generic2> TO <lv_field>.
        IF sy-subrc = 0. ls_sheet2-city = <lv_field>. ENDIF.
        ASSIGN COMPONENT 4 OF STRUCTURE <ls_generic2> TO <lv_field>.
        IF sy-subrc = 0. ls_sheet2-swift = <lv_field>. ENDIF.
        APPEND ls_sheet2 TO lt_sheet2.
      ENDLOOP.

    CATCH cx_fdt_excel_core INTO DATA(lx_excel).
      MESSAGE lx_excel->get_text( ) TYPE 'E'.
  ENDTRY.

  IF lt_sheet1 IS INITIAL.
    MESSAGE 'No data found in Sheet1' TYPE 'E'.
  ENDIF.

ENDFORM.

FORM create_banks.

  LOOP AT lt_sheet1 INTO ls_sheet1.

    IF ls_sheet1-bank_ctry IS INITIAL OR ls_sheet1-bank_key IS INITIAL.
      WRITE: / 'Skipped row - missing country/key'.
      CONTINUE.
    ENDIF.

    CLEAR: ls_return, gs_address.

    gs_address-bank_name = ls_sheet1-bank_name.

    READ TABLE lt_sheet2 INTO ls_sheet2
         WITH KEY bank_ctry = ls_sheet1-bank_ctry
                  bank_key  = ls_sheet1-bank_key.

    IF sy-subrc = 0.
      gs_address-city       = ls_sheet2-city.
      gs_address-swift_code = ls_sheet2-swift.
    ENDIF.

    CALL FUNCTION 'BAPI_BANK_CREATE'
      EXPORTING
        bank_ctry    = ls_sheet1-bank_ctry
        bank_key     = ls_sheet1-bank_key
        bank_address = gs_address
      IMPORTING
        return       = ls_return.

    IF ls_return-type CA 'AE'.
      CALL FUNCTION 'BAPI_TRANSACTION_ROLLBACK'.
      WRITE: / ls_sheet1-bank_key, ls_return-message.
    ELSE.
      CALL FUNCTION 'BAPI_TRANSACTION_COMMIT'
        EXPORTING
          wait = 'X'.
      WRITE: / 'Bank Created Successfully:', ls_sheet1-bank_key.
    ENDIF.

  ENDLOOP.

ENDFORM.

CONCLUSION

What I liked about this approach is that it replaces two separate old-style problems — reading Excel data (previously OLE Automation or ALSM_EXCEL_TO_INTERNAL_TABLE) and matching data across sheets — with one clean, modern, generic-table-based method. It's a solid pattern if you ever need to pull structured data from multi-sheet Excel files into any custom or standard BAPI, not just Bank Master creation.

If you've worked with CL_FDT_XL_SPREADSHEET yourself, I'd be curious to hear if you ran into the same column-position mapping issue I did, or if you handled worksheet validation differently. Feel free to share your thoughts, questions, or improvements in the comments below.

SAMPLE INPUT
Sheet1 (Bank Country, Bank Key, Bank Name)

Bank Ctry Bank Key Bank Name

US	021000021	JPMorgan Chase Bank
US	026009593	Bank of America
IN	SBIN0001234	State Bank of India
DE	10070000	Deutsche Bank AG

Sheet2 (Bank Country, Bank Key, City, SWIFT)

Bank Ctry Bank Key City SWIFT

US	021000021	New York	CHASUS33
US	026009593	Charlotte	BOFAUS3N
IN	SBIN0001234	Mumbai	SBININBB
DE	10070000	Berlin	DEUTDEBB

SAMPLE OUTPUT

Bank Created: 021000021
Bank Created: 026009593
Bank Created: SBIN0001234
Bank Created: 10070000.

ABAP Development

SAP Community - SAP BTP, ABAP environment

ABAP development tools for Visual Studio Code: Patch 1.0.1 released

What happened since the first release?

What gets shipped with this release?

RFC System logon via password

AGENTS.md template

What's next?

Provide feedback and influence our product backlog!

SAP Joule for Developers, ABAP AI capabilities including agentic capabilities is now available!

New Commercial model for SAP Joule for Developers, ABAP AI Capabilities

Commercial model & AI Units

What is an SAP AI Unit?

How do I know how many units I should purchase?

How to Purchase the License and activate the packages?

For Administrators: Steps to configure SAP Joule for Developers, ABAP AI Capabilities.

For Developers Using ABAP Development Tools (ADT) for Eclipse: Steps to configure SAP Joule for Developers, ABAP AI Capabilities.

For Developers Using ABAP Development Tools (ADT) for Visual Studio Code: Steps to configure SAP Joule for Developers, ABAP AI Capabilities.

Overview of SAP Joule for Developers, ABAP AI capabilities supported in SAP products including lower releases of SAP S/4HANA Cloud Private Edition

SAP BTP ABAP Environment – Pre-Upgrade Option for Release 2608

Overview

Purpose

Approach

Costs

Planned New Features

Time Schedule

System Nomination

Report an Issue

Exceptional Process in Case of Unresolved Priority Very High Issues

Summary

Unmanaged RAP application for Excel File Upload and CDS Custom Entity with Unmanaged Query Implement

Intro

Use-case

Data Model

Implementation of Excel Upload

Service Binding

Fiori UI Preview

Final words

Building an Inventory System with RAP on BTP Trial — CDS Views Explained

Introduction

The System at a Glance

The Two-Layer Architecture

Composition: Stock Document Header and Item

Associations: Two Aliases, One Target View

Semantic Annotations: Free Administrative Data

Projection Views: What Most Tutorials Skip

Value Help Annotations

Running This on BTP Trial

The Missing Layer in Every SAP Go-Live: Why Hypercare Should Be Built Before Go-Live, Not After!

Why Hypercare Keeps Failing — Structurally

More Consultants Is Not the Answer

An Embedded AI Agent — Built in Parallel With Testing

The Bot Is a System Object — So It Gets Signed Off Like One

What It Actually Looks Like — Four Real Scenarios

The Bot Learns Only When a Trusted Human Signs Off

On the Architecture — Briefly

Make It Non-Negotiable

The Tool Does Not Yet Exist. That Is the Point.

SAP BTP ABAP Environment - Build Partner Products and Bring Them to SAP Store

Helpful resources

Bypassing the List Report in SAP Fiori Apps: BCMO, Static Keys, and Dynamic Keys

What is a BCMO App, and How Does It Relate to Table Maintenance Generator (TMG)?

Part 1: Creating a BCMO App

Prerequisites on the Database Table

Generating the BCMO Objects

Accessing the BCMO App

A Note on Authorizations

Part 2: Getting Rid of the Singleton List Report for a BCMO App

Step 1: Create a New Project in BAS

Step 2: Remove the List Report Route from the Manifest

Step 3: Auto-Navigate to the Object Page in Component.js

Step 4: Test It

Part 3: Bypassing the List Report for a Standard List Report App

Deploying the Base List Report App

Option A: Bypassing with a Static Key

Option B: Bypassing with a Dynamic Key (Logged-in Username)

For Multi-Level Apps

Wrapping Up

Chat-based RAP Business Object Generation in VS Code

Getting Started

Prerequisites:

Method `CREATE`

Method `UPDATE`

Method `DELETE`

Private helpera methods `CALL_WRITE_DOCUMENT`, `READ_CURRENT_CUSTOMER`, `READ_CURRENT_CUSTOMER_BANK`