SAP Community - ABAP Cloud

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

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

Custom Field and Logic from Scratch

2026-06-25T06:22:05.149000+02:00

Recommendations for Wrapper Interface Design

2026-06-25T15:19:44.883000+02:00

Introduction

With the shift towards clean core extensibility in SAP S/4HANA, developers are encouraged to build extensions that are upgrade-stable, loosely coupled, and compliant with ABAP Cloud principles. One key design pattern to achieve this is the use of wrappers.

As described in Clean core extensibility for SAP S/4HANA Cloud and, in more detail, in Extend SAP S/4HANA in the cloud and on premise with ABAP based extensions, SAP recommends encapsulating classic APIs and internal objects within a wrapper layer. This wrapper can then be released for use in ABAP Cloud development.

In this blog post, we will walk through:

Why wrappers are essential
How to design them effectively
Best practices for data types and consistency
Common pitfalls and how to avoid them

Why Use Wrappers?

A wrapper acts as a controlled façade around existing SAP APIs (for example, classic BAPIs). Instead of consuming these APIs directly, your application interacts only with the wrapper.

Key Benefits

Encapsulation of internal APIs: Only the necessary parts of the underlying API are exposed.
Clear contract: The wrapper defines a stable and explicit interface towards SAP.
Reduced dependencies: Consumers depend on the wrapper, not the underlying implementation.
Improved flexibility: The implementation can be replaced or adapted without impacting consumers.
Better testability: Wrappers make it easier to create test doubles and isolate logic during testing.

Example: Wrapper for a BAPI

A typical case is wrapping a classic BAPI such as BAPI_USER_GET_DETAIL. Instead of calling the BAPI directly,

You define a wrapper interface
Call the BAPI inside the wrapper implementation
Expose only the required parameters and results

Let’s assume your task is getting the first name, the last name, and the phone number of a user. The wrapper interface and implementation may look like this:

C1-released interface:

INTERFACE zkd_if_wrap_bapi_user_get PUBLIC .

  TYPES:
    ty_username TYPE xubname,
    BEGIN OF ts_person,
      firstname TYPE ad_namefir,
      lastname  TYPE ad_namelas,
    END OF ts_person,
    BEGIN OF ts_telephone,
      std_no TYPE ad_flgdfnr,
      tel_no TYPE ad_telnrlg,
    END OF ts_telephone,
    tt_telephone TYPE STANDARD TABLE OF ts_telephone WITH NON-UNIQUE DEFAULT KEY,
    tt_bapiret2  TYPE STANDARD TABLE OF bapiret2 WITH NON-UNIQUE DEFAULT KEY.

  METHODS:
    user_get_details
      IMPORTING
        iv_username      TYPE ty_username
        iv_cache_results TYPE abap_boolean DEFAULT abap_false
      EXPORTING
        es_person        TYPE ts_person
        et_telephone     TYPE tt_telephone
        et_return        TYPE tt_bapiret2.

ENDINTERFACE.

Non-released implementation:

CLASS zkd_cl_wrap_bapi_user_get DEFINITION PUBLIC.

 PUBLIC SECTION.
    INTERFACES zkd_if_wrap_bapi_user_get.

ENDCLASS.

CLASS zkd_cl_wrap_bapi_user_get IMPLEMENTATION.

  METHOD zkd_if_wrap_bapi_user_get~user_get_details.

    DATA ls_address TYPE bapiaddr3.
    DATA lt_addtel TYPE STANDARD TABLE OF bapiadtel.

    CALL FUNCTION 'BAPI_USER_GET_DETAIL'
      EXPORTING
        username      = iv_username
        cache_results = iv_cache_results
      IMPORTING
        address       = ls_address
      TABLES
        addtel        = lt_addtel
        return        = et_return.

    es_person = CORRESPONDING #( ls_address ).
    et_telephone = CORRESPONDING #( lt_addtel ).

  ENDMETHOD.

ENDCLASS.

C1-released factory:

CLASS zkd_cl_wrap_factory DEFINITION PUBLIC CREATE PRIVATE.

  PUBLIC SECTION.
    CLASS-METHODS:
      get_wrap_bapi_user_get RETURNING VALUE(ro_wrapper) TYPE REF TO zkd_if_wrap_bapi_user_get.

ENDCLASS.

CLASS zkd_cl_wrap_factory IMPLEMENTATION.

  METHOD get_wrap_bapi_user_get.
    ro_wrapper = NEW zkd_cl_wrap_bapi_user_get( ).
  ENDMETHOD.

ENDCLASS.

The wrapper may be accessed as indicated in the following console application:

CLASS zkd_cl_call_wrap_bapi_user_get DEFINITION PUBLIC.

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.

ENDCLASS.

CLASS zkd_cl_call_wrap_bapi_user_get IMPLEMENTATION.

  METHOD if_oo_adt_classrun~main.

    DATA lo_wrapper TYPE REF TO zkd_if_wrap_bapi_user_get.
    lo_wrapper = zkd_cl_wrap_factory=>get_wrap_bapi_user_get(  ).

    lo_wrapper->user_get_details(
      EXPORTING
        iv_username  = 'DEHMANN'
      IMPORTING
        es_person    = DATA(ls_person)
        et_telephone = DATA(lt_telephone)
        et_return    = DATA(lt_return) ).

    out->write( |First name: { ls_person-firstname }| ).
    out->write( |Last name : { ls_person-lastname }| ).
    out->write( |Phone numbers:| ).
    LOOP AT lt_telephone INTO DATA(ls_telephone).
      out->write( ls_telephone-tel_no ).
    ENDLOOP.

  ENDMETHOD.

ENDCLASS.

General Design Best Practices

When designing wrapper interfaces, follow these principles:

Keep it lean
- The wrapper implementation should stay close to the underlying API
- Avoid adding unnecessary logic inside the wrapper
Expose only what you need
- Restrict the interface to required parameters and outputs
- Avoid overexposing SAP structures
Separate concerns
- Handle conversions (internal ↔ external formats) outside or in dedicated components

In our example, the wrapper exposes only the parameters that are needed. Moreover, BAPIRET2 is the only SAP structure that is being used. Besides mapping parameters, the wrapper does not contain any additional logic.

Best Practices for Referenced Data Types

Handling data types correctly is essential. Follow these principles when implementing your wrapper interface:

Use released types when available: If SAP provides a suitable, released data type, always use it directly in your interface definition.
Define your own types when needed: If the required data types are not released, declare them explicitly within your wrapper interface using the TYPES statement. If these types are shared among a set of wrappers, then consider declaring these in a central interface with corresponding TYPES declaration. If technically needed, you may also create such types in ABAP Dictionary and release them for use in Cloud Development.
Reference existing data elements: When declaring your own types, reference SAP data elements — even if not released — to maintain consistency.
Define smaller structures: Avoid tight coupling to SAP structures. Rather than reusing or copying large SAP structures, declare smaller, dedicated structures with required fields only. This reduces the dependency footprint.
Be careful when declaring table types: Always declare a corresponding line type explicitly.

Let's check how these recommendations map to our example:

The released data element ABAP_BOOL is being used in the type declaration of the IV_CACHE_RESULTS parameter and the released BAPIRET2 structure is being used for the declaration of the TT_BAPIRET2 table type.
We define our own types TY_USERNAME, TS_PERSON, and TS_TELEPHONE referencing non-released SAP data elements such as XUBNAME or AD_NAMEFIR.
Instead of exposing all components of the BAPIADDR3 structure we declare the (small) TS_PERSON structure which contains only the relevant components. We keep the component names to ease the mapping in the implementation.
For the phone numbers we declare the TT_TELEPHONE table type and TS_TELEPHONE line type.

If you decide to reference non-released SAP structures in the type declarations, keep the following restrictions in mind:

If the SAP structure is complex (that is, it contains nested or non-elementary data types such as structure, table type, data reference, or object reference), you can't access these nested or non-elementary components from ABAP for Cloud Development unless they're released.
If the SAP structure is flat and contains only elementary data types, you can access the components of the structure from ABAP for Cloud Development. However, rework might be required if SAP enhances the structure with non-elementary data types in the future.

Let’s take a look at a negative example. Assume your task is reading the text of an object. You consider using the READ_MULTIPLE_TEXTS function module, which is a classic API. The wrapper implementation may look like this:

C1-released interface:

INTERFACE zkd_if_wrap_read_texts PUBLIC .

  TYPES:
    tt_texttable TYPE text_lh.

  METHODS:
    read_texts
      IMPORTING
        iv_name       TYPE tdobname
        iv_object     TYPE tdobject
        iv_id         TYPE tdid
      EXPORTING
        et_text_table TYPE tt_texttable.

ENDINTERFACE.

Non-released implementation:

CLASS zkd_cl_wrap_read_texts DEFINITION PUBLIC.

  PUBLIC SECTION.
    INTERFACES zkd_if_wrap_read_texts.

ENDCLASS.

CLASS zkd_cl_wrap_read_texts IMPLEMENTATION.

  METHOD zkd_if_wrap_read_texts~read_texts.

    CALL FUNCTION 'READ_MULTIPLE_TEXTS'
      EXPORTING
        name       = iv_name
        object     = iv_object
        id         = iv_id
      IMPORTING
        text_table = et_text_table.

  ENDMETHOD.

ENDCLASS.

C1-released factory:

CLASS zkd_cl_wrap_factory DEFINITION PUBLIC CREATE PRIVATE.

  PUBLIC SECTION.
    CLASS-METHODS:
      get_wrap_bapi_user_get RETURNING VALUE(ro_wrapper) TYPE REF TO zkd_if_wrap_bapi_user_get,
      get_wrap_read_texts RETURNING VALUE(ro_wrapper) TYPE REF TO zkd_if_wrap_read_texts.

ENDCLASS.

CLASS zkd_cl_wrap_factory IMPLEMENTATION.

  METHOD get_wrap_bapi_user_get.
    ro_wrapper = NEW zkd_cl_wrap_bapi_user_get( ).
  ENDMETHOD.

  METHOD get_wrap_read_texts.
    ro_wrapper = NEW zkd_cl_wrap_read_texts( ).
  ENDMETHOD.

ENDCLASS.

It uses the non-released TEXT_LH table type and does not declare a corresponding line type. Because there is no line type declaration, the “The use of element <element_name> of <object_type> <object_name> is not permitted” syntax check message is returned when trying to access a component of the underlying structure from ABAP for Cloud Development.

You could fix this by adding a corresponding line type declaration using the non-released ITCLH structure, which is the base structure of the TEXT_LH table type.

INTERFACE zkd_if_wrap_read_texts PUBLIC .

  TYPES:
    ts_texttable TYPE itclh,
    tt_texttable TYPE STANDARD TABLE OF ts_texttable.

  METHODS:
    read_texts
      IMPORTING
        iv_name       TYPE tdobname
        iv_object     TYPE tdobject
        iv_id         TYPE tdid
      EXPORTING
        et_text_table TYPE tt_texttable.

ENDINTERFACE.

You can now access the LINES component.

CLASS zkd_cl_call_wrap_read_texts DEFINITION PUBLIC.

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.

ENDCLASS.

CLASS zkd_cl_call_wrap_read_texts IMPLEMENTATION.

  METHOD if_oo_adt_classrun~main.

    DATA lo_wrapper TYPE REF TO zkd_if_wrap_read_texts.
    lo_wrapper = zkd_cl_wrap_factory=>get_wrap_read_texts(  ).

    lo_wrapper->read_texts(
      EXPORTING
        iv_name       = 'GLOSSAR         SAP'
        iv_object     = 'FORM'
        iv_id         = 'TXT'
      IMPORTING
        et_text_table = DATA(lt_text_table) ).

    READ TABLE lt_text_table INTO DATA(ls_text_table) INDEX 1.
    DATA(lt_lines) = ls_text_table-lines.

  ENDMETHOD.

ENDCLASS.

However, the ITCLH structure has the TDFORMAT component, which has a non-elementary type. When you try to access it from ABAP for Cloud Development, you’ll receive the “The use of element <element_name> of <object_type> <object_name> is not permitted” syntax check message.

This time, you won’t be able to fix it unless you define your own types.

Ensuring Consistency

Run the “API Release: Consistency of Released Objects” (API_CONSISTENCY) ATC check for your wrappers. Among other things, this checks if the components of your wrapper interface are accessible from ABAP for Cloud Development. In case of findings, rework your wrapper interfaces as recommended above.

Let’s take a look again at the negative example.

INTERFACE zkd_if_wrap_read_texts PUBLIC .

  TYPES:
    tt_texttable TYPE text_lh.

  METHODS:
    read_texts
      IMPORTING
        iv_name       TYPE tdobname
        iv_object     TYPE tdobject
        iv_id         TYPE tdid
      EXPORTING
        et_text_table TYPE tt_texttable.

ENDINTERFACE.

If you run the consistency check for this wrapper interface, you’ll receive the following check messages. It’ll report problems with the missing line types:

Read the Checking the Consistency of Released APIs documentation for more information.

Common Pitfalls

Usage of Unreleased Objects

A known issue (see SAP note 3450531) is that earlier syntax checks allowed access to:

Unreleased CDS entities via associations
Unreleased components of a complex structure

This got fixed and the syntax checks were tightened, and violations result in the “The use of element <element_name> of <object_type> <object_name> is not permitted” check message. The new syntax check message was added as a warning in 2023 and the priority got increased to error in 2025.

Hence, if you receive this check message, follow the guidance provided in the note. If the check message is caused by your wrapper being released incompletely as shown above, adjust the wrapper interface as recommended in this blog.

False Positives in Syntax Checks

Unfortunately, there is another known issue (see SAP note 3362119) where some of these syntax check messages “The use of element <element_name> of <object_type> <object_name> is not permitted” were incorrect (false positives). Follow the guidance provided in the note and either apply the kernel correction (recommended) or exempt the false positive. In latter case, please make sure to exempt only false positives, since you’ll get real syntax errors when you upgrade the system to the 2025 release. If you’re unsure if it’s a false positive, consider running the API_CONSISTENCY ATC check. If the check reports a finding, then fix it, since it’s not a false positive.

Icing On the Cake: Ensuring Compatibility

In the ABAP Cloud Development model, using released SAP APIs is a core principle. Released SAP APIs are officially supported and have stable interfaces.

SAP guarantees backward compatibility
Your code will continue to work after upgrades or patches
No risk from using internal or unreleased objects that might change or disappear

A released API is not upgrade-stable just because it’s released. SAP provides tools and checks that can be used to identify incompatible changes for released APIs: To detect and prevent incompatible changes in released APIs, the API_COMPATIBILITY ATC check is provided. Any change that is not allowed according to the compatibility rules of the release contract will be reported by this ATC check. To check compatibility, the ATC check uses so-called API snapshots. You can create API snapshots at any time using the Manage API Snapshots app.

Even if you don’t ship the released APIs to third parties but just release APIs for bridging classic APIs to the ABAP Cloud Development model, make use of the compatibility check. For example, if you reference a non-released SAP data element in your wrapper interface and SAP changes the data element in an incompatible way, then the compatibility check will inform you about this change and you can react accordingly.

Read the Checking the Compatibility of Released APIs documentation for more information.

Key Takeaways

To sum up,

Wrapper interfaces are a core pattern for clean core extensibility
They decouple your application from SAP internals
Proper data type declaration is crucial
ATC checks help you create consistent wrappers
Take the “The use of element <element_name> of <object_type> <object_name> is not permitted” syntax check message seriously

Understanding field(suppress) in SAP RAP and How It Differs from @UI.hidden and @Consumption.hidden

2026-06-25T20:52:31.333000+02:00

INTRODUCTION

When working with SAP RAP (RESTful Application Programming Model), the Behavior Definition (BDEF) offers several keywords to control how data is exposed and handled. One of the less-discussed but powerful ones is field(suppress).

This blog is not just about syntax — it’s about what actually happens at runtime, the edge cases I hit, and why I chose suppression over readonly.

Requirement: In had one requirement, customer service reps needed to update Priority, Deadline Date, Cancel Reason, but they should never touch Created Time or Created User. These audit fields must remain intact, even during draft saves or mass updates.

What I Tried First
@UI.hidden: Hid the fields in Fiori, but they were still exposed in OData payloads.

field(readonly): Made the fields immutable, but they still appeared in EML structures — meaning a payload could attempt to overwrite them.

Both approaches failed to fully protect the audit fields.

What is field(suppress)?
field(suppress) is a static feature control in the BDEF that removes a field from RAP's transactional behavior layer. When a field is marked as suppressed, RAP excludes it from:

EML (Entity Manipulation Language) structures — such as TYPE TABLE FOR CREATE, TYPE STRUCTURE FOR UPDATE
RAP-generated behavior APIs
Behavior-related metadata

Runtime Behavior of Suppressed Fields
When I switched to field(suppress), here’s what I observed:

In EML statements, suppressed fields simply don’t exist. If you try to reference them, RAP silently ignores them, no runtime dump, no short dump.

If you mistakenly add them in the mapping section, RAP throws a framework error at activation time.

In draft handling, suppressed fields are still maintained internally, but you can’t overwrite them. This was critical for audit consistency.

In determinations, you cannot reference suppressed fields — the compiler blocks it. I observed this when trying to auto-populate Created By and Created At.

Syntax:

define behavior for ZI_REQHDR {
    field ( suppress ) CreatedAt, CreatedBy; 
}

Attempting to map them in the behavior pool raises:
Field "CreatedBy" cannot be suppressed.

Key insight: field(suppress) is a behavior-layer protection tool — it removes a field from RAP-generated transactional types and APIs. It is not a UI visibility control or an OData filter

Why Suppress Instead of Readonly
Readonly: Field is visible but immutable — still exposed in payloads.

Suppress: Field is completely removed from RAP’s transactional model — safest option for audit fields.

Note: Key fields (primary key fields) cannot be suppressed.

Suppressed fields must also be excluded from the field mapping. Attempting to include them raises a framework error:

mapping for zdt_vd_reqhdr corresponding
{
    RequestUuid   = request_uuid;
    Status        = status;
    Priority      = priority;
    ExternalId    = external_id;
    DeadlineDate  = deadline_date;
    RequesterId   = requester_id;
    CancelReason  = cancel_reason;

* // If i try to add the below fields error will get raised
*   CreatedBy     = created_by; // Field "CreatedBy" cannot suppressed
*   CreatedAt     = created_at; // Field "CreatedAt" cannot suppressed

    LastChangedBy = last_changed_by;
    LastChangedAt = last_changed_at;
}

Behavior Pool: Effect on EML Strutcure

Once suppressed, the fields are no longer available in EML operations. For example, in a MODIFY ENTITIES call, suppressed fields do not appear in the FIELDS ( ) selector:

 MODIFY ENTITIES OF zi_vd_reqhdr IN LOCAL MODE
    ENTITY RequestHeader
    UPDATE FIELDS (  ) 
* i try add the fields which i have done suppressed those not visible here 
    WITH VALUE #( FOR ls_key IN keys
                  ( %key = ls_key-%key
                  Status = 100 ) )
    REPORTED DATA(lt_report).

This confirms that suppressed fields are cleanly removed from the generated TYPE STRUCTURE FOR UPDATE and equivalent EML types.

How Does It Differ from `@ui.hidden` and `@Consumption.hidden`?

All three mechanisms can "hide" a field, but they operate at different layers:

Mechanism Layer Effect

`field(suppress)`	RAP behavior / EML	Removes field from RAP transactional APIs and EML structures
`@ui.hidden: true`	UI rendering	Hides the field from generated Fiori screens; field may still appear in OData metadata and API payloads
`@Consumption.hidden: true`	OData consumption	Hides the field from OData consumers and Fiori Elements scenarios

Use field(suppress) to protect a field from the RAP behavior layer entirely.
Use @ui.hidden to keep a field out of the UI while it remains accessible in APIs.
Use @Consumption.hidden to hide a field from external OData consumers.

Conclusion

field(suppress), @ui.hidden, and @Consumption.hidden serve distinct purposes in the RAP stack and should not be treated as interchangeable. When you have internal technical fields — timestamps, UUIDs, control fields — that RAP should never expose through its transactional model, field(suppress) is the right tool. Pair it with @Consumption.hidden to lock down the field at both the behavior and OData layers.

Updating Sales Order Header and Sales Order Item using Business Object Framework(Cleancore Approach)

2026-06-26T07:11:15.507000+02:00

In RAP, business processes are encapsulated within Business Objects (BOs), which define the data model and business logic. Developers interact with these Business Objects using the Entity Manipulation Language (EML), a modern ABAP syntax that supports operations such as CREATE, UPDATE, DELETE, and EXECUTE. By leveraging RAP and EML, applications become more maintainable, extensible, and upgrade-safe while adhering to SAP's Clean Core strategy and cloud-ready development standards.

Example : -

MODIFY ENTITIES OF i_salesordertp

ENTITY salesorder

UPDATE FIELDS ( zz1_testdata_sdh )

WITH VALUE #( (

%key-salesorder = keys[ 1 ]-salesorder

zz1_testdata_sdh = 'TestingData'

) )

ENTITY salesorderitem

UPDATE FIELDS ( zz1_status1_sdi )

WITH VALUE #(

(

%key-salesorder = keys[ 1 ]-salesorder

%key-salesorderitem = keys[ 1 ]-itemno

zz1_status1_sdi = keys[ 1 ]-%param-status

)

Note: The approach described here is not limited to custom fields. It applies to any field exposed by the SalesOrder or SalesOrderItem Business Object, regardless of whether the field is standard or custom.

If you introduce a custom field by directly appending standard database tables (for example, VBAK or VBAP), you must manually extend the entire data exposure layer. This typically involves extending CDS views, updating OData services, enhancing APIs, and ensuring the field is propagated across all relevant artifacts, which increases development effort and maintenance complexity.

A more Clean Core–compliant approach is to create custom fields using the Custom Fields and Logic (CFL) framework. When configured and enabled correctly, CFL automatically extends the relevant CDS views, OData services, and Business Objects, significantly reducing manual development. To ensure end-to-end availability of the custom field, enable the required UIs, SAP GUI, CDS Views, and APIs during field creation. For implementing custom business logic, use Cloud BAdIs instead of classical enhancement techniques.

For a detailed walkthrough on enabling CFL artifacts and implementing Cloud BAdIs, please refer to my previous blog.

- https://community.sap.com/t5/technology-blog-posts-by-sap/custom-field-and-logic-from-scratch/ba-p/14426888

Make ChatGPT or Claude generate correct ABAP syntax - a free, 2-minute setup

2026-06-30T00:04:37.362000+02:00

AI assistants write ABAP that looks right and then fails the syntax check — obsolete statements, RAP behavior definitions that don't parse, classic-only syntax in supposedly Cloud-ready code. The fix isn't a better prompt. It's giving the assistant what every other language already gives it: a syntax checker it can call while it works, so errors get caught and fixed before the code ever reaches you.

I built that missing piece after 15 years of ABAP and open-sourced it (MIT): abap-mcp, which runs abaplint (Lars Hvam's open-source ABAP parser, ~180 rules) as a tool your AI assistant can call — entirely offline, no SAP system, no credentials. Here's the full setup.

Step 1 — Prerequisite. Node.js 20+ on your machine (nodejs.org). That's it.

Step 2 — Connect your assistant (Claude Code, Cursor, VS Code agent mode, or any MCP client). One command:

claude mcp add abap-mcp -- npx -y abap-mcp

claude mcp add abap-mcp -- npx -y abap-mcp

(For Cursor/VS Code: add { "mcpServers": { "abap-mcp": { "command": "npx", "args": ["-y", "abap-mcp"] } } } to your MCP config.)

Step 3 — Make the checking automatic. Add one line to your project notes (CLAUDE.md / Cursor rules):

Before claiming any ABAP change is done, lint it with abap-mcp. For ABAP Cloud targets, run the readiness check too.

From now on the assistant writes ABAP → lints it → gets exact parser errors with line numbers → fixes → re-lints — and only shows you code that parses clean. You'll see it happen in the tool-call log.

Step 4 — Using plain ChatGPT (no MCP)? Use the same engine as a command line and check the generated code yourself before it goes near a transport:

npx abap-mcp lint zcl_generated.clas.abap
npx abap-mcp readiness src/ --fail-below 80    # whole abapGit repo: ABAP Cloud readiness score

Step 5 — Try these prompts once connected:

"Lint this class against ABAP Cloud and fix every finding."

"Is this report cloud-ready? Categorize the blockers."

"Scaffold a draft-enabled RAP BO for entity Booking, table zbooking, key booking_id." (every generated class and CDS view is validated through the parser before you see it)

"Explain why exit_or_check was flagged, with the Clean ABAP rationale."

What it honestly can and can't catch: everything the parser sees — syntax, statement validity per ABAP language version (including Cloud), structure, Clean ABAP style. It does not know your DDIC (a wrong field name on a table the assistant wasn't shown still gets through — provide the dependent objects in the same call to close that), and released-API compliance remains ATC's job; the tool says so on every report. It complements ADT-connected MCP servers (including SAP's upcoming one) — they're the hands on a live system, this is the feedback loop where your files live.

Repo with a cookbook (PR review without a transport, migration triage, CI gates, agent workflows): github.com/palimkarakshay/abap-mcp · npm: abap-mcp

I'd really value your feedback — try it on your own Z-code and tell me: What does your assistant still get wrong (syntax, obsolete statements, BDEF structure, Cloud restrictions)? Did the readiness categories match how you'd size remediation? What would you want checked offline that today forces a system round-trip? Replies here or GitHub issues both welcome — that's what the next version gets built around.

(Not affiliated with SAP; SAP, ABAP and RAP are SAP SE trademarks.)

How to Scan Custom ABAP for Security Issues in Eclipse (Step-by-Step)

2026-07-03T10:20:40.741000+02:00

Disclosure: I work on this tool at RedRays. This post is a straightforward setup guide, not a product pitch.

This post walks through connecting Eclipse to a static analysis backend that scans custom ABAP for common security issues (SQL injection, missing authorization checks, hard-coded credentials, weak crypto, and similar) and returns findings directly in the IDE.

Prerequisites

- Eclipse 2024-09 or newer
- SAP ABAP Development Tools (ADT) installed
- Java 17
- Network access to the backend you plan to scan against (in this walkthrough, a demo instance)

Step 1: Get an API key

The plugin needs an API key to authenticate against a scan backend. For testing, there's a self-service demo instance:

1. Open get.abap-security.com.
2. Enter a name and email address.
3. Click Create my Eclipse API key.
4. Copy the key immediately - it is displayed once.

Notes on the demo instance:
- Limited to one key per IP address per time window.
- It is a shared instance - do not submit confidential or production code to it. For real use, point the plugin at your own tenant or an on-premise instance instead (see "Beyond the demo" below).

Step 2: Install the plugin

In Eclipse:

1. Help → Install New Software…
2. Click Add… and enter the update site: plugin.abap-security.com
3. Select RedRays ABAP Scanner from the list.
4. Finish the wizard and restart Eclipse when prompted.

Step 3: Configure the connection

1. Window → Preferences → RedRays Scanner
2. Set Working mode to RedRays.
3. Set RedRays URL to https://demo.abap-security.com:8443/ (or your own instance's URL).
4. Paste the API key from Step 1 into RedRays API key.
5. Click Test connection and confirm it succeeds before continuing.

Step 4: Run a scan

1. Right-click any ABAP object in the Project Explorer.
2. Select Scan with RedRays.
3. Choose the Quick scan profile for a first run.
4. Findings appear in a dedicated Eclipse view as the scan completes.

Reading the results

- Findings are grouped by severity: Critical, High, Medium, Low.
- Double-clicking a finding opens the source at the exact line.
- Each finding includes a CVSS score and an automated exploitability check, intended to reduce false positives that would otherwise need manual triage.

Categories currently covered include: SQL/ADBC injection, OS command execution, dynamic WHERE/ORDER BY clauses, path traversal on OPEN DATASET, RFC trust issues, missing AUTHORITY-CHECK, hard-coded credentials, and weak cryptographic algorithms (MD5/SHA-1), among others.

Beyond the demo

The same plugin can point at a privately provisioned tenant or an on-premise instance instead of the shared demo, with isolated access per subaccount and no source retention (code is scanned in memory and discarded; only findings are stored). There is also a REST API for scanning from CI/CD, including an endpoint that returns an allow/block decision for a transport based on a severity threshold - useful as a pre-import gate.

Resources

- Plugin overview: redrays.io/abap-scanner-eclipse-plugin
- Demo / API key: get.abap-security.com

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 rename an OData V4 service?

2026-07-04T12:04:41.946000+02:00

Introduction

I was approached by a colleague from SAP Fiori Elements development who noticed that it is possible to change the service name of an OData V4 service in an OData V4 service binding.

As a result the OData service URL will change as well, which would mean that an existing deployed app will not work anymore.

Result in short

Original service URL

/sap/opu/odata4/sap/zui_travel_o4_af/srvd/sap/zui_travel_o4/0001/

Service URL if the service is being renamed

/sap/opu/odata4/sap/zui_travel_o4/srvd/sap/zui_travel_o4_af/0001/

Service URL's if an additional service definition is being created and a new service version based on that new service definition is being created

/sap/opu/odata4/sap/zui_travel_o4/srvd/sap/zui_travel_o4/0002/
/sap/opu/odata4/sap/zui_travel_o4/srvd/sap/zui_travel_o4/0001/

Service URL if a new service binding is being created for the new service definition

/sap/opu/odata4/sap/zui_travel_o4_af/srvd/sap/zui_travel_o4_af/0001/

This has the same effect from a service URL perspective than renaming the service in an existing service definition.

Trying it out

Using the "from Scratch Wizard" I generated an OData V4 UI service using the structure /DMO/TRAVEL as a template and created a service binding ZUI_TRAVEL_O4.

Using the OData V4 catalog service we can find out more details about this service.

(I just use relative URL's to the hostname of the SAP BTP ABAP Environment system being used. But the same can be tried out in an on premise system as well.)

/sap/opu/odata4/iwfnd/config/default/iwfnd/catalog/0002/ServiceGroups?$expand=DefaultSystem($expand=Services)&$top=500&$filter=GroupId%20eq%20%27ZUI_TRAVEL_O4%27

The response when having published the service looks like follows:

{
  "@odata.context": "$metadata#ServiceGroups(DefaultSystem(Services()))",
  "@odata.metadataEtag": "W/\"20260211141301\"",
  "value": [
    {
      "GroupId": "ZUI_TRAVEL_O4",
      "Description": "R3TR G4BA ZUI_TRAVEL_O4",
      "DefaultSystem": {
        "SystemAlias": "LOCAL",
        "Description": "Current Client",
        "Services": [
          {
            "RepositoryId": "DEFAULT",
            "ServiceId": "/IWBEP/COMMON",
            "ServiceVersion": "0001",
            "ServiceType": null,
            "IsReleasedC2": false,
            "ServiceAlias": "",
            "ServiceAliasVersion": "0000",
            "Description": "V4 Common Service",
            "ServiceUrl": "/sap/opu/odata4/sap/zui_travel_o4/default/iwbep/common/0001/?sap-client=100"
          },
          {
            "RepositoryId": "SRVD",
            "ServiceId": "ZUI_TRAVEL_O4",
            "ServiceVersion": "0001",
            "ServiceType": "UI",
            "IsReleasedC2": false,
            "ServiceAlias": "ZUI_TRAVEL_O4",
            "ServiceAliasVersion": "0001",
            "Description": "Service Definition for ZC_TRAVEL",
            "ServiceUrl": "/sap/opu/odata4/sap/zui_travel_o4/srvd/sap/zui_travel_o4/0001/?sap-client=100"
          }
        ]
      }
    }
  ]
}

Option 1 - Renaming the service

When you try to rename the service in the service binding you first will find out that this doesn't work when the service has already been published.

When the service is unpublished you can rename it, e.g. to e.g. ZUI_TRAVEL_O4_AF.

After you have performed this change you have to press the publish locally button again.

This then changes the Service Alias and hence the OData ServiceURL.

The Service URL if the service is being renamed is now:

/sap/opu/odata4/sap/zui_travel_o4/srvd/sap/zui_travel_o4_af/0001/

When checking the entry in the service catalog we will find that the service catalog entry is still there but contains a different service URL.

{
  "@odata.context": "$metadata#ServiceGroups(DefaultSystem(Services()))",
  "@odata.metadataEtag": "W/\"20260211141301\"",
  "value": [
    {
      "GroupId": "ZUI_TRAVEL_O4",
      "Description": "R3TR G4BA ZUI_TRAVEL_O4",
      "DefaultSystem": {
        "SystemAlias": "LOCAL",
        "Description": "Current Client",
        "Services": [
          {
            "RepositoryId": "DEFAULT",
            "ServiceId": "/IWBEP/COMMON",
            "ServiceVersion": "0001",
            "ServiceType": null,
            "IsReleasedC2": false,
            "ServiceAlias": "",
            "ServiceAliasVersion": "0000",
            "Description": "V4 Common Service",
            "ServiceUrl": "/sap/opu/odata4/sap/zui_travel_o4/default/iwbep/common/0001/?sap-client=100"
          },
          {
            "RepositoryId": "SRVD",
            "ServiceId": "ZUI_TRAVEL_O4",
            "ServiceVersion": "0001",
            "ServiceType": "UI",
            "IsReleasedC2": false,
            "ServiceAlias": "ZUI_TRAVEL_O4_AF",
            "ServiceAliasVersion": "0001",
            "Description": "Service Definition for ZC_TRAVEL",
            "ServiceUrl": "/sap/opu/odata4/sap/zui_travel_o4/srvd/sap/zui_travel_o4_af/0001/?sap-client=100"
          }
        ]
      }
    }
  ]
}

Option 2 - Creating another service version

Instead of renaming the service it is possible to create a second service version in the same service binding. For this you have however to create a new service definition. So we simply copy the existing service definition ZUI_TRAVEL_O4 and create an additional service definition. to ZUI_TRAVEL_O4_AF.

Service Definition ZUI_TRAVEL_O4

@EndUserText: {
  label: 'Service Definition for ZC_TRAVEL'
}
@ObjectModel: {
  leadingEntity: {
    name: 'ZC_TRAVEL'
  }
}
define service ZUI_TRAVEL_O4 provider contracts odata_v4_ui {
  expose ZC_TRAVEL as Travel;
}

Service Definition ZUI_TRAVEL_O4_AF

Here we expose an additional CDS view so that both services can be better distinguised.

@EndUserText: {
  label: 'Service Definition for ZC_TRAVEL'
}
@ObjectModel: {
  leadingEntity: {
    name: 'ZC_TRAVEL'
  }
}
define service ZUI_TRAVEL_O4_AF
  provider contracts odata_v4_ui {
  expose ZC_TRAVEL  as Travel;
  expose I_Currency as MyCurrency;
}

When checking the service binding we see two version of our service, 1.0.0 and 2.0.0.

The service version 2.0.0 exposes two entities as expected.

And the service URL's differ by the service version 0001 and 0002

/sap/opu/odata4/sap/zui_travel_o4/srvd/sap/zui_travel_o4/0001/
/sap/opu/odata4/sap/zui_travel_o4/srvd/sap/zui_travel_o4/0002/

When checking the OData V4 service catalog we find an additional entry in our service group ZUI_TRAVEL_O4.

{
  "@odata.context": "$metadata#ServiceGroups(DefaultSystem(Services()))",
  "@odata.metadataEtag": "W/\"20260211141301\"",
  "value": [
    {
      "GroupId": "ZUI_TRAVEL_O4",
      "Description": "R3TR G4BA ZUI_TRAVEL_O4",
      "DefaultSystem": {
        "SystemAlias": "LOCAL",
        "Description": "Current Client",
        "Services": [
          {
            "RepositoryId": "DEFAULT",
            "ServiceId": "/IWBEP/COMMON",
            "ServiceVersion": "0001",
            "ServiceType": null,
            "IsReleasedC2": false,
            "ServiceAlias": "",
            "ServiceAliasVersion": "0000",
            "Description": "V4 Common Service",
            "ServiceUrl": "/sap/opu/odata4/sap/zui_travel_o4/default/iwbep/common/0001/?sap-client=100"
          },
          {
            "RepositoryId": "SRVD",
            "ServiceId": "ZUI_TRAVEL_O4",
            "ServiceVersion": "0001",
            "ServiceType": "UI",
            "IsReleasedC2": false,
            "ServiceAlias": "ZUI_TRAVEL_O4",
            "ServiceAliasVersion": "0001",
            "Description": "Service Definition for ZC_TRAVEL",
            "ServiceUrl": "/sap/opu/odata4/sap/zui_travel_o4/srvd/sap/zui_travel_o4/0001/?sap-client=100"
          },
          {
            "RepositoryId": "SRVD",
            "ServiceId": "ZUI_TRAVEL_O4_AF",
            "ServiceVersion": "0001",
            "ServiceType": "UI",
            "IsReleasedC2": false,
            "ServiceAlias": "ZUI_TRAVEL_O4",
            "ServiceAliasVersion": "0002",
            "Description": "Service Definition for ZC_TRAVEL",
            "ServiceUrl": "/sap/opu/odata4/sap/zui_travel_o4/srvd/sap/zui_travel_o4/0002/?sap-client=100"
          }
        ]
      }
    }
  ]
}

Option 3 - Creating another service

Another option would be to create a new service binding ZUI_TRAVEL_O4_AF from our new service definition ZUI_TRAVEL_O4_AF.

Here the service URL is named

/sap/opu/odata4/sap/zui_travel_o4_af/srvd/sap/zui_travel_o4_af/0001/

So this has from a OData Service URL perspective the same effect as when you rename the existing service.

It has however the big advantage of not being that disruptive and you can decide either to publish a second app using the new URL or to perform the changes to the app only after having transported the newly created service to production.

In order to find your service in the service catalog you have to change the filter as follows:

/sap/opu/odata4/iwfnd/config/default/iwfnd/catalog/0002/ServiceGroups?$expand=DefaultSystem($expand=Services)&$top=500&$filter=GroupId%20eq%20%27ZUI_TRAVEL_O4_AF%27

and would get the following result.

{
  "@odata.context": "$metadata#ServiceGroups(DefaultSystem(Services()))",
  "@odata.metadataEtag": "W/\"20260211141301\"",
  "value": [
    {
      "GroupId": "ZUI_TRAVEL_O4_AF",
      "Description": "R3TR G4BA ZUI_TRAVEL_O4_AF",
      "DefaultSystem": {
        "SystemAlias": "LOCAL",
        "Description": "Current Client",
        "Services": [
          {
            "RepositoryId": "DEFAULT",
            "ServiceId": "/IWBEP/COMMON",
            "ServiceVersion": "0001",
            "ServiceType": null,
            "IsReleasedC2": false,
            "ServiceAlias": "",
            "ServiceAliasVersion": "0000",
            "Description": "V4 Common Service",
            "ServiceUrl": "/sap/opu/odata4/sap/zui_travel_o4_af/default/iwbep/common/0001/?sap-client=100"
          },
          {
            "RepositoryId": "SRVD",
            "ServiceId": "ZUI_TRAVEL_O4_AF",
            "ServiceVersion": "0001",
            "ServiceType": "UI",
            "IsReleasedC2": false,
            "ServiceAlias": "ZUI_TRAVEL_O4_AF",
            "ServiceAliasVersion": "0001",
            "Description": "Service Definition for ZC_TRAVEL",
            "ServiceUrl": "/sap/opu/odata4/sap/zui_travel_o4_af/srvd/sap/zui_travel_o4_af/0001/?sap-client=100"
          }
        ]
      }
    }
  ]
}

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.

Building a RAP Application with External SAP HANA Cloud using CDS External Entities – Part 1

2026-07-08T10:49:55.174000+02:00

Why External Entities?

CDS external entities provide a modern way to handle secondary database connections in ABAP Cloud. They allow applications to retrieve and modify data from other databases using SQL. Sounds interesting? This blog post covers how to create a RAP application in SAP BTP ABAP Environment with a secondary HANA database connection.

Business scenario:

Many organizations already have business data stored in a separate SAP HANA Cloud database and want to build modern RAP (ABAP RESTful Application Programming Model) applications on SAP BTP ABAP Environment without replicating that data into the ABAP system.

The blog demonstrates this using a Loyalty Management application.

Scenario

Customer loyalty information (Memberships) is stored in an external SAP HANA Cloud database.
Transaction data related to each membership is also stored in the same external database.
The business wants a Fiori application where users can:
- Create loyalty memberships
- Maintain loyalty transactions
- Update and delete records
- View accumulated loyalty points
- Persist all changes directly in the external HANA database

Prerequisites:

SAP BTP Sub-Account
SAP HANA Cloud Instance
SAP BTP ABAP Environment

Steps:

Setup SAP HANA Cloud instance
Create Schema and Tables
Configure external connection to External HANA database from SAP BTP ABAP Environment using External Entities
Create External Entities

Setup SAP HANA Cloud instance

Let’s start on with the creation of SAP HANA Cloud instance.

Open SAP BTP cockpit and add the following Entitlements.
Create HANA cloud subscription.
Create HANA Cloud Instance

Specify Instance name, Set DBADMIN password and choose Allow all IP address
Spoiler
Disclaimer on Database IP Access Configuration
Allowing unrestricted access (e.g., permitting all IP addresses such as 0.0.0.0/0) to a database that contains production data introduces significant security risks. This approach should only be used in strictly controlled environments.
Once the Instance status turns into Running state and click on Actions three dots and Open in SAP HANA Database Explorer.
Provide the DBADMIN credentials from the previous step to connect to the HANA database.

Create Schema and Tables

Open SQL Console and perform the following steps to create the schema and tables.

Create Schema

CREATE SCHEMA LOYALTY;

Create Membership table: zlm_membship_ee .

Stores membership details
Primary key: client + membershipuuid

create column table loyalty."zlm_membship_ee" (
"client" nvarchar (000003) default '000' not null, 
"membershipuuid" varbinary (000016) default x'00000000000000000000000000000000' not null , 
"membershipid" nvarchar (000010) default '0000000000' not null, 
"customer" nvarchar (000010) default '' not null, 
"createdby" nvarchar (000012) default '' not null, 
"createdat" decimal (000021, 000007) default 0 not null, 
"lastchangedby" nvarchar (000012) default '' not null, 
"locallastchangedat" decimal (000021, 000007) default 0 not null, 
"lastchangedat" decimal (000021, 000007) default 0 not null,
primary key ("client", "membershipuuid" )     
) column loadable

Create Transactions table: zlm_transctns_ee

Stores transactions linked to membership.
Contains transaction value and loyalty points.

create column table loyalty."zlm_transctns_ee" (
"client" nvarchar (000003) default '000' not null, 
"transactionuuid" varbinary (000016) default x'00000000000000000000000000000000' not null ,
"membershipuuid" varbinary (000016) default x'00000000000000000000000000000000' not null , 
"transactiondate" NVARCHAR (000008) DEFAULT '00000000' NOT NULL, 
"transactionvalue" DECIMAL (000010, 000002) DEFAULT 0 NOT NULL, 
"transactioncurrency" NVARCHAR (000005) DEFAULT '' NOT NULL, 
"loyaltypoints" BIGINT DEFAULT 0 NOT NULL, 
"createdby" nvarchar (000012) default '' not null, 
"createdat" decimal (000021, 000007) default 0 not null, 
"lastchangedby" nvarchar (000012) default '' not null, 
"locallastchangedat" decimal (000021, 000007) default 0 not null, 
"lastchangedat" decimal (000021, 000007) default 0 not null,
primary key ("client", "transactionuuid" )     
) column loadable

Configure connectivity to an external SAP HANA database from Steampunk for data access using External Entities

Establish outbound SQL access using an external entity using ABAP Development Tools for Eclipse
1. Define and activate a logical external schema whose configuration specifies the connection details for the outbound communication. Create a logical external schema in ABAP Development Tools (ADT) using the creation wizard.
2. Create an Outbound Service of the type Outbound SQL Access for your logical external schema.
3. Create a Communication Scenario.
4. Include the outbound service in the communication scenario.
Configure External Connection
In the Fiori Launchpad, Logon as Administrator and perform the following steps.
1. Create a Communication Arrangement for scenario ZLM_COM_EXT_SCHEMA_EE.
2. Create a Communication System
  
  Toggle Remote SQL Access and choose Adapter Name as HANA (ODBC)
  Adapter Configuration :Driver=libodbcHDB.so;ServerNode=*.hanacloud.ondemand.com(URL of the External Database):443;
3. Create an Outbound User. Specify the HANA DB user which contains the necessary authorizations for accessing the External Schema.

Create CDS External Entities

Two types:
1. Writable External Entity → Used for INSERT/UPDATE/DELETE
2. Static External Entity → Used for SELECT (read only)

These entities map external tables to ABAP CDS.

In ABAP Development Tools for Eclipse: As an ABAP Developer, here’s what you need to do to establish outbound SQL access using a CDS external entity.

Define and activate an external entity that represents the external database object.As we are going to perform CUD operation on external database, we need to create Writable External Entity for table zlm_membship_ee which will be referred by external name zlm_membship_ee.

@EndUserText.label: 'Writable EE for HANA tab zlm_membship_ee'
define writable external entity zlm_membship_cud_ee external name "zlm_membship_ee"
{
  key client             : abap.char(3)                  external name "client";
  key membershipuuid     : sysuuid_x16                   external name "membershipuuid";
      membershipid       : zlm_membershipid_ee           external name "membershipid";
      customer           : zlm_customer_ee               external name "customer";
      @Semantics.user.createdBy: true
      createdby          : abp_creation_user             external name "createdby";
      @Semantics.systemDateTime.createdAt: true
      createdat          : abp_creation_tstmpl           external name "createdat";
      @Semantics.user.lastChangedBy: true
      lastchangedby      : abp_lastchange_user           external name "lastchangedby";
      @Semantics.systemDateTime.localInstanceLastChangedAt: true
      locallastchangedat : abp_locinst_lastchange_tstmpl external name "locallastchangedat";
      @Semantics.systemDateTime.lastChangedAt: true
      lastchangedat      : abp_lastchange_tstmpl         external name "lastchangedat";
}
with federated data provided at runtime

We need to create Writable External Entity for table zlm_transctns_ee

@EndUserText.label: 'Writable EE for HANAtab zlm_transctns_ee'
define writable external entity zlm_transctns_cud_ee external name "zlm_transctns_ee"
{
  key client              : abap.char(3)                  external name "client";
  key transactionuuid     : sysuuid_x16                   external name "transactionuuid";
      membershipuuid      : sysuuid_x16                   external name "membershipuuid";
      transactiondate     : zlm_transactiondate_ee        external name "transactiondate";
      @Semantics.amount.currencyCode : 'transactioncurrency'
      transactionvalue    : zlm_transactionvalue_ee       external name "transactionvalue";
      transactioncurrency : zlm_transactioncurrency_ee    external name "transactioncurrency";
      loyaltypoints       : zlm_loyaltypoints_ee          external name "loyaltypoints";
      @Semantics.user.createdBy: true
      createdby           : abp_creation_user             external name "createdby";
      @Semantics.systemDateTime.createdAt: true
      createdat           : abp_creation_tstmpl           external name "createdat";
      @Semantics.user.lastChangedBy: true
      lastchangedby       : abp_lastchange_user           external name "lastchangedby";
      @Semantics.systemDateTime.localInstanceLastChangedAt: true
      locallastchangedat  : abp_locinst_lastchange_tstmpl external name "locallastchangedat";
      @Semantics.systemDateTime.lastChangedAt: true
      lastchangedat       : abp_lastchange_tstmpl         external name "lastchangedat";
}
with federated data provided at runtime

To securely map a remote physical database object so it can be queried directly, we need to use STATIC EXTERNAL ENTITIES to fetch data from table zlm_membship_ee .

@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Static EE for HANA tab zlm_membship_ee'
define external entity zlm_membship_ee external name "zlm_membship_ee"
{
  key client             : abap.char(3)                  external name "client";
  key membershipuuid     : sysuuid_x16                   external name "membershipuuid";
      membershipid       : zlm_membershipid_ee           external name "membershipid";
      customer           : zlm_customer_ee               external name "customer";
      @Semantics.user.createdBy: true
      createdby          : abp_creation_user             external name "createdby";
      @Semantics.systemDateTime.createdAt: true
      createdat          : abp_creation_tstmpl           external name "createdat";
      @Semantics.user.lastChangedBy: true
      lastchangedby      : abp_lastchange_user           external name "lastchangedby";
      @Semantics.systemDateTime.localInstanceLastChangedAt: true
      locallastchangedat : abp_locinst_lastchange_tstmpl external name "locallastchangedat";
      @Semantics.systemDateTime.lastChangedAt: true
      lastchangedat      : abp_lastchange_tstmpl         external name "lastchangedat";
}
with federated data provided by zlm_ext_schema_ee

We need another STATIC EXTERNAL ENTITY for table zlm_transctns_ee

@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Static EE for HANA tab zlm_transctns_ee'
define external entity zlm_transctns_ee external name "zlm_transctns_ee"
{
  key client              : abap.char(3)                  external name "client";
  key transactionuuid     : sysuuid_x16                   external name "transactionuuid";
      membershipuuid      : sysuuid_x16                   external name "membershipuuid";
      transactiondate     : zlm_transactiondate_ee        external name "transactiondate";
      @Semantics.amount.currencyCode : 'transactioncurrency'
      transactionvalue    : zlm_transactionvalue_ee       external name "transactionvalue";
      transactioncurrency : zlm_transactioncurrency_ee    external name "transactioncurrency";
      loyaltypoints       : zlm_loyaltypoints_ee          external name "loyaltypoints";
      @Semantics.user.createdBy: true
      createdby           : abp_creation_user             external name "createdby";
      @Semantics.systemDateTime.createdAt: true
      createdat           : abp_creation_tstmpl           external name "createdat";
      @Semantics.user.lastChangedBy: true
      lastchangedby       : abp_lastchange_user           external name "lastchangedby";
      @Semantics.systemDateTime.localInstanceLastChangedAt: true
      locallastchangedat  : abp_locinst_lastchange_tstmpl external name "locallastchangedat";
      @Semantics.systemDateTime.lastChangedAt: true
      lastchangedat       : abp_lastchange_tstmpl         external name "lastchangedat";
}
with federated data provided by zlm_ext_schema_ee

Key Takeaways.

External entities enable real-time integration with external databases without replication.

In Part 2 of this series, we will build a RAP application using the data model created here.

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.

Clean Core Levels A–D: how to classify your custom ABAP — and what to do with each grade

2026-07-15T04:47:46.379000+02:00

Disclosure: I'm the author of this post and the creator of Clean-Core.io, a free, non-commercial community tool I mention once near the end. This post is educational; the tool is optional.

Overview

With the 2025 update to the ABAP extensibility guide, SAP evolved the familiar 3-tier extensibility model into the clean core level concept — a four-grade classification of custom extensions: A, B, C, D. Instead of a blunt "clean vs. not clean", it tells you how closely each extension aligns with Clean Core, and it maps directly to ABAP Test Cockpit (ATC) behaviour:

Level Usage of SAP objects in custom development ATC behaviour

A	Released SAP APIs (local & remote) and extension points	No message
B	Classic SAP APIs and extension points (SAP-recommended)	Priority 3 · info
C	Internal SAP APIs (conditionally clean via the changelog-for-SAP-objects check)	Priority 2 · warning
D	Not-recommended objects & extension technologies (modifications, implicit enhancements)	Priority 1 · error

Level A is the cleanest — on-stack ABAP Cloud or side-by-side on SAP BTP. Levels B–D describe classic ABAP, from SAP-recommended (B) down to not-recommended (D).

Why this matters now

Every custom object you carry into S/4HANA has to be defensible. The move from a binary "clean/not clean" to A–D is a gift — it lets you transform at your own pace, prioritising the worst first instead of trying to reach "100% clean" overnight.

The real problem

Knowing the model is easy. Grading thousands of custom objects against it is not. ATC flags readiness object-by-object, and the Cloudification Repository tells you which standard objects are released — but turning that into a per-object A/B/C/D verdict plus a remediation path, across a grown Z-landscape, is still mostly manual and inconsistent between teams.

A practical classification flow

Identify the custom object and what it touches (tables, APIs, function modules, enhancements).
Look up each dependency: released API/extension point → A; classic-but-official API → B; internal SAP object → C; modification / not-recommended access → D.
Decide remediation per grade: A keep · B keep, plan to lift later · C verify via the changelog-for-SAP-objects approach and wrap behind a released interface · D replace before the upgrade.

A worked example

A classic Z_CUSTOMER_REPORT:

SELECT kunnr, name1 FROM kna1 INTO TABLE @lt_cust.   " direct read of an internal standard table

Classify: direct access to KNA1 (an internal SAP object, not a released API) → Level C (ATC: warning). A direct write would be Level D (ATC: error).

Remediate: map to the released CDS view I_Customer → the same logic becomes Level A (ATC: no message):

SELECT Customer, CustomerName FROM I_Customer INTO TABLE @lt_cust.

One dependency, one grade, one clear next step. Repeat across the landscape and you get a prioritised backlog: fix D first (upgrade blockers), lift C, schedule B, keep A.

How I approached tooling this (optional)

To avoid doing this by hand, I built Clean-Core.io — a free, non-commercial community tool. It runs a deterministic evidence engine first (parsing the code, mapping dependencies against the catalog), then AI on top, and derives an A–D grade per detected object — aligned to the clean core level concept and its ATC priorities. It is complementary to ATC/ADT, not a replacement, and every output is a draft for a qualified architect to review. Free: clean-core.io (link in the comments).

Conclusion

The move from 3-tier to A–D isn't a relabel — it's a better mental model for prioritising custom-code remediation. Give each dependency an explicit grade, start with your Level D objects, and turn "we have a lot of Z-code" into a defensible, upgrade-ready plan.

How are you classifying your custom code against the new A–D levels today — by hand, ATC, or something else? I'd genuinely like to compare approaches in the comments.

RAP Augmentation in Managed Scenario – Enriching Transactional Requests Before BO Processing

2026-07-17T11:22:43.643000+02:00

Introduction

The RESTful Application Programming Model (RAP) provides several extension points for implementing business logic, such as Determinations, Validations, Actions, and Prechecks. RAP Augmentation adds another extension point that allows developers to enrich incoming create or update requests before the framework starts processing the business object.

This early execution makes augmentation useful for scenarios where default values, audit information, or business-specific data must be available before any further RAP processing takes place. In this blog, we will understand RAP Augmentation, compare it with Determinations, and implement it using an Employee Management example.

Business Requirement

I had a requirement an Employee Management application where users create and maintain employee records. During record creation, the application should automatically populate business-specific information instead of relying on users to enter every value manually.

The application should:

Set the employee status to PENDING_APPROVAL.
Determine whether approval is required based on the selected department.
Capture the current user as the creator.
Maintain audit information during updates.

Instead of implementing all this logic inside the business object, we will use RAP Augmentation to enrich the incoming request before standard processing begins.

Problem Statement

Determinations are commonly used in RAP to derive or update field values. However, they execute after the request has already entered the transactional buffer.

In some business scenarios, values must be available even before the business object starts processing. For example, default values or audit fields may be required before validations or other business logic execute. In such cases, Augmentation provides a cleaner and more suitable solution by enriching the request at the beginning of the transaction.

What is RAP Augmentation?

RAP Augmentation is an extension mechanism that runs during the Interactive Phase of a RAP transaction. It allows developers to enrich incoming create or update requests before the framework processes the business object.

Rather than modifying persisted data, augmentation focuses on preparing the request by supplying additional values or applying business-specific logic. Once the request is enriched, RAP continues with its normal processing flow.

Augmentation Flow

The request passes through augmentation before reaching the business object implementation. During this stage, additional values can be added or modified, ensuring the business object receives a complete request for further processing.

The overall execution flow is:

User sends a create or update request.
RAP invokes the registered augmentation.
The request is enriched with additional data.
Standard RAP processing continues.
Data is persisted to the database.

Augmentation vs Determination

Defined at the Projection Behavior Definition using use create/update (augment).	Defined at the Interface Behavior Definition using determination.
Implemented in a Projection Behavior Implementation Class	Implemented in the Behavior Pool class.
Runs during the Interactive Phase, before the BO implementation processes the request.	Runs during ON MODIFY or ON SAVE, after data enters the transactional buffer.
Used to enrich or modify the incoming request before BO processing.	Used to derive or recalculate values based on data in the transactional buffer.

When Execution timing matter?

The main advantage of Augmentation is when it executes. Since it runs before business object processing, any values added during augmentation are available to the rest of the RAP processing flow.

If the application should automatically set an employee's status or determine whether approval is required, these values are already present when the framework performs subsequent processing. If the same logic were implemented in a Determination, the values would only be available later in the transaction.

When to Use Augmentation?

Augmentation is a good choice when the incoming request needs to be enriched before RAP starts processing the business object.

Typical use cases include:

Setting default values.
Populating audit fields.
Deriving values from user input.
Performing lightweight request enrichment.
Preparing data required by later processing steps.

It is not intended to replace Determinations, which remain the preferred option for business logic that should execute after the request has entered the transactional buffer.

BDEF of Interface

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

define behavior for zaky_i_emp //alias <alias_name>
persistent table zaky_t_emp

lock master

authorization master ( instance )
//etag master <field_name>
{
  create( authorization : global ) ;
  update;
  delete;
  action Approve result [1] $self;
  mapping for zaky_t_emp
{
  Employeeid        = employeeid;
  Firstname         = firstname;
  Lastname          = lastname;
  Department        = department;
  Status            = status;
  Approvalrequired  = approvalrequired;
  Createdby         = createdby;
  Createdat         = createdat;
  Lastchangedby     = lastchangedby;
  Lastchangedat     = lastchangedat;
  }
}

BDEF of Projection

projection implementation in class zbp_aky_c_emp unique;
strict ( 2 );

define behavior for zaky_c_emp //alias <alias_name>
{
  use create( augment );
  use update( augment );
    use delete;
  field ( readonly ) Status;
  field ( readonly ) Approvalrequired;
  field ( readonly ) Createdby;
  field ( readonly ) Createdat;
  field ( readonly ) Lastchangedby;
  field ( readonly ) Lastchangedat;
  use action Approve;
}

BP of Projection

CLASS lhc_zaky_c_emp DEFINITION INHERITING FROM cl_abap_behavior_handler.
  PRIVATE SECTION.

    METHODS augment_create FOR MODIFY
      IMPORTING entities FOR CREATE zaky_c_emp.

    METHODS augment_update FOR MODIFY
      IMPORTING entities FOR UPDATE zaky_c_emp.

ENDCLASS.

CLASS lhc_zaky_c_emp IMPLEMENTATION.
  METHOD augment_create.
  LOOP AT entities INTO DATA(entity).

    IF entity-Department IS INITIAL.
      APPEND VALUE #(
        %cid = entity-%cid
        %msg = new_message_with_text(
                 severity = if_abap_behv_message=>severity-error
                 text     = 'Department is mandatory' ) )
      TO reported-zaky_c_emp.        

      APPEND VALUE #( %cid = entity-%cid )
      TO failed-zaky_c_emp.          
      CONTINUE.
    ENDIF.

    MODIFY AUGMENTING ENTITIES OF zaky_i_emp  
      ENTITY zaky_i_emp
      CREATE FIELDS ( Status Approvalrequired Createdby Createdat )
      WITH VALUE #( (
        %cid             = entity-%cid
        Status           = 'PENDING_APPROVAL'
        Approvalrequired = COND #(
                             WHEN entity-Department = 'HR'
                               OR entity-Department = 'FIN'
                             THEN abap_true
                             ELSE abap_false )
        Createdby        = sy-uname
        Createdat        = cl_abap_context_info=>get_system_date(  )
      ) ).

  ENDLOOP.
ENDMETHOD.

METHOD augment_update.
  LOOP AT entities INTO DATA(entity).

    MODIFY AUGMENTING ENTITIES OF zaky_i_emp   
      ENTITY zaky_i_emp
      UPDATE FIELDS ( Lastchangedby Lastchangedat )
      WITH VALUE #( (
        Employeeid    = entity-Employeeid
        Lastchangedby = sy-uname
        Lastchangedat = cl_abap_context_info=>get_system_date(  )
      ) ).

  ENDLOOP.
ENDMETHOD.
ENDCLASS.

BP of interface

METHOD Approve.

  " Read current status of the employee
  READ ENTITIES OF zaky_i_emp IN LOCAL MODE
    ENTITY zaky_i_emp
    FIELDS ( Status Employeeid )
    WITH CORRESPONDING #( keys )
    RESULT DATA(employees)
    FAILED DATA(read_failed).

  " Loop and update status
  LOOP AT employees INTO DATA(employee).

    " Only approve if current status is PENDING_APPROVAL
    IF employee-Status <> 'PENDING_APPROVAL'.
      APPEND VALUE #(
        %tky = employee-%tky
        %msg = new_message_with_text(
                 severity = if_abap_behv_message=>severity-error
                 text     = 'Only records with PENDING_APPROVAL status can be approved' ) )
      TO reported-zaky_i_emp.
      APPEND VALUE #( %tky = employee-%tky )
      TO failed-zaky_i_emp.
      CONTINUE.
    ENDIF.

    " Update status to APPROVED
    MODIFY ENTITIES OF zaky_i_emp IN LOCAL MODE
      ENTITY zaky_i_emp
      UPDATE FIELDS ( Status )
      WITH VALUE #( (
        %tky   = employee-%tky
        Status = 'APPROVED'
      ) )
      FAILED   DATA(update_failed)
      REPORTED DATA(update_reported).

    " Pass back result
    APPEND VALUE #(
      %tky   = employee-%tky
      %param = employee
    ) TO result.

  ENDLOOP.
ENDMETHOD.

Output

Click on the create

After adding the value click on the create and put the debugger on the create-augment method to check it is triggering or not because we are doing managed application where creation is handled by framework

Execute

Currently it is in pending state click on the Approve employee.

After clicking on action

If you not adding the department

Conclusion

RAP Augmentation provides a simple and effective way to enrich transactional requests before the RAP framework begins processing the business object. It is particularly useful for populating default values, maintaining audit information, and preparing request data that should be available throughout the transaction.

In this example, we used augmentation to automatically populate employee details while keeping the business object implementation clean and maintainable. Understanding when to use Augmentation instead of Determinations helps developers choose the right extension point and build more maintainable RAP applications

Secure Outbound Communication in ABAP Cloud

2026-07-20T09:00:00.024000+02:00

Introduction

Modern ABAP development, especially in cloud environments, is increasingly centered around one core idea: while application logic still triggers and executes the outbound calls, the underlying communication configuration and connection settings must be strictly separated from the application logic to ensure secure and controlled integration. Whether an application calls an external HTTP service or an RFC-enabled system, the goal is no longer just to make the call succeed, but to ensure that every connection is governed, traceable, and aligned with clean-core principles.

SAP addresses this through a structured communication model in SAP S/4HANA Cloud Public Edition, SAP BTP ABAP environment and SAP S/4HHANA Private Cloud Edition.

The model is based on two pillars: The development object Communication Target (CoTa) and the configuration stored in so called Application Destinations.

In SAP S/4HANA Cloud Private Edition (and in on-premise), integrations require both the communication target and the application destinations to be maintained explicitly. In contrast, for SAP S/4HANA Cloud Public Edition and SAP BTP ABAP Environment, the application destination is generated automatically when the administrator saves the communication arrangement, further simplifying configuration and lifecycle management. While the system handles the creation of the destination automatically, meaning customers do not need to write custom code to save the destination itself, users retain full control over where the automatically generated destination name is stored and maintained within the system (see Executing Custom Code During a Communication Arrangement Save | SAP Help Portal )

While ABAP Cloud preserves the principle of separating configuration from application logic and still requires code adaptations when communication protocols change (for example, from RFC to HTTP), it significantly modernizes connectivity management.

Communication targets replace this approach with a formal development object that represents the intended communication purpose. Rather than referencing a technical destination directly, application code refers to the communication target, and the runtime framework resolves the underlying destination. This automation applies when there is only a single application destination, in other words, the application logic remains completely unaware of the application destination name.

If multiple application destinations exist, the specific name of the application destination must still be explicitly provided in the code, just as with a traditional SM59 destination.

Communication targets also act as a logical control layer that governs access to destinations. Unlike the traditional model, where any application could potentially reuse a destination if its name was known, communication targets explicitly define which applications are allowed to use a particular destination. This prevents uncontrolled reuse and establishes a clearer and more governed communication model.

By enforcing this explicit authorization, the model mitigates critical security risks, such as:

Data Spoofing & Interception: Unauthorized applications can no longer masquerade as legitimate services to intercept sensitive data streams.
Resource Depletion (DoS): Rogue or compromised applications are prevented from flooding a destination with traffic, ensuring high availability for authorized users.
Privilege Escalation: It eliminates the risk of an application accidentally (or maliciously) gaining access to high-privilege backend systems simply by guessing a destination name.

More in Communication Target | SAP Help Portal and Using Communication Targets | SAP Help Portal

Although both communication targets and SM59 destinations separate configuration from business logic, communication targets extend this concept through stronger lifecycle integration, improved traceability, controlled destination access, and greater flexibility in managing tenant-specific configuration.

Besides, communication targets deliver key architectural upgrades by utilizing an object-oriented class basis. Because all communication is routed through communication targets, the user can perform reliable where-used analysis and runtime validation. In addition, communication targets allow developers to define general communication settings and client dependency as part of the development object, reducing configuration errors and simplifying administration. These two advantages represent the core improvements of the new concept.

HTTP Communication via Communication Targets

For HTTP communication, this model is reinforced by communication target. Each outbound call is validated at runtime to ensure that the application is authorized to use the destination behind the communication target. This major improvement over the classic model significantly strengthens security by design.

From a development perspective, the beauty of this model is its simplicity in code. Once a communication arrangement is defined and the application destination is generated, the ABAP implementation becomes clean and focused purely on business logic. All technical details such as URLs, authentication, and certificates, are handled outside the application.
In case there will be only one application destination (most likely case), a typical HTTP call in ABAP Cloud looks like below.

DATA: lo_cota TYPE REF TO ZCT_EXAMPLE.

lo_cota = NEW ZCT_EXAMPLE(application_destination = 'Z_APPLDEST_EXAMPLE' ).

DATA(lo_client) = lo_cota->create_web_http_client( ).

DATA(lo_response) = lo_client->execute( if_web_http_client=>get ).

However, if multiple application destinations are available for the Communication target, you must explicitly pass the name of the relevant application destination as a parameter to ensure the outbound call maps to the correct target system.

The code is intentionally minimal. For example, in Cloud, the application. This ensures that the application can only communicate with endpoints that are explicitly approved.

RFC Communication via Communication Targets

The same principle applies to RFC communication: for outbound RFC calls, you should use communication targets together with the application destination. The same principle applies to RFC communication: for outbound RFC calls, it is recommended to use communication targets together with the application destination.
The architectural lifecycle of application destinations is conceptually identical for both RFC and HTTP protocols; in both cases, the communication target serves as the abstract reference in your ABAP code, while administrators manage the destination details. The distinction lies purely in the developer implementation at runtime, where protocol-specific configuration and distinct APIs, such as classic function modules for RFC versus HTTP client classes for REST, must be used to execute the call.

In the newer governance model, RFC connections can be governed through communication arrangements and communication targets, providing the same structured, secure, and centrally managed approach that is already used for HTTP communication. In code, the call may still look familiar:

DATA: lo_cota TYPE REF TO ZCT_EXAMPLE.
    lo_cota = NEW ZCT_EXAMPLE( ).
    DATA(lo_remote_session) = lo_cota->create_session( ).
    CALL FUNCTION 'RFC_PING' IN REMOTE SESSION lo_remote_session.

The important difference is not only in the governance of the destination, but also in the syntax itself, which is an important aspect of the new concept. A session object is created from the corresponding CoTa class. With this class-based approach, developers can perform a where-used analysis on the class. This reflects a broader shift in ABAP development. Developers are no longer responsible for managing connectivity details directly. Instead, they consume centrally defined communication configurations. This separation improves maintainability and allows changes to endpoints or credentials without modifying application code.

Cloud VS On-Premise

In ABAP Cloud, communication target is highly recommended and preferred. Within the Communication Management framework of ABAP Cloud, utilizing a formal communication target is highly recommended and considered best practice. However, while the structured framework is preferred for most scenarios, it is still technically possible to establish outbound connections independently when needed. Developers can bypass the standard communication target lifecycle by dynamically instantiating destinations at runtime using specific provider methods, such as creating a destination directly via a URL or a BTP Cloud Destination.

In on-premise systems, the landscape is even more flexible, as they can also leverage modern cloud connectivity concepts. Starting with the SAP S/4HANA 2025 release, on-premises systems support modern connectivity features, including the use of communication targets alongside application destinations (APPLDEST) for outbound HTTP and RFC communication. Meanwhile, the traditional approach using transaction SM59 remains available, particularly for earlier on-premises releases or classic scenarios.
Existing SM59 configurations can also be migrated to application destination for an existing HTTP or RFC applications. However, the use of communication targets is not enforced system-wide in on-premises environments, unlike in ABAP Cloud.
By early adoption of communication targets, even in on-premises landscapes, developers can align their applications with a model that is clearly designed for the future, secure, transparent, and ready for cloud-native integration.

Further studies

If you want to explore this concept in detail, SAP provides both official documentation and deep-dive blogs:

SAP Help Portal:

SAP Community blogs:

Early idea: VS Code extension merging ADT + abaplint, is this useful to anyone?

2026-07-20T09:51:49.341000+02:00

Hey SAP Community,

I got tired of the usual ABAP loop. Write something, hit Ctrl+F3, wait a
few seconds, see the error, fix it, repeat. So I started building
something to get rid of the waiting part.

The idea is simple: run abaplint locally so you get errors instantly while
typing, and when you're ready, send the code to SAP with one command
instead of switching to GUI.

Right now it has inline diagnostics while typing, basic syntax
highlighting, a code outline panel showing classes and methods, keyword
autocomplete, and an activate command that talks to ADT.

I only tested it against a local mock server, not a real SAP system. Auth
for BTP is not properly handled yet. There's no autocomplete from the
actual system. It probably breaks on edge cases I haven't thought of.

I'm posting because I genuinely don't know if this is useful or if someone
already did this better. If the idea resonates, the code is open and the
architecture is meant to be extended. Take it, fork it, break it, improve
it.

GitHub: https://github.wdf.sap.corp/I749493/abap-adv-linter

Honest feedback appreciated, including "this already exists, look here
instead."

Thanks,

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!

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.

How to run different versions of the ABAP development tools for Visual Studio Code in parallel?

2026-07-24T20:16:18.829000+02:00

Introduction

Having now released a second version of the ABAP development tools for Visual Studio Code the question may arise how to run different versions of this plugin in parallel in order to test the latest version or to check differences in the behavior of the new and an older version.

At least SAP internally this is a question that is of interest for me since I want to run the public available version and the next upcoming version before this is going to be released officially 😉.

For the ABAP Development Tools for Eclipse you have to install a second Eclipse so that you can test a second version there.

How to section

Co-Pilot will provide various options to this question from which I chose the IMHO most easiest one, namely to create different profiles and install a different extension version in each profile.

You can either click on the gear icon and select Profiles.

Or you can open Command Palette (Ctrl+Shift+P) and then enter Profiles and select Profiles: New Profile.

This will open the following dialogue where you can select the default profile from the drop down box.

This let you swith to the newly created profile.

Using the drop down arrow of the "uninstall" button you are offered to install a specific version of the selected extension in the copied profile.

Here you are able to select an older version

As a result you can activate this older version by restarting the extension.

Please note that the Auto Update option has been deactivated conveniently.

SAP Community - ABAP Cloud

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

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

Custom Field and Logic from Scratch

Recommendations for Wrapper Interface Design

Introduction

Why Use Wrappers?

Key Benefits

Example: Wrapper for a BAPI

General Design Best Practices

Best Practices for Referenced Data Types

Ensuring Consistency

Common Pitfalls

Usage of Unreleased Objects

False Positives in Syntax Checks

Icing On the Cake: Ensuring Compatibility

Key Takeaways

Understanding field(suppress) in SAP RAP and How It Differs from @UI.hidden and @Consumption.hidden

How Does It Differ from @ui.hidden and @Consumption.hidden?

Updating Sales Order Header and Sales Order Item using Business Object Framework(Cleancore Approach)

Make ChatGPT or Claude generate correct ABAP syntax - a free, 2-minute setup

How to Scan Custom ABAP for Security Issues in Eclipse (Step-by-Step)

Chat-based RAP Business Object Generation in VS Code

Getting Started

Prerequisites:

Enable the ADT MCP Server

Configuring ADT MCP Server

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

Generating a RAP Business Object

Summary

How to rename an OData V4 service?

Introduction

Result in short

Trying it out

Option 1 - Renaming the service

Option 2 - Creating another service version

Service Definition ZUI_TRAVEL_O4

Service Definition ZUI_TRAVEL_O4_AF

Option 3 - Creating another service

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

What This Post Covers - and Why It Matters?

Building a RAP Application with External SAP HANA Cloud using CDS External Entities – Part 1

Why External Entities?

Business scenario:

Scenario

Prerequisites:

Steps:

Setup SAP HANA Cloud instance

Create Schema and Tables

Configure connectivity to an external SAP HANA database from Steampunk for data access using External Entities

Create CDS External Entities

Key Takeaways.

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

1 Architecture Overview

How Does It Differ from `@ui.hidden` and `@Consumption.hidden`?