SAP Community - SAP BTP, ABAP environment

SAP BTP ABAP Environment Customer & Partner Roundtable – Update for 2026

2026-01-14T13:58:33.145000+01:00

We would like to share an update to the SAP BTP ABAP Environment Customer & Partner Roundtable as we kick off the 2026 session series.

What’s new in 2026?

As of 2026, the roundtable sessions are hosted on Microsoft Teams instead of Zoom.

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

Schedule & Calendar Invitation

📅 The first session of the 2026 series takes place on 3 February 2026.

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

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

Agenda, Slides & Recordings – Single Access Point

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

Looking ahead

We look forward to welcoming you to the first session on 3 February 2026.

Agenda:

Welcome & Introduction new session format
Product updates
E-Mail Templates incl. demo
Business Configuration Sets incl. demo

We’re looking forward to another year of open discussions with our customers and partners around SAP BTP ABAP Environment.

Blue‑Green Deployment in SAP: How BTP, S/4HANA Cloud Public Edition, and Commerce Cloud Deliver(NZD)

2026-01-16T21:09:22.059000+01:00

SAP utilizes blue-green deployment strategies across several of its cloud offerings to achieve zero-downtime updates and minimize release risk. Blue‑green is the default way many SAP cloud services roll out change without interrupting users: run Blue (live) and Green (new) side‑by‑side, verify, then switch traffic. If something misbehaves, point traffic back to Blue—fast

1) SAP BTP (Cloud Foundry runtime): Blue‑Green for MTAs

What happens

Deploy the new MTA as Green next to Blue; the deployer creates “idle” apps and temporary routes (often with an -idle suffix).
After tests, resume to remap productive routes to Green, clean up temporary routes, and remove the old Blue apps.

Command you’ll actually run

Important restrictions

Supported only for Cloud Foundry apps; not for bound services such as workflow content or HTML5 repo content. Plan compatibility (DB schema, UAA) in advance.

Nice to know

SAP’s Community guide walks through the approach and its benefits for mission‑critical app [help.sap.com]

2) SAP S/4HANA Cloud Public Edition: Blue‑Green Uptime

SAP uses a blue‑green uptime window to complete most upgrade/update work while users can still log in. Typical goals: ≤5 minutes downtime, with a roadmap toward zero.

How it behaves

Uptime can begin ~12 hours before the maintenance window; users continue most day‑to‑day work.
Restrictions apply to safeguard consistency (e.g., transport release, certain migration activities).
Landscape coverage: blue‑green currently applies to all systems in 3‑system landscapes and to production in 2‑system landscapes.

SAP S/4HANA Cloud Public Edition - Software Lifecycle Management for Customers

What to tell the business

“You can keep transacting during uptime; a short logoff occurs only for the final switch.” (Share the permitted/blocked activities list from the SAP blog before each release. [community.sap.com]

3) SAP Commerce Cloud: Preview in Green, Then Cut Over

Purpose
Preview the release in the production environment (but on isolated endpoints) before users see it. Green and Blue share the same live database, which enables realistic checks while avoiding duplicate data migrations.

Scope of Green

You can create Green endpoints only for Storefront, JS Storefront, and API—ideal for experience and integration validation.
The Green preview exists for ~2 hours by default; accept or it’s automatically removed.
Single replica by default in Green; scale if needed.
Practical implication: keep heavy write/admin processes (Backoffice, background jobs, Solr changes) on Blue until cutover; SAP advises avoiding blue‑green for complex DB or Backoffice/Solr changes. [help.sap.com]

Side‑by‑Side Benefits (Quick Comparison)

Feature	Why it helps
Zero/near‑zero downtime	Router‑level switch keeps users online; S/4HANA aims for ≤5 min today. [help.sap.com], [community.sap.com]
Instant rollback	Point traffic back to Blue if defects appear. [help.sap.com], [community.sap.com]
Lower release risk	Validate Green in production‑identical conditions (routes in BTP; preview endpoints in Commerce Cloud). [help.sap.com], [help.sap.com]

Design Patterns & Guardrails

1) Backward‑compatible change sets

Keep DB changes additive until the next cycle; avoid breaking contracts during the window. (SAP BTP help explicitly calls out version compatibility across DB/UAA.)

2) Feature flags + canary checks

Gate risky features behind toggles; smoke‑test Green via its temporary routes (BTP) or preview endpoints (Commerce) before promotion.

3) Capacity planning

Expect temporarily doubled instances during BTP testing (both Blue and Green running). Budget memory/instances accordingly.

4) Know when not to use blue‑green (Commerce)

Skip blue‑green for complex schema changes, Backoffice/Solr modifications, or non‑backward‑compatible changes—use a different rollout plan.

5) Align with S/4HANA blue‑green uptime policy

Socialize what’s allowed vs. blocked during uptime; schedule transports/data migration outside uptime.

Thanks for the read.

Cheers, VS

Navigate SAP Fiori launchpad with Ease: Launch Apps via Transaction Codes

2026-01-19T16:39:27.978000+01:00

Overview

We have introduced an innovative feature in the SAP Fiori launchpad offering a swift and efficient way to navigate to applications using transaction codes**.

Users can now perform quick search on transaction code with instant navigation to the corresponding application.

Seamless In-Place and Ex-Place Navigation

In-Place Launch: If you have access to a role-based app, simply enter /n followed by the transaction code to launch it in the same browser tab.

Ex-Place Launch: For opening apps in a new browser tab, use /o followed by the transaction code.

Navigation to Start Page: Easily return to the start page with /n, or open it in a new tab with /o.

Key Benefits

Instant App Access: Accelerate your workflow with immediate app navigation.
Enhanced User Experience: Business users enjoy an empowering and intuitive navigation experience.
Familiarity for SAP GUI Users: Mimics the classic navigation style for those accustomed to transaction codes in SAP GUI.

Initial Release Restrictions

Please note that some restrictions apply to this feature in its initial release. For detailed information, refer to SAP Note 3687260.

Feature Release Horizon

This feature is included in version 2602 across various platforms:

SAP S/4HANA Cloud Public Edition: Official Documentation
SAP BTP ABAP Environment: Official Documentation
SAP Integrated Business Planning: Official Documentation

Experience the power of seamless navigation and user empowerment while keeping your workflows efficient and intuitive with this cutting-edge feature!

** Discovering Transaction Codes for applications

Some of the ways to identify the transaction code corresponding to an application include:

1. Access the Fiori reference library , typically for SAP Fiori and SAP GUI applications the App ID information would correspond to the transaction code.

2. Navigate to an application by other means such as clicking on the tile and invoke the About dialog via User menu to find the transaction code.

Feel free to share any additional shortcuts or cheat sheets you may have in the comments section!

What's New in SAP BTP - Q4 2025 Innobytes

2026-01-21T17:28:03.157000+01:00

Happy new year and welcome back to the SAP BTP Innobytes! 2026 is going to be an exciting year and we have big ideas and a strong strategy for the year ahead! In the meantime, let’s see how we finished out last year with some innovative highlights.

Check out the video below and explore the latest features in Application Development, Integration and more. Enjoy watching!

Data & Analytics

My Metrics

To keep up with the important numbers and data, let me introduce you to your personalized watchlist to keep up with what really matters: My Metrics in SAP Analytics Cloud on SAP BTP.

You can find it via the My Metrics Card on the new Homepage, bringing together performance cards from stories and models into one easy-to-access space with these core areas:

Your Metrics to manage cards
Detailed Visualization with instant charts and active filters
Smart Insights surfacing automated observations

You can create lists from My Metrics page or directly from a story chart: select a data point that you want to track and add it to an existing list or create a new one. You can name the metric and customize suggested comparisons and default visualizations. It’s now possible to rename, delete, copy or move metrics between different lists. You can Share multiple metrics with tailored permissions and distribute it with different SAC users or teams.

See these steps in action (starting at 0:09).

Learn more

MyMetrics Blog Post

App Dev Highlights

Analytical Table with RAP and SAP Fiori

Real-time data analysis tools are essential for decision-making, that’s why SAP BTP ABAP introduced these powerful features for business users.

By adding the annotation @odata.applySupportedForAggregation: #FULL to your data model, you can now unlock advanced aggregation, grouping, and subtotalling directly in Fiori analytical tables. View real-time summarized business data, group by key fields, and dynamically sort and analyse profitability. This way you can simplify analytics for end users, enabling faster, data-driven decisions.

Watch the demo starting at 1:37 to get more insights.

Learn more

Developing Read-Only RAP Analytical Tables

SAP Build Extensibility Wizard now available in SAP SuccessFactors

You might already know the SAP Build Extensibility Wizard, supporting developers in process creation and UI extensions directly from Cloud ERP apps. This feature is now also available in SAP SuccessFactors.

In this example we want to simplify the process of requesting personal data from new hires in the onboarding process:

Launch the process variant manager from the SAP SuccessFactors application and select the specific HR process you want to extend.
To let the new hire know, that their data has been accepted, we want to add a step of approval. The wizard will walk you through the familiar steps to set up our extension.
You can jump directly into SAP Build to customize this process.
View the process from the SAP SuccessFactors application, reviewing the new hires and the personal data they have collected.
HR will get a notification in the Task Center Inbox and can select approve, notifying the new hire.

The Extensibility wizard can now practice its magic in SAP SuccessFactors, delivering a better experience for our employees with SAP Build.

To watch this innovation example, start the video at 2:41.

Learn more

Joule Studio Agent Builder

When it comes to making decisions for your business, transparency and control are essential. AI agents can help speed up the process but building AI agents that are both powerful and enterprise-ready is a challenge. How do you combine development speed with the governance and trust your business demands?

Describe your business goals to your AI conversational Partner and let Joule build an agent that fits your needs. It automatically discovers tools and connects to external systems through the framework support for MCP. Giving the agent deep business context enables smarter decision-making. The timeline feature gives you full transparency, showing every step of the agent's logic, essential for debugging and governance.

Start the demo at 4:21 to learn all about the Agent Builder in Joule Studio.

Learn more

Integration

Local OData API access & SAP HANA support in Edge Integration Cell

When it comes to manage persistence and monitoring in hybrid landscapes, integration is an essential step to make it more flexible.

Edge Integration Cell now supports SAP HANA as both a database and datastore, offering an alternative to PostgreSQL and Redis. If your landscape already runs on HANA, avoid maintaining separate persistence systems by unifying your data layer. One SAP HANA instance can be used for multiple Edge to keep everything consistent and centralized. To ensure the reliability of your integrations even if the cloud connection isn’t available, try the Local OData API access for your Edge runtime. You can retrieve message processing logs, data stores, and other runtime info through local GET APIs.

To use the Local API Access,

Activate the API Plan support to the cluster using the ELMO UI
Modify the configuration by adding a valid API Virtual Host and an API Virtual Host Key Alias

These settings are also available upon onboarding a new Edge node, allowing a stronger performance and visibility into your integrations.

Watch this part (starting at 5:36) to get more insights.

Learn more

Security

SAP Key Management Service

SAP Key Management Service (KMS) enables customers to manage encryption keys to business compliance and regulations. Group systems and keys in key configurations according to your requirements.

The Primary Key is the active one for encryption. The SAP KMS supports Hold Your Own Key (HYOK) and Bring Your Own Key (BYOK) by importing Your Key. Revoke a key at any time by disabling or deleting it, leading to a shutdown of the connected systems, locking the data. When assigned to a KMS tenant, connect the system seamless via the UI. The four-eye-principle secures tasks like connecting a system or a key action.

To see this demo in action, watch the video (starting at 7:04).

Share your thoughts

These videos are for YOU, and we would love to hear your impressions. How do you like the video? How can we improve the upcoming videos? Please share your feedback by liking this post or leaving a comment below.

Thank you for your support and happy viewing, sharing, and enjoying!

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

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

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

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

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

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

The Three Paths for ABAP AI Evolution:

1. The Standard Path: Joule for Developers in ADT

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

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

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

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

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

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

Here you can learn more:

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

Mass Update Through Custom Action In RAP

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

Introduction:

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

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

Solution Overview:

The blog covers:

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

Database Table:

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

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

}

Root Entity:

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

Projection View:

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

Metadata Extension:

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

Root Behavior Definition:

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

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

with draft;

extensible;
define behavior for ZR_UUID_TABLE alias R_UUID_TABLE
persistent table ZUUID_TABLE

extensible
draft table ZUUID_TABLE_D
etag master Lastchangedat

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

  field ( numbering : managed )
   TravelID;


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

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

}

Parameter For Action:

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

  status : /dmo/travel_status;

}

Implementation:

  METHOD UpdateStatus.


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

  ENDMETHOD.

Explanation:

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

Projection BDEF:

expose our custom action in projection behavior definition.

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

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

Preview:

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

Conclusion:

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

ABAP Connectivity ABAP Extensibility SAP BTP ABAP environment

How to enable BC Set support for BC app

2026-01-23T11:06:48.347000+01:00

Introduction

In order to use the "import from transport" function in the BC Set editor, the data must be recorded in the context of a transport object (TOBJ) and the business configuration maintenance object (SMBC) must maintain the corresponding transport object attribute.

This blog explains the necessary steps to enable existing SMBC objects for the "import from transport" functionality. Newly generated SMBC objects are automatically enabled.

This blog is relevant for

Case 1: Transport object is already used in the BC app

As of release 2302, when you use the ADT wizard to generate a business configuration maintenance object (SMBC), a transport object (TOBJ) is generated by default and used in the behavior implementation. In this case you only need to maintain the new "Transport Object" attribute of the SMBC object.

You can do this manually in the ADT editor of the SMBC object or programmatically. First you need to find out the name of the transport object. In most cases the name is equal to the name of the SMBC object. You can open the behavior implementation class and check the first couple of rows to verify the name of the transport object ( depending on the release the object was created: CO_TRANSPORT_OBJECT or TDAT_NAME )

CLASS LHC_COMPANYCODEALL DEFINITION FINAL INHERITING FROM CL_ABAP_BEHAVIOR_HANDLER.
  PUBLIC SECTION.
    CONSTANTS:
      CO_ENTITY TYPE abp_entity_name VALUE `ZI_COMPANYCODE_S`,
      CO_TRANSPORT_OBJECT TYPE mbc_cp_api=>indiv_transaction_obj_name VALUE `ZCOMPANYCODE`,
      CO_AUTHORIZATION_ENTITY TYPE abp_entity_name VALUE `ZI_COMPANYCODE`.

CLASS LHC_RAP_TDAT_CTS DEFINITION FINAL.
  PUBLIC SECTION.
    CLASS-METHODS:
      GET
        RETURNING
          VALUE(RESULT) TYPE REF TO IF_MBC_CP_RAP_TDAT_CTS.

ENDCLASS.

CLASS LHC_RAP_TDAT_CTS IMPLEMENTATION.
  METHOD GET.
    result = mbc_cp_api=>rap_tdat_cts( tdat_name = 'ZTAB6'

You can maintain the attribute "Transport Object" in the "Service Configuration" section of the SMBC object in the ADT editor. Save and activate.

You can update this attribute also programmatically:

CLASS zset_tobj DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun .
  PROTECTED SECTION.
  PRIVATE SECTION.
ENDCLASS.

CLASS zset_tobj IMPLEMENTATION.

  METHOD if_oo_adt_classrun~main.
    DATA smbc_id TYPE TABLE OF if_mbc_cp_api_business_config=>ty_technical_id WITH EMPTY KEY.
    SELECT ABAPObject FROM I_CustABAPObjDirectoryEntry
      WHERE ABAPObjectType = 'SMBC' AND ABAPObject LIKE '<NAMESPACE>%'
      INTO TABLE @smbc_id .
    LOOP AT smbc_id ASSIGNING FIELD-SYMBOL(<smbc_id>).
      out->write( |SMBC object: { <smbc_id> }| ).
      TRY.
          DATA(tobj) = mbc_cp_api=>business_configuration_api( <smbc_id> )->read( )-transport_object.
          IF tobj IS NOT INITIAL.
            out->write( |TOBJ already set: { tobj }| ).
          ELSE.
            mbc_cp_api=>business_configuration_api( <smbc_id> )->update_transport_object(
              transport_object = <smbc_id> "if the table list of the transport object does not match the table list of the behavior definition an exception is raised
              transport        = '<Workbench Request>' ). "transport=space for local objects
            out->write( |TOBJ set: { mbc_cp_api=>business_configuration_api( <smbc_id> )->read( )-transport_object }| ).
          ENDIF.
        CATCH cx_root INTO DATA(exc).
          out->write( |Error: { exc->get_text( ) }| ).
      ENDTRY.
    ENDLOOP.
  ENDMETHOD.

ENDCLASS.

Use Case 2: The BC app does not use a transport object

Delete the existing BC app and create it again using the ADT wizard.

If you cannot do that, you can also use the ADT wizard to generate a new BC app for the table(s) with different object names. Move the generated transport object to the package of the old BC app and maintain the transport object attribute of the old SMBC object.
If necessary, adjust the generated TOBJ by changing the table piece list.
Adjust the old behavior implementation class by by replacing the existing method implementation with the equivalent method implementation of the new behavior implementation class. Adjust the constants to match the old object names.
You can now delete the newly generated objects.

Transport object names

The last character of the technical name of a transport object is its type. In the SMBC and TOBJ ADT editor, the technical name of the transport object is used. Use the input help to select a transport object.
In the API calls in the behavior implementation class, the type of a transport object is either a separate parameter or T (Individual Transaction Object) by default. That is, remove the last character for the name of the transport object.
Example:
In ADT, the name of the transport object is "ZTOBJ1 T" or "ZCOMPANYCODET". In the behavior implementation class, use "ZTOBJ1" or "ZCOMPANYCODE".

My Home in SAP BTP ABAP Environment

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

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

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

New Look and Feel

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

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

My Home in SAP BTP ABAP environment

My Home Sections

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

News

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

News section on My Home entry page

Pages

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

Pages section on My Home entry page

Apps

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

Apps section on My Home entry page

Insights Tiles and Insights Cards

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

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

Insights section on My Home entry page

Make it Mine – Personalize My Home to Your Needs

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

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

My Home Settings

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

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

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

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

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

Switching to Spaces and Pages

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

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

This means in detail:

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

How to Prepare for the Transition

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

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

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

Here are our best practices for end users:

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

For Administrators: Summary of the Upcoming Changes

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

With SAP BTP ABAP environment 2602:

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

With SAP BTP ABAP environment 2605:

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

With SAP BTP ABAP environment 2608:

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

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

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

Dynamic RAP Actions Explained: Abstract Entities Powering Flexible Action Buttons

2026-02-04T08:58:36.978000+01:00

Introduction--

In the RESTful ABAP Programming Model (RAP), actions play a crucial role in triggering custom business logic on business objects — for example, approving, rejecting, or performing special updates on records.

Sometimes, these actions require user inputs, such as selecting a reason code, approval type, or custom parameter value before execution. To achieve this, RAP provides parameterized actions, and to enhance usability, we can use an abstract entity to define the parameter structure along with a dropdown (value help).

In this blog, we’ll explore how to build a parameterized RAP action that displays a dropdown list for user selection, powered by an abstract entity. This approach keeps the core logic clean, reusable, and consistent with RAP’s “clean core” principles.

Objective--

By the end of this blog, you’ll learn how to: -

Define an abstract entity to represent the action parameters

Provide a dropdown for the parameter field

Link the abstract entity to the RAP action definition

Implement the behavior logic to handle user input

Execute and test the action from the Fiori Elements UI

Business Scenario Overview--

You are designing a Purchase Order (PO) Management RAP application, consisting of a Header and Item structure.

The goal: -

To release purchase orders (POs) from Fiori using a parameterized action.

The action uses an abstract entity to capture runtime parameters (like release flag).

Database Tables--

Header Table: ZBRT_T_PO_HRD

This table stores high-level details of a purchase order.

@EndUserText.label : 'Purchase order header table' 
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE 
@AbapCatalog.tableCategory : #TRANSPARENT 
@AbapCatalog.deliveryClass : #A 
@AbapCatalog.dataMaintenance : #RESTRICTED 
define table zbrt_t_po_hrd { 

key mandt    : abap.clnt not null;
key ebeln    : ebeln not null;
bukrs        : abap.char(4);
supplier     : abap.char(10);
bsart        : abap.char(4);
lifnr        : abap.char(10);
land1        : abap.char(2);
country_desc : abap.char(40);
po_release   : abap.char(1); 
migo_status  : abap.char(40); 
email        : abap.char(60); 
lastdatetime : timestampl; 
}

Key points:--

EBELN is the primary key.

lastdatetime acts as the ETag for draft handling and concurrency control.

po_release indicates whether the PO has been released or not.

Item Table: ZBRT_T_PO_ITEM--

This stores item-level details linked to the header via a foreign key.

@EndUserText.label : 'Purchase order item table' 
@AbapCatalog.enhancement.category : #NOT_EXTENSIBLE 
@AbapCatalog.tableCategory : #TRANSPARENT 
@AbapCatalog.deliveryClass : #A 
@AbapCatalog.dataMaintenance : #RESTRICTED 
define table zbrt_t_po_item { 

key mandt       : abap.clnt not null; 
@AbapCatalog.foreignKey.screenCheck : false 
key ebeln       : ebeln not null 
with foreign key [1..*,1] zbrt_t_po_hrd 
where mandt = zbrt_t_po_item.mandt 
and ebeln = zbrt_t_po_item.ebeln; 
key ebelp       : abap.numc(5) not null; 
matnr           : abap.char(40); 
werks           : abap.char(4); 
lgort           : abap.char(4); 
@Semantics.quantity.unitOfMeasure : 'zbrt_t_po_item.meins' 
menge           : abap.quan(12,2); 
meins           : abap.unit(3); 
@Semantics.amount.currencyCode : 'zbrt_t_po_item.waers'
netpr           : abap.curr(15,2);
waers           : abap.cuky;
lastdatechanged : timestampl;
}

Key points:-

The association [1..*,1] means: Many items can belong to one header.

Semantic annotations help map units and currencies for UI display.

lastdatechanged helps track data changes per item.

Abstract Entity: ZBRT_POPUP-

Abstract entities are not physical tables; they are used for data transfer or parameter passing.

In this case, it’s used as a parameter popup entity during your action execution (e.g., PO release).

@EndUserText.label: 'PO RELEASE' 
@Metadata.allowExtensions: true 
define abstract entity zbrt_popup 
{ 
@UI.defaultValue: 'X' @EndUserText.label: 'po_release' 
po_release : abap.char( 1 );
}

Purpose:-

Used as a popup parameter for a RAP parameterized action.

When the user triggers the Release PO action in the Fiori UI, this abstract entity is displayed to capture additional inputs (like “Release Flag”).

It is decoupled from the database, acting only as a temporary input structure.

Interface View for Header: ZC_BRT_PO_HEAD--

This is the Root Entity of your RAP Business Object.

@AbapCatalog.viewEnhancementCategory: [#NONE]
@AccessControl.authorizationCheck: #NOT_REQUIRED 
@EndUserText.label: 'Projection view for header' 
@Metadata.ignorePropagatedAnnotations: true 
@ObjectModel.usageType:{
serviceQuality: #X, 
sizeCategory: #S,
dataClass: #MIXED 
} 
@Metadata.allowExtensions: true 
define root view entity zc_brt_po_head 
as select from zbrt_t_po_hrd 
composition [1..*] of zc_brt_po_item as _item 
{ 
key ebeln,
bukrs,
supplier, 
bsart,
lifnr,
land1,
country_desc,
po_release,
migo_status,
email, 
@Semantics.systemDateTime.localInstanceLastChangedAt: true 
lastdatetime,
cast('3' as abap.char(1)) as porelease,
cast('1' as abap.char(1)) as noporelease,  
_item
}

Key concepts:-

root view entity: Marks it as the root node of the RAP Business Object.

composition [1..*] of _item: Establishes a header–item relationship (1 header → many items).

@Semantics.systemDateTime.localInstanceLastChangedAt: Enables ETag-based draft and lock management.

cast('3' as abap.char(1)) as porelease: Defines a calculated field named porelease. This is a constant value ('3') cast to a character of length 1. It is typically used to represent a fixed feature control value (e.g., enabling a 'Release PO' button on the UI).

cast('1' as abap.char(1)) as noporelease: Defines another calculated field named noporelease with a constant value of '1'. Similar to above, this could be used for feature control (e.g., disabling a 'No Release' button).

Interface View for Item: ZC_BRT_PO_ITEM--

This is the child entity linked to the header.

@AbapCatalog.viewEnhancementCategory: [#NONE] 
@AccessControl.authorizationCheck: #NOT_REQUIRED 
@EndUserText.label: 'Projection view for item' 
@Metadata.ignorePropagatedAnnotations: true 
@ObjectModel.usageType:{ 
serviceQuality: #X, 
sizeCategory: #S,
dataClass: #MIXED 
} 
@Metadata.allowExtensions: true 
define view entity zc_brt_po_item
as select from zbrt_t_po_item
association to parent zc_brt_po_head as _head on $projection.ebeln = _head.ebeln
{
key ebeln,
key ebelp,
matnr,
werks,
lgort,
@Semantics.quantity.unitOfMeasure: 'Meins'
menge,
meins,
@Semantics.amount.currencyCode: 'Waers'
netpr,
waers, 
@Semantics.systemDateTime.localInstanceLastChangedAt: true
lastdatechanged,
_head
}

Explanation:-

This view represents the item-level node in your RAP BO.

_head is a public association to navigate back to the header.

The same ETag annotation (@Semantics.systemDateTime.localInstanceLastChangedAt) ensures concurrency management for items too.

Then design the behavior definition-

managed implementation in class zbp_c_brt_po_head unique; 
strict ( 2 ); 
with draft; 

define behavior for zc_brt_po_head //alias <alias_name> 
persistent table zbrt_t_po_hrd 
lock master 
total etag Lastdatetime 
draft table zbrt_t_h_dft 
authorization master ( instance ) 
etag master lastdatetime 
{
create ( precheck ) { default function GetDefaultsForCreate; } 
update ( precheck, features : instance ); 
delete ( precheck, features : instance ); 
field ( readonly ) bsart, Country_Desc; 
field ( mandatory ) bukrs; 
field ( readonly : create ) po_release;
 
association _item { create; with draft; }
 
mapping for zbrt_t_po_hrd 
{ 
bsart        = bsart; 
bukrs        = bukrs; 
country_desc = country_desc; 
ebeln        = ebeln; 
land1        = land1; 
lastdatetime = lastdatetime; 
lifnr        = lifnr; 
migo_status  = migo_status; 
porelease    = po_release; 
email        = email; 
} 
validation check_email on save { field Email; }
determination migo_status_update on modify { field porelease; } 
action ( features : instance ) POREL parameter zbrt_popup result [1] $self; 
action ( features : instance ) PONOREL result [1] $self;
static action Static_ALL result [1] $self;

draft action Activate optimized;
draft action Edit;
draft action Resume;
draft action Discard;
draft determine action Prepare; 
} 
define behavior for zc_brt_po_item //alias <alias_name>
persistent table zbrt_t_po_item
lock dependent by _head
draft table zbrt_t_i_ft
authorization dependent by _head
etag master Lastdatechanged
{
update;
delete;
field ( readonly ) ebeln, ebelp;
association _head; 
}

determination migo_status_update on modify { field porelease; }

Automatically updates MIGO status whenever the PO Release field changes.

action ( features : instance ) POREL parameter zbrt_popup result [1] $self; 
action ( features : instance ) PONOREL result [1] $self; 
static action Static_ALL result [1] $self;

POREL → Triggered to release a purchase order (with parameter popup).

PONOREL → Reverses release.

Static_ALL → Static action (not tied to any instance).

Metadata extension--

@Metadata.layer: #CORE 
@UI:{ 
    headerInfo:{ 
    title:{ value: 'Ebeln'}, 
    description:{value: 'Migo_Status' }, 
    typeName: 'Purchase Order Data', 
    typeNamePlural: 'Purchase Order Data' } 
} 
annotate view zc_brt_po_head with 
{ 
@UI.facet: 
[ 
{ position: 10, label: 'PO Header', type: #IDENTIFICATION_REFERENCE }, 
{ position: 20 , label: 'PO Item' , type: #LINEITEM_REFERENCE , targetElement: '_item' } 
] 
@UI.identification: [ { 
position: 10, label: 'PO Number' 
} , 
{ type: #FOR_ACTION_GROUP, label: 'PO Release Options', actionGroupId: '_ClickRelease' }, 
{ type: #FOR_ACTION, label: 'PO Release', dataAction: 'POREL', actionGroupId: '_ClickRelease' }, 
{ type: #FOR_ACTION, label: 'PO NotRelease', dataAction: 'PONOREL', actionGroupId: '_ClickRelease' } 
] 
@UI.lineItem: [ { 
position: 10, label: 'PO Number' 
} , 
{ type: #FOR_ACTION_GROUP, label: 'PO Release Options', actionGroupId: '_ClickRelease' }, 
{ type: #FOR_ACTION, label: 'PO Release', dataAction: 'POREL', actionGroupId: '_ClickRelease' }, 
{ type: #FOR_ACTION, label: 'PO NotRelease', dataAction: 'PONOREL', actionGroupId: '_ClickRelease' } , 

//This button we will use as static button 
{ type: #FOR_ACTION, label: 'Release All POs', dataAction: 'Static_ALL',actionGroupId: '_ClickRelease' } ] 
@UI.selectionField: [ { 
position: 10 
} ] 
@EndUserText.label: 'PO Number' 
ebeln; 
@UI.identification: [ { 
position: 20 , 
label: 'Company Code' 
} ] 
@UI.lineItem: [ { 
position: 20 , 
label: 'Company Code' 
} ] 
@UI.selectionField: [ { 
position: 20 
} ] 
@EndUserText.label: 'Company Code' 
bukrs; 
@EndUserText.label: 'Document Type' 
@UI.identification: [ {
position: 40 , 
label: 'Document Type' 
} ] 
@UI.lineItem: [ { 
position: 40 , 
label: 'Document Type' 
} ] 
@UI.selectionField: [ { 
position: 40 
} ]
bsart;
@EndUserText.label: 'Vendor' 
@UI.identification: [ { 
position: 50 , 
label: 'Vendor' 
} ] 
@UI.lineItem: [ { 
position: 50 , 
label: 'Vendor' 
} ] 
@UI.selectionField: [ { 
position: 50 
} ] 
lifnr; 
@EndUserText.label: 'Country' 
@UI.identification: [ { 
position: 60 , 
label: 'Country' 
} ] 
@UI.lineItem: [ { 
position: 60 , 
label: 'Country' 
} ] 
@UI.selectionField: [ { 
position: 60 
} ] 
land1; 
@EndUserText.label: 'Country Name' 
@UI.identification: [ { 
position: 70 , 
label: 'Country Name' 
} ] 
@UI.lineItem: [ { 
position: 70 , 
label: 'Country Name' 
} ] 
@UI.selectionField: [ { 
position: 70 
} ] 
country_desc; 
@EndUserText.label: 'PO Release' 
@UI.identification: [ { 
position: 80 , 
label: 'PO Release' 
} ] 
@UI.lineItem: [ { 
position: 80 , 
label: 'PO Release' 
} ] 
@UI.selectionField: [ { 
position: 80 
} ] 
po_release; 
@EndUserText.label: 'MIGO Status' 
@UI.identification: [ { 
position: 90 , 
label: 'MIGO Status' 
} ] 
@UI.lineItem: [ { 
position: 90 , 
label: 'MIGO Status' 
} ] 
@UI.selectionField: [ { 
position: 90 
} ] 
migo_status;
@EndUserText.label: 'Email ID' 
@UI.identification: [ { 
position: 100 , 
label: 'Email ID' 
} ] 
@UI.lineItem: [ { 
position: 100 , 
label: 'Email ID' 
} ] 
@UI.selectionField: [ { 
position: 100 
} ]
email; 
@UI.identification: [ { 
position: 110, label: 'Change Date Time' 
} ] 
@UI.lineItem: [ { 
position: 110, label: 'Change Date Time' 
} ] 
@UI.selectionField: [ { 
position: 110 
} ] 
@EndUserText.label: 'Change Date Time'
lastdatetime;
}

This is the Metadata Extension (UI annotations) for RAP Purchase Order application-- it defines how the fields and actions from our behavior definition (zc_brt_po_head) appear in the Fiori Elements app (List Report/Object Page).

.identification: [ { 

position: 10, label: 'PO Number' 
} , 
{ type: #FOR_ACTION_GROUP, label: 'PO Release Options', actionGroupId: '_ClickRelease' }, 
{ type: #FOR_ACTION, label: 'PO Release', dataAction: 'POREL', actionGroupId: '_ClickRelease' }, 
{ type: #FOR_ACTION, label: 'PO NotRelease', dataAction: 'PONOREL', actionGroupId: '_ClickRelease' } 
]

These create grouped action buttons and drop-down on both the List Report and Object Page:-

PO Release Options → Acts as a dropdown group.

Inside it:

PO Release → Triggers the POREL action (for releasing PO).

PO NotRelease → Triggers PONOREL action (for cancelling release).
Release All POs → Added later as a static action.

{ type: #FOR_ACTION, label: 'Release All POs', dataAction: 'Static_ALL', actionGroupId: '_ClickRelease' }

This button executes the Static Action (Static_ALL) — useful for mass operations like “Release All Purchase Orders” without selecting individual ones.

Then implement the logic in the behavior implementation class for validation, actions and determination--

CLASS lhc_zc_brt_po_head DEFINITION INHERITING FROM cl_abap_behavior_handler. 

PRIVATE SECTION. 

METHODS get_instance_features FOR INSTANCE FEATURES 
IMPORTING keys REQUEST requested_features FOR zc_brt_po_head RESULT result. 

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

METHODS precheck_create FOR PRECHECK 
IMPORTING entities FOR CREATE zc_brt_po_head. 

METHODS precheck_update FOR PRECHECK 
IMPORTING entities FOR UPDATE zc_brt_po_head. 

METHODS precheck_delete FOR PRECHECK 
IMPORTING keys FOR DELETE zc_brt_po_head. 

METHODS GetDefaultsForCreate FOR READ 
IMPORTING keys FOR FUNCTION zc_brt_po_head~GetDefaultsForCreate RESULT result. 

METHODS ponorel FOR MODIFY 
IMPORTING keys FOR ACTION zc_brt_po_head~ponorel RESULT result. 

METHODS porel FOR MODIFY 
IMPORTING keys FOR ACTION zc_brt_po_head~porel RESULT result.
 
METHODS Static_ALL FOR MODIFY 
IMPORTING keys FOR ACTION zc_brt_po_head~Static_ALL RESULT result. 

METHODS migo_status_update FOR DETERMINE ON MODIFY 
IMPORTING keys FOR zc_brt_po_head~migo_status_update. 

METHODS check_email FOR VALIDATE ON SAVE 
IMPORTING keys FOR zc_brt_po_head~check_email. 

ENDCLASS. 

CLASS lhc_zc_brt_po_head IMPLEMENTATION. 
 
METHOD get_instance_features. 
ENDMETHOD. 

METHOD get_instance_authorizations. 
ENDMETHOD. 

METHOD precheck_create. 

 LOOP AT entities INTO DATA(ls_enity). 

  IF ls_enity-bukrs EQ '6000'. 
    APPEND VALUE #( ebeln = ls_enity-ebeln ) TO failed-zc_brt_po_head. 
    APPEND VALUE #( 
                  ebeln = ls_enity-ebeln 
                  %msg = new_message_with_text(
                  severity = if_abap_behv_message=>severity-error
                  text = 'Please enter correct Company Code' && ls_enity- bukrs ) )
   TO reported-zc_brt_po_head. 

ENDIF. 
ENDLOOP. 

ENDMETHOD. 

METHOD precheck_update. 

LOOP AT entities INTO DATA(ls_enity). 

  IF ls_enity-bukrs EQ '6000'. 
   APPEND VALUE #( ebeln = ls_enity-ebeln ) TO failed-zc_brt_po_head. 
   APPEND VALUE #( 
                ebeln = ls_enity-ebeln 
                %msg = new_message_with_text( 
                severity = if_abap_behv_message=>severity-error 
                text = 'Please enter correct Company Code' && ls_enity-Bukrs )
) TO reported-zc_brt_po_head. 

ENDIF. 
ENDLOOP. 

ENDMETHOD. 

METHOD precheck_delete. 

   READ ENTITY IN LOCAL MODE zc_brt_po_head 
   ALL FIELDS WITH VALUE #( FOR ls_key IN keys 
                          ( ebeln = ls_key-ebeln ) ) 
RESULT DATA(lt_prechk_delete). 

LOOP AT lt_prechk_delete INTO DATA(ls_enity). 

  IF ls_enity-porelease EQ abap_true. 
    APPEND VALUE #( ebeln = ls_enity-ebeln ) TO failed-zc_brt_po_head. 
    APPEND VALUE #( 
               ebeln = ls_enity-ebeln 
               %msg = new_message_with_text( 
               severity = if_abap_behv_message=>severity-error 
               text = 'You can not delete this line Item as PO release is X'
) 
) TO reported-zc_brt_po_head. 

ENDIF. 
ENDLOOP. 

ENDMETHOD. 

METHOD GetDefaultsForCreate. 
  APPEND VALUE #( %cid = keys[ 1 ]-%cid %param-bsart = 'ZNB' ) TO result. 
ENDMETHOD. 

METHOD ponorel. 
 
   READ ENTITY IN LOCAL MODE zc_brt_po_head 
   ALL FIELDS WITH VALUE #( FOR ls_key IN keys 
                          ( ebeln = ls_key-ebeln ) ) 
   RESULT DATA(lt_po_action). 

LOOP AT lt_po_action ASSIGNING FIELD-SYMBOL(<fs_po_action>). 

   MODIFY ENTITY IN LOCAL MODE zc_brt_po_head 
   UPDATE FIELDS ( porelease ) 
   WITH VALUE #( ( ebeln = <fs_po_action>-ebeln 
                   porelease = abap_false ) )  
   REPORTED reported 
   FAILED failed. 

   READ ENTITY IN LOCAL MODE zc_brt_po_head 
   ALL FIELDS WITH VALUE #( ( ebeln = <fs_po_action>-ebeln ) ) 
   RESULT DATA(lt_result). 
   result = VALUE #( FOR ls_result IN lt_result 
                   ( ebeln           = ls_result-ebeln 
                    %param-ebeln     = ls_result-ebeln 
                    %param-porelease = ls_result-porelease ) ). 
ENDLOOP. 

ENDMETHOD. 

METHOD porel. 

LOOP AT keys ASSIGNING FIELD-SYMBOL(<fs_po_action>). 

   DATA(lv_popup_value) = <fs_po_action>-%param-po_release. 
   MODIFY ENTITY IN LOCAL MODE zc_brt_po_head 
   UPDATE FIELDS ( po_release ) 
   WITH VALUE #( ( Ebeln = <fs_po_action>-Ebeln 
                   po_release = lv_popup_value ) ) 
   REPORTED reported FAILED failed.

   READ ENTITY IN LOCAL MODE zc_brt_po_head 
   ALL FIELDS WITH VALUE #( ( Ebeln = <fs_po_action>-Ebeln ) ) 
   RESULT DATA(lt_result). 
   
   result = VALUE #( FOR ls_result IN lt_result 
                   ( ebeln = ls_result-Ebeln 
                     %param-ebeln = ls_result-ebeln 
                     %param-po_release = ls_result-po_release ) ). 

ENDLOOP. 

ENDMETHOD. 

METHOD Static_ALL. 

   SELECT FROM zbrt_t_po_hrd 
          FIELDS ebeln , po_release 
          WHERE po_release = _false 
   INTO TABLE(lt_static_act). 

LOOP AT lt_static_act INTO DATA(ls_static_action). 

   MODIFY ENTITY IN LOCAL MODE zc_brt_po_head 
   UPDATE FIELDS ( porelease ) 
   WITH VALUE #( ( ebeln = ls_static_action-ebeln 
                   porelease = abap_true ) ) .
 
   READ ENTITY IN LOCAL MODE zc_brt_po_head 
   ALL FIELDS WITH VALUE #( ( ebeln = ls_static_action-ebeln ) ) 
   RESULT DATA(lt_result). 
   result = VALUE #( FOR ls_result IN lt_result 
                   ( %param-ebeln = ls_result-ebeln 
                     %param-porelease = ls_result-porelease ) ).
ENDLOOP. 

   INSERT VALUE #( 
                 %msg = new_message_with_text( 
                  severity = if_abap_behv_message=>severity-success 
                  text = |{ lines( lt_static_act ) } Records has been  upadted | ) ) 
   INTO TABLE reported-zc_brt_po_head. 

ENDMETHOD. 

METHOD migo_status_update. 

   READ ENTITY IN LOCAL MODE zc_brt_po_head 
   ALL FIELDS WITH VALUE #( FOR ls_key IN keys 
                          ( ebeln = ls_key-ebeln ) ) 
   RESULT DATA(lt_migo_status). 

LOOP AT lt_migo_status ASSIGNING FIELD-SYMBOL(<fs_migo>). 

  IF <fs_migo>-porelease EQ abap_true. 
     MODIFY ENTITY IN LOCAL MODE zc_brt_po_head 
     UPDATE FIELDS ( migo_status )
     WITH VALUE #( ( ebeln = <fs_migo>-ebeln 
                     migo_status = 'GR has done' ) ). 

  ELSEIF <fs_migo>-porelease EQ abap_false. 
     MODIFY ENTITY IN LOCAL MODE zc_brt_po_head 
     UPDATE FIELDS ( migo_status ) 
     WITH VALUE #( ( ebeln = <fs_migo>-ebeln 
                     migo_status = 'Open' ) ). 
ENDIF. 
ENDLOOP. 
ENDMETHOD. 

METHOD check_email. 

DATA: lr_reg TYPE REF TO cl_abap_regex. 
DATA: lr_matcher TYPE REF TO cl_abap_matcher, 
      lv_email TYPE string. 

   CREATE OBJECT lr_reg
      EXPORTING 
        pattern = '\w+(\.\w+)*@(\w+\.)+(\w{2,4})' 
        ignore_case = abap_true.

   READ ENTITY IN LOCAL MODE zc_brt_po_head 
   ALL FIELDS WITH VALUE #( FOR ls_key IN keys 
                          ( Ebeln = ls_key-Ebeln ) ) 
   RESULT DATA(lt_validation). 

LOOP AT lt_validation INTO DATA(ls_validation). 
   DATA(lv_po_count) = strlen( ls_validation-Email ). 
   IF lv_po_count LT 10. 
     APPEND VALUE #( Ebeln = ls_validation-Ebeln ) TO failed-zc_brt_po_head. 
     APPEND VALUE #( Ebeln = ls_validation-Ebeln 
                     %msg = new_message_with_text( 
                     severity = if_abap_behv_message=>severity-error 
                     text = 'Pls enter correct length for Email' && ls_validation-Email ) ) 
     TO reported-zc_brt_po_head. 

ENDIF. 

   lr_matcher = lr_reg->create_matcher( text = ls_validation-Email ).
   IF lr_matcher->match( ) IS INITIAL.
     APPEND VALUE #( Ebeln = ls_validation-Ebeln ) TO failed-zc_brt_po_head. 
     APPEND VALUE #( Ebeln = ls_validation-Ebeln 
                     %msg = new_message_with_text( 
                     severity = if_abap_behv_message=>severity-error 
                     text = 'Pls enter correct format for Email Id' && ls_validation-Email ) ) 
     TO reported-zc_brt_po_head.
 
ENDIF. 
ENDLOOP. 
ENDMETHOD.

ENDCLASS.

METHOD ponorel. 
 
  READ ENTITY IN LOCAL MODE zc_brt_po_head 
  ALL FIELDS WITH VALUE #( FOR ls_key IN keys 
  ( ebeln = ls_key-ebeln ) ) RESULT DATA(lt_po_action). 

LOOP AT lt_po_action ASSIGNING FIELD-SYMBOL(<fs_po_action>). 

   MODIFY ENTITY IN LOCAL MODE zc_brt_po_head 
   UPDATE FIELDS ( porelease ) 
   WITH VALUE #( ( ebeln = <fs_po_action>-ebeln 
   porelease = abap_false 
   ) 
)  REPORTED reported 
   FAILED failed. 
   READ ENTITY IN LOCAL MODE zc_brt_po_head 
   ALL FIELDS WITH VALUE #( ( ebeln = <fs_po_action>-ebeln ) ) 
   RESULT DATA(lt_result). 
   result = VALUE #( FOR ls_result IN lt_result 
    ( 
    ebeln            = ls_result-ebeln 
    %param-ebeln     = ls_result-ebeln 
    %param-porelease = ls_result-porelease 
  )
).
ENDLOOP. 

ENDMETHOD.

Purpose of the Method--

ponorel is triggered when a user clicks the “PO Not Release” button in Fiori.
Its job is to:

Read the selected PO(s) from the frontend.
Update their porelease field to false.
Return the updated PO information back to the frontend so the UI reflects the change.

Step	Purpose
Read entity from local mode	Fetch selected POs from draft/local buffer
Loop through POs	Process each PO individually
Modify entity	Set porelease = false (Not Released)
Read back updated record	Get latest values for UI
Assign to result	Send updated record(s) back to Fiori

METHOD porel. 

LOOP AT keys ASSIGNING FIELD-SYMBOL(<fs_po_action>). 

   DATA(lv_popup_value) = <fs_po_action>-%param-po_release. 
   MODIFY ENTITY IN LOCAL MODE zc_brt_po_head UPDATE FIELDS ( po_release ) 
   WITH VALUE #( 
       ( Ebeln = <fs_po_action>-Ebeln po_release = lv_popup_value ) 
  ) 
         REPORTED reported FAILED failed.

   READ ENTITY IN LOCAL MODE zc_brt_po_head 
   ALL FIELDS WITH VALUE #( ( Ebeln = <fs_po_action>-Ebeln ) ) 
   RESULT DATA(lt_result). 

   result = VALUE #( FOR ls_result IN lt_result 
                   ( ebeln = ls_result-Ebeln 
                    %param-ebeln = ls_result-ebeln 
                    %param-po_release = ls_result-po_release ) ). 
ENDLOOP. 

ENDMETHOD.

Purpose of the Method--

porel is triggered when a user clicks the “PO Release” button in Fiori.
Its job is to:

Read the selected POs from the frontend.
Update their po_release field based on the value passed from the frontend (%param-po_release).
Return the updated PO(s) back to the frontend so the UI reflects the change.

Feature	ponorel	porel
po_release update	Always sets to false	Sets dynamically from frontend %param-po_release
Use case	“PO Not Release” button	“PO Release” button or popup
Logic	Hard-coded	Dynamic based on action parameter

METHOD Static_ALL. 

   SELECT FROM zbrt_t_po_hrd 
          FIELDS ebeln , po_release 
          WHERE po_release = _false 
   INTO TABLE (lt_static_act). 

LOOP AT lt_static_act INTO DATA(ls_static_action). 

   MODIFY ENTITY IN LOCAL MODE zc_brt_po_head 
   UPDATE FIELDS ( porelease ) 
   WITH VALUE #( 
                ( ebeln = ls_static_action-ebeln 
                  porelease = abap_true )
 ) . 
   READ ENTITY IN LOCAL MODE zc_brt_po_head 
   ALL FIELDS WITH VALUE #( ( ebeln = ls_static_action-ebeln ) ) 
   RESULT DATA(lt_result). 

   result = VALUE #( FOR ls_result IN lt_result 
                   ( 
                    %param-ebeln = ls_result-ebeln 
                    %param-porelease = ls_result-porelease 
                   )
).
ENDLOOP. 

   INSERT VALUE #( 
               %msg = new_message_with_text( 
               severity = if_abap_behv_message=>severity-success 
               text = |{ lines( lt_static_act ) } Records has been upadted | 
                ) 
) INTO TABLE reported-zc_brt_po_head. 

ENDMETHOD.

Purpose of Static_ALL--

This method is typically triggered by a “Release All POs” button in Fiori.

It automatically sets all POs with porelease = false to true.

Provides a success message for the user showing how many POs were updated.

Step	Action
1	Select all unreleased POs from DB
2	Loop through them
3	Set porelease = true in local/draft mode
4	Read the updated record
5	Return updated data to frontend
6	Insert a success message in reported-zc_brt_po_head

METHOD migo_status_update. 

   READ ENTITY IN LOCAL MODE zc_brt_po_head 
   ALL FIELDS WITH VALUE #
                    ( FOR ls_key IN keys 
                    ( ebeln = ls_key-ebeln ) ) 
                      RESULT DATA(lt_migo_status). 

LOOP AT lt_migo_status ASSIGNING FIELD-SYMBOL(<fs_migo>). 

   IF <fs_migo>-porelease EQ abap_true. 
      MODIFY ENTITY IN LOCAL MODE zc_brt_po_head 
      UPDATE FIELDS ( migo_status )
      WITH VALUE #( ( ebeln = <fs_migo>-ebeln 
      migo_status = 'GR has done') ).

   ELSEIF <fs_migo>-porelease EQ abap_false. 
      MODIFY ENTITY IN LOCAL MODE zc_brt_po_head 
      UPDATE FIELDS ( migo_status ) 
      WITH VALUE #( ( ebeln = <fs_migo>-ebeln 
      migo_status = 'Open' ) ). 

ENDIF. 
ENDLOOP. 
ENDMETHOD.

Purpose--

Whenever the field porelease is modified (via POREL, PONOREL, or Static_ALL), this determination triggers.

Updates migo_status dynamically:

'GR has done' → if the PO is released (porelease = abap_true).

'Open' → if the PO is not released (porelease = abap_false).

Concept	Explanation
Determination	Runs automatically when a field changes (porelease) in RAP.
Local Mode	Updates the draft version, ensuring changes are visible in the UI before committing.
Dynamic Update	migo_status is computed automatically based on porelease.
No result table	The UI will automatically get updated via RAP binding; no explicit result table needed.

Create the service definition and service binding--

Let's preview our application in Fiori--

Above can see the PO Release status and MIGO Status is done.

Let's create a record and see the pop-up.

Above can the action button with drop down.

Let’s check the actions button, how PO release and MIGO status are changing.

Select one record-->click on action drop-down-->click on PO Not Release.

Now can see automatically MIGO status changed based on PO Release.

Conclusion--

In this blog, we explored how to implement parameterized actions in RAP using abstract entities and a dropdown-based parameter selection, enabling flexible and user-driven behavior in Fiori applications.

We demonstrated how multiple actions -- such as POREL, PONOREL, and STATIC_ALL — can be designed to handle different business scenarios like Purchase Order release, mass update, and status refresh dynamically. Furthermore, with the MIGO_STATUS_UPDATE determination, we ensured real-time consistency between release and goods receipt statuses, illustrating the power of behavior-driven logic in the RAP framework.

Thanks-------

How to Deliver Customizing as a SaaS Provider using Business Configuration Sets

2026-02-05T09:59:15.458000+01:00

In our previous blog post, How to Provide Customizing as a SaaS Provider, we described a programmatic approach that used EML statements with explicitly coded object templates in application jobs to deliver customizing entries. With release 2511, you can now use Business Configuration Sets instead, removing the need to include explicitly coded customizing data in your business logic.

This blog illustrates how to maintain customizing data in a Business Configuration Maintenance Object, how to maintain customizing translations, importing the created customizing data/translations into a BC Set, implementing an application job for the BC Set activation and finally how to deploy the BC Set content to the relevant customizing table.
We will also have a look into how BC Sets can be updated programmatically for the case when the customizing data was changed and BC Set data needs to be reimported.

This blog presents an alternative method to the Fiori app Upload Business Configuration. One restriction of the Upload Business Configuration app is that it does not validate the customizing data being uploaded.
In contrast, customizing data imported into Business Configuration (BC) Sets via ADT originates from existing customizing requests. This data is created within custom business configuration objects, where it is automatically validated through the underlying BO behavior (for example, error codes greater than 500 are rejected):

This blog covers the following topics:

Create Business Configuration Maintenance Object

The Business Configuration Maintenance Object discussed in this blog can be developed using the following tutorial, which guides you in creating a table for storing error codes:

Create Business Configuration Maintenance Object | SAP Tutorials

Providing Authorization Control for a Business Configuration Maintenance Object

To use the Business Configuration Maintenance Object, the required authorization must be set up. How to do this is explained in this tutorial:

Providing Authorization Control for a Business Configuration Maintenance Object | SAP Tutorials

Creating customizing data & translations

Maintain following customizing data as described in tutorial Use Custom Business Configurations app on a new customizing request:

Error Code	Description
400	Bad Request
401	Unauthorized
403	Forbidden

Afterwards your customizing request should include the primary customizing data as Customizing: Table Contents. Such customizing requests can be used for importing into a BC Set. Corresponding data records and translations will be extracted automatically during the process.

Maintain customizing translations for source language English United States and target language, for example German Germany, for the error codes using the Maintain Customizing Translations app.

Select the text table ZERRCODET_### that was created earlier as text source in your translation project.

Creating a BC Set and importing customizing data & translations

Follow the steps provided in Creating Business Configuration Sets to create a new business configuration set and use the customizing request that was created in the previous step for importing the data.

After successful import from the customizing request the error code data records as well as translations are included:

We can now proceed to implement an application job that can be used activate this BC Set.

Note: To import customizing data into a BC Set, the customizing data needs to be maintained for customizing objects of type Individual Transaction Object. A business configuration maintenance object (CUBCO) is configured as such by defining a transport object definition (TOBJ) in the service configuration settings of the CUBCO. By using the business configuration maintenance object wizard as described in Create Business Configuration Maintenance Object | SAP Tutorials, this prerequisite is fulfilled. For more information, please refer to Generating a Business Configuration Maintenance Object with the Generate ABAP Repository Objects Wizard → BC Management. Configuration changes are then recorded with object type TDAT instead of a TABU.

Those business configuration maintenance objects without existing transport object definition must be migrated, and a transport object definition needs to be created manually. How this can be done is described in the blog post How to enable BC Set support for BC app.

Creating an Application Job for the BC Set activation

In this example, an Application Job is used for creating and updating the customizing entries in a SaaS tenant. The customizing entries are deployed within the Application Job's implementation by activating the business configuration set using the corresponding runtime API.

As a first step, implement the BC Set activation as the business logic of the of the application job with a parameter for the BC Set to be activated and while saving activation messages in the application log:

CLASS zcl_errorcode_set_activate_000 DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    "! <p class="shorttext synchronized">Error Codes BC Set</p>
    DATA errorcode_bc_set TYPE cl_scpr_cd_bcset_activation=>ty_bcset_id VALUE 'Z_ERROR_CODES_SET_000'.

    INTERFACES if_apj_rt_run.
    INTERFACES if_apj_dt_defaults.

  PRIVATE SECTION.
    CONSTANTS log_object    TYPE cl_bali_header_setter=>ty_object    VALUE 'Z_ERRORCODE_SET_000'.
    CONSTANTS log_subobject TYPE cl_bali_header_setter=>ty_subobject VALUE 'ACTIVATE'.
ENDCLASS.

CLASS zcl_errorcode_set_activate_000 IMPLEMENTATION.
  METHOD if_apj_dt_defaults~fill_attribute_defaults.
    errorcode_bc_set = 'Z_ERROR_CODES_SET_000'.
  ENDMETHOD.

  METHOD if_apj_rt_run~execute.
    TRY.
        DATA(lo_bali_log) = cl_bali_log=>create_with_header(
                                header = cl_bali_header_setter=>create( object    = log_object
                                                                        subobject = log_subobject ) ).
        TRY.
            DATA(lo_bcset_activate) = cl_scpr_cd_bcset_activation=>of( errorcode_bc_set ).
          CATCH cx_scpr_object_not_permitted INTO DATA(lx_scpr_object_not_permitted).
            lo_bali_log->add_item(
                item = cl_bali_exception_setter=>create( severity  = if_bali_constants=>c_severity_error
                                                         exception = lx_scpr_object_not_permitted ) ).
        ENDTRY.

        DATA(lo_activation_handler) = lo_bcset_activate->get_activate_handler( ).

        DATA(lo_activation_result) = lo_activation_handler->local( )->add_activation_options( )->start( ).

        DATA(lt_activation_messages) = lo_activation_result->get_messages( ).

        LOOP AT lt_activation_messages INTO DATA(ls_msg).
          lo_bali_log->add_item( item = cl_bali_message_setter=>create_from_bapiret2( message_data = ls_msg ) ).
        ENDLOOP.

        cl_bali_log_db=>get_instance( )->save_log_2nd_db_connection( log                        = lo_bali_log
                                                                     assign_to_current_appl_job = abap_true ).

      CATCH cx_bali_runtime INTO DATA(lx_bali_runtime).
        RAISE EXCEPTION TYPE cx_apj_rt_content USING MESSAGE
          EXPORTING previous = lx_bali_runtime.
    ENDTRY.
  ENDMETHOD.
ENDCLASS.

Then create a catalog entry and job template for the class with the business logic: Creating a Job Catalog Entry and a Job Template. Also create an application log object and sub object according to the job logic implementation: Working with Application Log Objects.

To run the application job for BC Set activation, users must have the authorization provided by a business catalog. In this case we will reuse the business catalog Z_ERROR_CODES_### that was already created as part of the tutorial Providing Authorization Control for a Business Configuration Maintenance Object.

The business catalog Z_ERROR_CODES_### already includes the IAM App of type MBC (Business Configuration App) that was created for the CUBCO. During creation of the job catalog entry for the BC Set activation job, another IAM app with name <job catalog entry name>_SAJC is automatically created (refer to Setting up the Authorizations). This IAM app, to start the application job, is added to the existing business catalog so that the catalog provides authorizations to maintain error codes in the CUBCO as well as to start the BC Set activation job:

The BC Set activation implemented in the activation job using the CL_SCPR_CD_BCSET_ACTIVATION API requires table access for all entities used in the BC Set, so for both the primary tables as well as text tables. This can be achieved by adding the names of the tables in the TABLE authorization field of the existing S_TABU_NAM authorization in the _MBC IAM app: in this case ZERRCODET_000 (text table) and ZERRCODE_000 (primary table):

Hint: If you plan to run the BC Set activation job in your development system, do not forget to publish your changes to the business catalog locally.

Deploying the BC Set content by running the application job

Make sure that the user that shall run the BC Set activation job has following business roles/catalogs assigned in the ABAP tenant (for example your SaaS consumer tenant):

Business Role	Business Catalog	Purpose
SAP_BR_ADMINISTRATOR	SAP_CORE_BC_APJ_JCE	For scheduling jobs in the Application Jobs app
SAP_BR_BPC_EXPERT	SAP_CORE_BC_BCT_MBC_PC	To use the Custom Business Configurations app
ZBR_ERROR_CODES_EXPERT_###	Z_ERROR_CODES_###	To maintain error codes in the Custom Business Configurations app and to start the BC Set activation job. As created in tutorial Providing Authorization Control for a Business Configuration Maintenance Object

Open the Application Job App and select "Create" to create a new Application Job, then
choose the Application Job Template. Maintain the scheduling options and provide a valid BC Set in the parameter. Schedule the Application Job by clicking "Schedule".

Check the Application Job Log to determine if the BC Set content was deployed correctly:

Users assigned to the required business roles (see above) can now check in the Custom Business Configurations App whether the customizing has been inserted and updated correctly:

Maintaining customizing data programmatically in BC Sets

You might want to automate the lifecycle of your customizing data. For instance, you can update a BC Set with the latest customizing data after some changes. To do this, maintain your changes in EML within the configuration object on a customizing request. Then read the latest data from the underlying customizing tables and finally update the BC Set.

You can programmatically create a customizing request using the XCO CTS module. EML will then be used to maintain the data on that customizing request. Additionally, you have the option to programmatically release the customizing request afterward.

CLASS zcl_errorcode_generate_000 DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.

  PRIVATE SECTION.
    TYPES tyt_errorcodes            TYPE STANDARD TABLE OF zerrcode_000 WITH KEY error_code.
    TYPES tyt_errorcodestext        TYPE STANDARD TABLE OF zerrcodet_000 WITH KEY langu error_code.
    TYPES tyt_errorcodes_update     TYPE TABLE FOR UPDATE ZI_ErrorCode000.
    TYPES tyt_errorcodestext_update TYPE TABLE FOR UPDATE ZI_ErrorCode000Text.

    METHODS delete_errorcodes
      IMPORTING transportrequest TYPE trkorr.

    METHODS create_errorcodes
      IMPORTING transportrequest      TYPE trkorr
                it_errorcodes_crt     TYPE tyt_errorcodes
                it_errorcodestext_crt TYPE tyt_errorcodestext.

    METHODS update_errorcodes
      IMPORTING transportrequest         TYPE trkorr
                it_errorcodes_update     TYPE tyt_errorcodes_update
                it_errorcodestext_update TYPE tyt_errorcodestext_update.

    CONSTANTS co_cust_transport_target      TYPE if_xco_transport_target=>tv_value      VALUE ''.                                          " LOCAL
    CONSTANTS co_cust_transport_description TYPE sxco_ar_short_description              VALUE 'Maintain new error codes programmatically'.
ENDCLASS.


CLASS zcl_errorcode_generate_000 IMPLEMENTATION.
  METHOD if_oo_adt_classrun~main.
    " Create customizing transport request
    DATA(lo_customizing_request) = xco_cp_cts=>transports->customizing( co_cust_transport_target )->create_request(
        co_cust_transport_description ).

    " Programmatically create new error codes using EML
    create_errorcodes( transportrequest      = lo_customizing_request->value
                       it_errorcodes_crt     = VALUE tyt_errorcodes( ( error_code = '404' )
                                                                     ( error_code = '405' )
                                                                     ( error_code = '406' ) )
                       it_errorcodestext_crt = VALUE tyt_errorcodestext(
                           ( langu  = 'D' error_code  = '404' description = 'Not Found' )
                           ( langu  = 'E' error_code  = '404' description = 'Nicht gefunden' )
                           ( langu  = 'D' error_code  = '405' description = 'Method Not Allowed' )
                           ( langu  = 'E' error_code  = '405' description = 'Methode nicht erlaubt' )
                           ( langu  = 'D' error_code  = '406' description = 'Not Acceptable' )
                           ( langu  = 'E' error_code  = '406' description = 'Nicht akzeptabel' ) ) ).

    " Release customizing tasks and customizing request
    DATA(lt_transport_tasks) = lo_customizing_request->get_tasks( ).

    LOOP AT lt_transport_tasks INTO DATA(lo_transport_task).
      IF lo_transport_task->get_status( ) <> xco_cp_transport=>status->modifiable.
        CONTINUE.
      ENDIF.

      lo_transport_task->release( ).
    ENDLOOP.

    lo_customizing_request->release( ).

  ENDMETHOD.

  METHOD create_errorcodes.
    DATA lt_errorcode_create TYPE TABLE FOR CREATE ZI_ErrorCode000_S\_ErrorCode000.
    TYPES tys_errorcode_create LIKE LINE OF lt_errorcode_create.
    DATA ls_errorcode_create      TYPE tys_errorcode_create.

    DATA lt_errorcodestext_create TYPE TABLE FOR CREATE ZI_ErrorCode000\_ErrorCode000Text.
    TYPES tys_errorcodestext_create LIKE LINE OF lt_errorcodestext_create.
    DATA ls_errorcodestext_create TYPE tys_errorcodestext_create.

    LOOP AT it_errorcodes_crt INTO DATA(wa_errorcode_crt).

      ls_errorcode_create = VALUE #( SingletonID = 1
                                     %target     = VALUE #( ( ErrorCode          = wa_errorcode_crt-error_code
                                                              %control-ErrorCode = if_abap_behv=>mk-on ) ) ).
      APPEND ls_errorcode_create TO lt_errorcode_create.

    ENDLOOP.

    LOOP AT it_errorcodestext_crt INTO DATA(wa_errorcodestext_crt).
      ls_errorcodestext_create = VALUE #(
          %tky-ErrorCode = wa_errorcodestext_crt-error_code
          %target        = VALUE #( ( Langu                = wa_errorcodestext_crt-langu
                                      %control-Langu       = if_abap_behv=>mk-on
                                      Description          = wa_errorcodestext_crt-description
                                      %control-Description = if_abap_behv=>mk-on ) ) ).

      APPEND ls_errorcodestext_create TO lt_errorcodestext_create.

    ENDLOOP.

    MODIFY ENTITIES OF ZI_ErrorCode000_S
           ENTITY ErrorCode000All
           UPDATE
           FIELDS ( TransportRequestID )
           WITH VALUE #( ( SingletonId        = 1
                           TransportRequestID = transportrequest ) )

           ENTITY ErrorCode000All
           CREATE BY \_ErrorCode000 FROM lt_errorcode_create
           REPORTED DATA(r_errorcodes_crt)
           FAILED   DATA(f_errorcodes_crt)
           MAPPED   DATA(m_errorcodes_crt) ##NEEDED.

    MODIFY ENTITIES OF ZI_ErrorCode000_S
           ENTITY ErrorCode000
           CREATE BY \_ErrorCode000Text FROM lt_errorcodestext_create
           REPORTED DATA(r_errorcodestext_crt)
           FAILED   DATA(f_errorcodestext_crt)
           MAPPED   DATA(m_errorcodestext_crt) ##NEEDED.

    COMMIT ENTITIES
           BEGIN RESPONSE OF ZI_ErrorCode000_S
           FAILED DATA(failed_create)
           REPORTED DATA(reported_create) ##NEEDED.
    COMMIT ENTITIES END.
  ENDMETHOD.

  METHOD delete_errorcodes.
    MODIFY ENTITIES OF ZI_ErrorCode000_S
           ENTITY ErrorCode000All
           UPDATE
           FIELDS ( TransportRequestID )
           WITH VALUE #( ( SingletonId        = 1
                           TransportRequestID = transportrequest ) )

           FAILED DATA(f_delete_tr)
           MAPPED DATA(m_delete_tr)
           REPORTED DATA(r_delete_tr) ##NEEDED.

    MODIFY ENTITIES OF ZI_ErrorCode000_S
           ENTITY ErrorCode000All
           CREATE FIELDS ( TransportRequestID ) WITH VALUE #( ( TransportRequestID  = transportrequest ) )
           DELETE FROM VALUE #( ( SingletonID = 1 ) )
           FAILED DATA(f_delete)
           MAPPED DATA(m_delete)
           REPORTED DATA(r_delete) ##NEEDED.

    COMMIT ENTITIES
           BEGIN RESPONSE OF ZI_ErrorCode000_S
           FAILED DATA(failed_delete)
           REPORTED DATA(reported_delete) ##NEEDED.
    COMMIT ENTITIES END.
  ENDMETHOD.

  METHOD update_errorcodes.
    DATA lt_errorcodestext_update_i TYPE TABLE FOR UPDATE ZI_ErrorCode000Text.

    IF it_errorcodes_update IS NOT INITIAL OR it_errorcodestext_update IS NOT INITIAL.
      LOOP AT it_errorcodestext_update INTO DATA(ls_errorcodetext_update).
        ls_errorcodetext_update-%control-Description = if_abap_behv=>mk-on.
        APPEND ls_errorcodetext_update TO lt_errorcodestext_update_i.
      ENDLOOP.
    ENDIF.

    MODIFY ENTITIES OF ZI_ErrorCode000_S
           ENTITY ErrorCode000All
           UPDATE
           FIELDS ( transportrequestid )
           WITH VALUE #( ( SingletonID        = 1
                           TransportRequestID = transportrequest ) )

           ENTITY ErrorCode000Text
           UPDATE FROM lt_errorcodestext_update_i

           REPORTED DATA(r_errorcodes_upd)
           FAILED   DATA(f_errorcodes_upd)
           MAPPED   DATA(m_errorcodes_upd) ##NEEDED.

    COMMIT ENTITIES
           BEGIN RESPONSE OF ZI_ErrorCode000_S
           FAILED DATA(failed_update)
           REPORTED DATA(reported_update) ##NEEDED.
    COMMIT ENTITIES END.
  ENDMETHOD.
ENDCLASS.

The advantage of using EML to create, update, and delete customizing entries is that all validations of the business configuration object (BCO) are performed. This approach also supports both customizing entries of type table data (TABU) and individual transaction object (TDAT) since API adapters are available for both cases to be used in the behavior implementation of the BCO (for example, mbc_cp_api=>rap_tdat_cts()). For further information, refer to Transport Handling.

After updating the customizing data in the Business Configuration Object (BCO) using EML, the latest customizing data can be retrieved from the underlying customizing tables for further processing. Once the up-to-date customizing data is obtained, it can be directly maintained in the BC Set. This process utilizes the XCO generation APIs for BC Sets.

CLASS zcl_errorcode_generate_000 DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.

  PRIVATE SECTION.
    CONSTANTS co_workbench_request          TYPE trkorr                                 VALUE ''.                                          " ZLOCAL
    CONSTANTS co_error_codes_set_name       TYPE if_xco_business_cnfgrtn_set=>tv_name   VALUE 'Z_ERROR_CODES_SET_000'.

    CONSTANTS co_error_codes_entity_primary TYPE if_xco_bcs_entity=>tv_name             VALUE 'ZERRCODE_000'.
    CONSTANTS co_error_codes_entity_text    TYPE if_xco_bcs_entity=>tv_name             VALUE 'ZERRCODET_000'.
    CONSTANTS co_error_codes_tobj           TYPE if_xco_bcs_customizing_object=>tv_name VALUE 'ZERRORCODE000'.

ENDCLASS.

CLASS zcl_errorcode_generate_000 IMPLEMENTATION.
  METHOD if_oo_adt_classrun~main.
    " Read latest error codes from customizing tables
    SELECT * FROM zerrcode_000 WHERE error_code < 500 INTO TABLE (lt_errorcodes).
    ASSERT sy-subrc = 0.

    SELECT * FROM zerrcodet_000 WHERE error_code < 500 INTO TABLE (lt_errorcodes_text).
    ASSERT sy-subrc = 0.

    " Retrieve error codes BC set and make sure it exists
    DATA(lo_business_configuration_set) = xco_cp_abap_repository=>object->scp1->for( co_error_codes_set_name ).
    ASSERT lo_business_configuration_set->if_xco_ar_object~exists( ).

    " Create BC Set patch operation and change specification to remove existing error codes customizing object (all its Entities and corresponding records)
    DATA(lo_patch_operation_delete) = xco_cp_generation=>environment->dev_system( co_workbench_request )->for-scp1->create_patch_operation( ).
    DATA(lo_change_specification_delete) = lo_patch_operation_delete->add_object( co_error_codes_set_name )->create_change_specification( ).
    lo_change_specification_delete->for-delete->add_individual_transaction_obj( co_error_codes_tobj ).

    " Create BC Set patch operation and change specification to insert latest error codes using latest customizing data
    DATA(lo_patch_operation_insert) = xco_cp_generation=>environment->dev_system( co_workbench_request )->for-scp1->create_patch_operation( ).
    DATA(lo_change_specification_insert) = lo_patch_operation_insert->add_object( co_error_codes_set_name )->create_change_specification( ).
    DATA(lo_tobj_insert) = lo_change_specification_insert->for-insert->add_individual_transaction_obj(
                               co_error_codes_tobj ).
    lo_tobj_insert->for-insert->add_entity( co_error_codes_entity_primary )->for-insert->add_records(
                                                                              REF #( lt_errorcodes[] ) ).
    lo_tobj_insert->for-insert->add_entity( co_error_codes_entity_text )->for-insert->add_records(
                                                                           REF #( lt_errorcodes_text[] ) ).

    " After preparing the change specifications, execute the PATCH operations
    TRY.
        DATA(lo_result_delete) = lo_patch_operation_delete->execute( ) ##NEEDED.
        DATA(lo_result_insert) = lo_patch_operation_insert->execute( ) ##NEEDED.

      CATCH cx_xco_gen_patch_exception INTO DATA(lo_xco_gen_patch_exception).

        LOOP AT lo_xco_gen_patch_exception->findings->get( ) ASSIGNING FIELD-SYMBOL(<fs_finding>) ##NEEDED.
          " Process errors/exceptions raised from the PATCH operation
        ENDLOOP.
    ENDTRY.
  ENDMETHOD.

ENDCLASS.

This section of using the XCO generation API for BC Sets to update BC set data requires customizing entries of type individual transaction object (TDAT). This is because it’s a requirement for importing any data into a BC Set. BC Sets are workbench objects and can be delivered alongside other development objects in your development software components.

Hint: In productive scenarios remove the ##NEEDED pragma from the code examples and implement proper error handling!

Reimagining Utility Transformation: Clean Core Principles Powered by SAP BTP

2026-02-06T07:51:30.744000+01:00

Introduction

Across the utility industry, one message appears in every transformation discussion: “Keep the core clean.” The guidance is sound, especially for organizations preparing for S/4HANA. But inside SAP IS‑U—where regulatory complexity, legacy billing logic, and decades of Z‑programs coexist—this principle often feels contradictory.

Utilities must modernize rapidly while protecting the stability of their revenue engine. This creates a familiar tension: innovation requires speed, but the core requires caution.

This post explores why that tension exists, how SAP BTP resolves it, and how utilities can operationalize a Clean Core strategy without compromising business continuity.

Main Body

1. The Customization Cage: How Utilities Got Here

For many years, utilities solved business needs by customizing the ERP core:

Custom ABAP for tariffs
Modified standard tables for regulatory fields
Embedded workflows inside IS‑U
Enhancements tightly coupled to billing and device management

These decisions were practical at the time—but over decades, they created a Rigid Core that is difficult to upgrade, expensive to test, and slow to evolve.

Resulting challenges:

High upgrade risk
Long regression cycles
Slow innovation
Technical debt that compounds every year

Your first diagram captures this reality perfectly.

Diagram 1 — The Customization Cage

2. Clean Core + SAP BTP: The Agility Layer Utilities Needed

A Clean Core strategy is not about reducing capability—it’s about relocating capability.

SAP Business Technology Platform (BTP) provides the architectural separation utilities have needed for years:

S/4HANA Core → Stable, standardized, upgrade-friendly
SAP BTP → Custom logic, workflows, APIs, event-driven processes

This separation transforms the ERP into a system of record, while BTP becomes the system of innovation.

Key benefits:

Faster delivery cycles
Reduced regression testing
Lower upgrade effort
Event-driven operations
Extensibility without core modification

3. A Practical Framework for Utility Clean Core Adoption

SAP Community readers expect actionable, practitioner-focused guidance. Here is a structured approach utilities can follow.

Step 1: Start With a Core Assessment

Identify:

Business-critical customizations
Redundant or obsolete logic
Enhancements blocking upgrade cycles
High-change areas suitable for BTP

This reframes Clean Core as risk reduction, not cleanup.

Step 2: Move High-Variability Logic to BTP First

Ideal candidates include:

Rate and tariff changes
Regulatory reporting
Credit & collections workflows
Meter-to-cash orchestration
BPEM automation

These areas generate the most upgrade friction—and deliver the fastest BTP wins.

Step 3: Use SAP Event Mesh to Break the Batch Mindset

Utilities can begin shifting toward real-time operations by triggering events for:

Move-in / move-out
Billing determinants
Meter read exceptions
Payment events
Outage notifications

This enables a hybrid model: batch where necessary, real-time where possible.

Step 4: Establish Governance That Protects the Core

No custom code in S/4 unless SAP mandates it
BTP-first evaluation for all new logic
Standard APIs and events as default patterns
Quarterly architecture reviews to prevent “core creep”

Governance is the long-term safeguard of Clean Core.

Step 5: Treat BTP as a Business Platform

Executives respond when BTP is positioned as:

A revenue protection tool
A regulatory accelerator
A customer experience enabler
A technical debt reduction mechanism

Step 6: Build a 24‑Month Roadmap

A practical roadmap includes:

Phase 1: Core assessment + quick wins
Phase 2: Event-driven architecture rollout
Phase 3: Predictive and AI-driven use cases
Phase 4: Full Clean Core enforcement + S/4 readiness

This provides clarity, sequencing, and measurable ROI.

4. The Modern Utility Innovation Stack

Your second diagram illustrates the future-state architecture:

A stable S/4HANA core
A flexible BTP layer
A connected utility ecosystem

Diagram 2 — The Utility Innovation Stack

Conclusion

A Clean Core is not a limitation—it is a strategic advantage.

Utilities preparing for S/4HANA should shift the conversation from:

“How do we migrate everything we built?” to “How do we protect the core and modernize the business at the same time?”

SAP BTP provides the answer:

Keep the core stable
Move innovation to the agility layer
Adopt event-driven operations
Reduce technical debt
Build a future-ready architecture

Utilities that embrace this model will be better positioned to innovate, comply, and scale in the decade ahead.

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

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

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

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

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

We will cover the below points:

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

1 Architecture Overview

Solution Architecture

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

2 Prerequisites

You must have:

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

3 Creating a Task Chain in SAP Datasphere

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

In the given example:

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

SAP Datasphere Task Chain with Replication Flow inside

Main takeaways:

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

4 Configuring OAuth Client in SAP Datasphere

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

Navigation Path

Datasphere → Administration → App Integration → OAuth Clients

OAuth Endpoints Provided

Amongst others, SAP Datasphere automatically exposes:

Authorization URL
Token URL

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

Configured OAuth Client (based on Technical User)

Menu Path Datasphere

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

OAuth Client Generation

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

OAuth Client Details

Important settings:

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

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

5 Creating Communication Artifacts in ABAP Cloud

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

First create an Outbound Service of type HTTP:

Create Outbound Service

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

Communication Scenario Creation

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

ABAP Cloud Web Access

ABAP Cloud Communication Systems

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

ABAP Cloud Communication Systems Details

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

ABAP Cloud Communication Systems Users

Key fields:

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

6 Creating a Communication Arrangement in SAP ABAP Cloud

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

Navigation: Communication Management → Communication Arrangements

Arrangement Example: ZDSP_CS_REST

ABAP Cloud Communication Arrangements

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

ABAP Cloud Communication Arrangements Detailed Configuration

What this provides:

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

7 Calling the Datasphere Task Chain API from ABAP Cloud

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

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

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

ABAP Cloud Implementation Pattern

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

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

The code snippet performs the following parts in more detail:

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

triggers a new run
receives a JSON response containing a LogId

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

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

Print everything in the ABAP Console.

ABAP-Code Snippet:

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

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

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

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

  ENDMETHOD.

  METHOD call_dsp.

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

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

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

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

    DATA(arrangement) = arrangements[ 1 ].

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

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

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

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

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

    WAIT UP TO 10 SECONDS.

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

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

  ENDMETHOD.
ENDCLASS.

Once triggered:

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

Follow-up calls can fetch:

Execution status
Logs
Completion result

8 Execution Results

ABAP Cloud Console Log: Results

The Task Chain in Datasphere is in Running status:

SAP Datasphere Task Chain Running Status

9 Conclusion/Outlook & Further aspects:

Overview of the major building blocks:

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

Use Cases that the implementation enables:

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

References

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

These are your main takeaways to further sharpen the solution:

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

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

Unlock S/4HANA Cloud Secrets: Hybrid Events+APIs Strategy for Seamless BTP Data Flows

2026-02-12T01:30:35.487000+01:00

Strategic Financial Data Extraction from SAP S/4HANA Cloud Public Edition to SAP BTP

Using Transfer Pricing as a Real-World Example

Transfer pricing represents a perfect use case to demonstrate generic financial data extraction strategies from SAP S/4HANA Cloud Public Edition. Multinational organisations need GL, Controlling, Material Ledger, and Asset Accounting postings to flow reliably to external engines hosted on SAP BTP—but Public Cloud’s “no direct database access” constraint demands architecturally sound patterns.

Why Transfer Pricing Perfectly Illustrates the Challenge

The business need: Calculate inter-company markups (cost-plus, resale-minus) using real-time ACDOCA postings across multiple currencies, profit centres, and cost elements.
The constraint: Pure cloud extensibility—no RFCs, no custom ABAP, no direct table extracts.
The solution: Three proven patterns that work for any financial data integration scenario.

Pattern 1: Event Notifications (Real-Time Push Model)

How transfer pricing uses it: GL postings trigger automatic business event notifications routed through SAP Event Mesh to BTP applications.

Event Notification

Generic applicability: Works for any posting-driven process—revenue recognition, inter-company reconciliation, compliance monitoring.

High-level activation:

Integration configuration apps → Activate accounting-related event notifications
Communication scenarios → Configure outbound event destinations
Event Mesh subscription → Point to BTP service endpoint
Payload contains: Company codes, ledger amounts (local/group), profit centres, material valuations

Pattern 2: Standard Query Services (Scheduled Pull Model)

How transfer pricing uses it: BTP service queries S/4HANA nightly for new/changed financial postings.

Query ServiceKey services (release-dependent availability):

Financial line item services → GL/CO/ML/AA postings
Profitability services → Margin analysis data
Material valuation services → Cost component details

Generic applicability: Perfect for scheduled reconciliation, historical backfills, or validation runs.

Pattern 3: Hybrid Extraction (Production Resilience)

Transfer pricing demands 99.9% coverage. Smart architects layer all three patterns:

Use Case	Primary Pattern	Transfer Pricing Example	Generic Use
Real-time GL postings	Event notifications	Invoice → immediate markup	Any posting trigger
Historical catch-up	Standard APIs	Month-end reconciliation	Data migration
Day 1 implementation	Bulk extraction	Full ACDOCA baseline	Initial loads
Custom calculations	BTP processing	Exception overrides	Business rules

Three-tier reference flow:

Hybrid ExtractionBTP Implementation Patterns (Transfer Pricing Example)

Cloud Application Programming Model (CAP)

service FinancialIntegration {
  entity Postings as projection on external financial services;
  entity PricingResults as projection on HANA staging;
}

Pattern: Event handlers + scheduled queries → unified HANA staging → business rules.

ABAP RESTful Application Programming (RAP)

define root view entity FinancialDataView
  as select from standard financial services

Pattern: Analytical CDS views over external data → transactional services.

Architect’s Production Checklist

✅ Tenant validation: Test events/APIs in your specific S/4HANA Cloud environment
✅ Quota management: Monitor Event Mesh throughput + API rate limits
✅ Fallback design: API polling validates event stream completeness
✅ Quarterly readiness: SAP evolves event coverage and API fields continuously
✅ Pure cloud: Zero custom code in production S/4HANA

The Universal Pattern

Transfer pricing proves the strategy works for complex financial scenarios. The same architecture applies to:

Inter-company reconciliation
Revenue recognition automation
Compliance reporting engines
Analytics data pipelines
Any standard data object/model driven process

Universal PatternKey takeaway: This isn’t “just for transfer pricing”—it’s your reusable blueprint for any S/4HANA Cloud → BTP data integration.

Accelerating SAPUI5 Migration to BAS: A Practical Framework

2026-02-12T08:43:37.222000+01:00

Introduction:

SAP has transitioned its development paradigm from SAP Web IDE to SAP Business Application Studio (BAS), pushing developers to migrate from legacy UI5 to Fiori applications to the new environment. This paper outlines a structured and scalable methodology to migrate SAP UI5 applications from WEB IDE to BAS, focusing on connectivity, tooling and configuration challenges.

Methodology:

Log in to your BTP Account. Go into your space. Go to the Service Marketplace. Search for Business Application Studio. Open Business Application Studio Application.

Note: Pre-Requisite - Cloud Connector and Destination should be set up for connectivity with the S4.

2. Click on Create Dev Space. Give some Dev Space Name—select the SAP Fiori on the left. On the right side, under Additional SAP Extensions select HTML5 Application Template, Launchpad Module, Basic UI5 Template. Click on Create Dev Space.

3. Dev Space is created as shown below. It will take a few minutes to start. Once it's started, click on the Dev space. Here, I have named it “DemoMigration”. It will open the Development workspace. Bookmark this URL for future use and easy navigation to Workspace.

4. For the first time, click on the menu on the top left and select the open folder. Search for Projects Folder. Click on OK.

5. Click on Import on your Get Started page. It will prompt to start the migration. Select migration option. Below screen will appear.

6. Select Destination and Hostname and Client Details.

Conclusion:

Migrating SAP UI5 applications from SAP Web IDE to SAP Business Application Studio is more than a technical upgrade. It represents a strategic change towards a cloud-native and future ready development environment aligned with that of SAP’s roadmap. This blog outlined a well-structured migration methodology, which includes prerequisite connectivity set up, dev space configuration, project import and environment preparation within BAS. By following these steps, organizations can ensure a smooth transition while minimizing disruption to existing Fiori applications. This structured approach simplifies migration from WEB IDE to BAS. It supports scalable and cloud-aligned SAPUI5 development for public institutions and enterprises.

SAP Master Data Governance, cloud edition – Maintenance Windows and Major Upgrade Windows in 2026

2026-02-12T18:25:20.539000+01:00

Major Upgrade Windows

As in 2025, the SAP Master Data Governance, cloud edition has 4 Major Upgrade Windows in 2026. These 24 hours of potential system unavailability are used to upgrade the systems to the next major version.

May 16th – 17th (Release 2605)
August 15th – 16th (Release 2608)
November 14th – 15th (Release 2611)

Depending on the data center region, the 24 hours downtime will start/end at:

Europe: SAT 4 am – SUN 4 am UTC
Americas: SAT 10 am – SUN 10 am UTC

Weekly Maintenance Windows

Potentially every weekend, the SAP Master Data Governance, cloud edition could use a downtime of 4 hours, to apply database updates, Hotfix Collections and other changes.

Depending on the data center region, the 4 hours downtime may start at:

Europe: SAT 9 pm UTC
Americas: SUN 5 am UTC

The following events for the release 2602 are planned as Weekly Maintenance Windows in 2026:

Hotfix Collection ... for Release 2602 | ... (information will be updated accordingly)

Cloud System Notification Subscriptions (CSNS)

Please register to Cloud System Notification Subscriptions (CSNS) in SAP for Me to get important information about planned and unplanned downtimes:

Please register to Cloud System Notification Subscriptions (CSNS) in SAP for Me to get important information about planned and unplanned downtimes:
- Access to Cloud System Notification Subscriptions (CSNS): https://me.sap.com/systemsprovisioning/getNotified
- Find more information about Cloud System Notification Subscriptions (CSNS) in this documentation
- To find SAP Master Data Governance, cloud edition entry select:
  - Subscription Type: Cloud Service
  - Solution Area: SAP Master Data Governance, cloud edition

References

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

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

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

Packed with live demos and product insights:

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

🔹New My Home (Caroline Welsh)

🔹Product Updates (Frank Jentsch)

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

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

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

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

We’re looking forward to seeing you there!

Custom code migration to SAP S/4HANA powered by SAP Joule for Developers, ABAP AI capabilities

2026-02-18T14:23:51.235000+01:00

Custom code migration during system conversion to SAP S/4HANA Cloud Private Edition is usually complex and time-consuming process. The whole custom code developed in the SAP ECC systems since years must be assessed and analysed for SAP S/4HANA and finally adapted after system conversion.

Customers often face challenges to understand S/4HANA simplifications and their relation to the custom code due to scattered documentation across various channels like SAP simplification notes, SAP Help, blog posts. To find an answer to the specific SAP S/4HANA custom code migration question, one needs to go through multiple sources of information.

The IT project managers have a tough time to carry out the custom code migration projects on time and within budget because they experience difficulties during execution of their tasks like defining custom code migration scope, getting high-level understanding of custom code issues, creating effort estimations and project plans and finding the right development experts for adaptation. Ability to meet a decision whether to migrate custom code to S/4HANA or not assumes understanding of its business purpose which is quite challenging primarily due to the absence of documentation for legacy code. Custom Code Migration app on SAP BTP can execute custom code analysis for S/4HANA readiness, but S/4HANA comes along with more than 430 simplification items which affect custom code. Thus, to get at least a high-level understanding of issues reported by the Custom Code Migration app to assign appropriate work packages to custom code migration developers a project manager needs to deep dive into these lengthy simplification items and provided cookbooks, which is time- and effort-consuming activity.

Along with this custom code migration developers, who finally must adapt the code for S/4HANA need to understand the old legacy code in all details: not only the business logic, but also the technical processing flow which is quite tedious task due to missing documentation. ABAP test cockpit (ATC) in ABAP development tools for Eclipse can check custom code for S/4HANA readiness, but developers still invest high effort into studying related simplification items and cookbooks to understand the issues in detail. The ATC issues in custom code should be fixed ideally with a high automation rate, but the quick fixes provided for S/4HANA ATC issues in ABAP development tools for Eclipse can support about 40%-60% of the typical S/4HANA simplification use cases like conflicts with MATNR field extension or missing ORDER BY in SELECTs, the remaining ATC issues must be fixed manually by developers.

To support IT project managers and developers during custom code migration projects to speed up the analysis and adaptation tasks and enhance productivity the AI-based skills were delivered for custom code management tools within SAP Joule for Developers, ABAP AI capabilities. This will shorten the custom code migration projects timelines, reduce project risks and enhance capacity to meet deadlines and budget constraints.

Let’s look at them in detail.

AI-based custom code migration support for IT project managers

Starting with SAP BTP ABAP environment 2602 AI-based custom code analysis support for IT project managers is integrated in the Custom Code Migration app. To use it the SAP Joule for Developers, ABAP AI capabilities must be activated in your SAP BTP ABAP environment system. See the SAP note 3571857.

Understand legacy code in the AI-based Custom Code Migration app

You will get short and clear AI-based explanation of the code in the pop-up window, which will support your migration decision. Subsequently you can use Explain business purpose in detail and Explain processing logic in detail options to get more details to deepen the clarification.

Finally, you can use Scope part of the Custom Code Migration app to add or remove the object from scope based on your decision.

Understand S/4HANA ATC issues in the AI-based Custom Code Migration app

After execution of remote SAP S/4HANA readiness ATC check run over the custom code in the ECC system with the Custom Code Migration app in SAP BTP ABAP environment it is now possible under the Analyze Findings view to select an ATC issue in the Findings table and use ATC Explain capability to get an explanation of an S/4HANA related ATC finding. The explanation is provided in the pop-up window along with the proposed step-by-step resolution and contains also referenced S/4HANA simplification materials like simplification notes or cookbooks. Referenced documents are offered as clickable links within the AI-based response for navigation to further details.

This will enable you to grasp the root cause quickly without having to read through numerous SAP S/4HANA simplification information materials.

AI-based support for custom code migration developer in ABAP development tools for Eclipse

Starting with SAP S/4HANA Cloud Private Edition 2025 AI-based custom code analysis and adaptation support for developers is provided in ABAP development tools for Eclipse within SAP Joule for Developers, ABAP AI capabilities. To find out how to activate it see the blog post SAP Joule for Developers, ABAP AI capabilities for SAP S/4HANA Cloud Private Edition 2025.

NOTE: Code Explain for module pools and ABAP classes along with the deep dive explain (code in INCLUDEs and called methods outside of the source code object) will be delivered with SAP S/4HANA Cloud Private Edition 2025 FPS01.

Using Docs Chat for questions around custom code and S/4HANA simplifications

In most cases you as a custom code migration developer before starting with your adaptation activities first need to gain general understanding of S/4HANA simplifications related to your functional area of expertise to get an overview as well as deep dive into SAP standard changes relevant to your custom code.

Docs Chat capability utilizes SAP simplification notes, related technical information and SAP Help documentation to deliver based on this extensive input quick and accurate answers.

Select /docs topic in the Joule chat window and ask your question, for example “What are the data model changes in Sales and Distribution?”. Joule will list all technical changes along with affected objects including also reference links for further information. You can also ask follow- up questions for your query.

Now for example after finding out that VBUK and VBUP tables were eliminated in S/4HANA and knowing that this has direct impact on your custom code, you can ask Joule ”How can references to VBUK and VBUP be eliminated in my code?”. Joule will deliver short and concrete answer providing code proposals considering different use cases based on the information provided in the extensive cookbook about the VBUK and VBUP adaption.

Understanding of old legacy code

Generally, you as a custom code migration developer starting with your adaptation activities need to understand the old legacy code, which must be analysed and adapted for S/4HANA. Thereby you are confronted with the following problems: the code has been implemented many years ago, often expands over multiple pages, has very little or no documentation, the author of the code is not available any more for questions and so on. Thus you have a tedious and long-time task to digest this code to verify if it is still needed from the business perspective and understand it’s implementation logic for the adaptation.

The Explain for ABAP report and Explain for module pools as interactive Dynpro-based applications capabilities significantly speed up and make more accurate the task of understanding of old legacy code.

Just select an old ABAP report in the Project Explorer and use context menu Joule ->Explain. Joule will explain its business purpose and processing logic and will list all called objects. You can further deep dive into details using Explain business purpose in detail or/and Explain processing logic in detail features in the Joule chat window or ask Joule to explain called objects.

In the example below the business purpose of this custom ABAP program is to upload customer email addresses, which length exceeds 50 characters since the standard ABAP program cannot handle it, and this custom functionality will be still required in the S/4HANA system.

Therefore, you as developer can for example follow up on the details of processing logic to understand the program better for the upcoming adaptation.

You can also select the source code snippet in the editor and ask Joule to explain it:

Here is one example of the module pool explanation by Joule. In addition to the general overview and business purpose Joule describes user flow, which is very important for screen-based Dynpro applications to follow on the screen logic along with technical details for the processing logic of the screens (PBO/PAI) comprising deep-dive into INCLUDEs and Dynpro logic:

Understanding of S/4HANA related ATC findings

The basis for all custom code adaptation activities is the execution of S/4HANA readiness checks with ATC over custom code in your S/4HANA system in ABAP development tools for Eclipse. The ATC check result contains the list of S/4HANA incompatibility issues in custom code, which must be adapted, explaining the error and providing as a reference the link to the corresponding simplification information. The custom code migration developer needs to read through it to find out how to apply it to solve the error in the particular custom code object, which is time-consuming task.

The Explain ATC finding capability offers clear and short explanation of the S/4HANA related issue in custom code based on information provided in S/4HANA simplification items and cookbooks along with step-by-step recommendation on how to solve the issue.

After execution of the ATC check run with S/4HANA readiness check variant S4HANA_READINESS_2025 over your custom code the ATC findings are displayed in the ATC Problems View. In the Details of an ATC finding you see the description of the error, in this example “DB Operation found (KONV, see Note(s) 0002220005)” and the link to the related SAP simplification note 2220005, which must be examined to understand how to resolve this issue. Instead of doing this just select the ATC finding and use the context menu Joule->Explain.

Joule will deliver a crisp explanation telling you that the table KONV was replaced in S/4HANA with the table PRCD_ELEMENTS, which must be accessed using the new pricing result API. This explanation is based on the information provided within the cookbook about pricing conditions techniques attached to the related SAP simplification note 2220005. Joule can also provide step-by-step recommendations on how to fix the issue and can answer follow-up questions for further clarification. The referenced documents (related SAP simplification note in this example) are offered as clickable links within the Joule response for navigation to further details.

This will allow you to quickly grasp the root cause without having to read through numerous SAP S/4HANA simplification information materials.

Getting code proposal for adaptation of S/4HANA related issues

The final step for a custom code migration developer is to fix S/4HANA related ATC findings to adapt the code to S/4HANA.

The ATC findings which can be resolved using deterministic quick fixes are marked with the yellow light bulb in the ATC findings list. The resolution of the remaining findings must be done manually based on simplification information, which is quite laborious and time-demanding task.

The Code proposal capability allows you to fix the issue in custom code based on AI-based proposal emulating the same process as deterministic quick fixes and can be utilized for S/4HANA issues where deterministic quick fixes are not available.

After AI-based explanation of an ATC finding just click Generate Code Proposal in the Joule window

The AI-based code proposal is UI friendly: it can be generated either after explanation of the ATC finding (as suggested above) or from a source code line in the editor.

For generating code proposal from source editor just click on the ATC finding marker like this:

After Joule proposed the code change, you have different options. You can Copy the code proposal for pasting it into the editor later or Insert the code at the cursor position in the editor, or use Apply (recommended).

If selecting Apply, then in the same way as for deterministic quick fixes the Code Review Dialog will be shown displaying the original source code and the source code containing code proposal.

You as developer can review the code proposal and apply as needed. AI-based Code Proposal allows you to save the manual efforts and benefit from the semi-automated code adaptation as you already know it from the deterministic quick fixes.

Further information

Discover generative AI capabilities for ABAP custom code migration by watching the video: Unleash the power of GenAI for ABAP Custom Code Migration.

For more details about ABAP AI capabilities for custom code migration refer to the SAP Help Portal documentation Using Custom Code Migration AI assistant including also video tutorials.

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

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

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

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

𝗢𝗻-𝗣𝗿𝗲𝗺𝗶𝘀𝗲

✔ You own/manage servers like ECC

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

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

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

✔ Limited Custom Code - Must Follow Clean Core Principles

𝗣𝘂𝗯𝗹𝗶𝗰 𝗖𝗹𝗼𝘂𝗱

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

✔ No Custom ABAP - Extensions Via BTP only

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

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

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

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

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

✔ Your Data is Completely isolated from other companies

✔ You get your own dedicated hardware/software stack

✔ SAP manages infrastructure ( Servers, OS, backups )

✔ You still control configurations and some customizations

𝗘𝘅𝗮𝗺𝗽𝗹𝗲:

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

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

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

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

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

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

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

✔ Your data is logically separated (like database partitions)

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

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

✔ No custom ABAP allowed (everyone uses same codebase)

𝗘𝘅𝗮𝗺𝗽𝗹𝗲:

Single Server → Single S/4 Instance

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

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

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

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

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

Having your own ECC system but SAP hosts the servers

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

✔ Can have some customizations (within clean core limits)

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

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

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

✔ Cost-effective but zero flexibility

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

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

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

Start ups - Public cloud ( Cost Effective )

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

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

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

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

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

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

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

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

" 𝗬𝗼𝘂 𝗱𝗼 𝘁𝗵𝗶𝘀:

1. Create Z-table (SE11)

2. Write custom ABAP program (SE38/SE80)

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

4. Add custom fields to EKKO table

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

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

You do this:

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

2. Build approval app on BTP (separate system)

3. Connect to S/4 via APIs

4. Store custom data in BTP database

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

𝟱. 𝗥𝗔𝗣 𝘃𝘀 𝗖𝗔𝗣

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

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

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

• Create custom database tables (Z-tables)

• Access standard SAP tables directly

• Some custom ABAP classes (within clean core guidelines)

• Traditional debugging in ADT

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

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

• NO custom database tables in S/4

• Only released APIs/BAPIs allowed

• Cannot use SE11/SE80 - only Eclipse ADT

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

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

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

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

𝟲. 𝗖𝗹𝗲𝗮𝗻 𝗖𝗼𝗿𝗲

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

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

𝗘𝘅𝗮𝗺𝗽𝗹𝗲 :

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

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

𝗖𝗹𝗲𝗮𝗻 𝗰𝗼𝗿𝗲 :

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

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

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

• No code in customer exits/BADIs

• Configuration-driven transformations

• Standard AIF framework handles processing

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

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

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

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

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

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

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

Add simple extensions inside SAP using key user tools.

SAP BTP ABAP Environment - Release 2602

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

SAP BTP ABAP Environment - Release 2602

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

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

ABAP Development Tools (ADT)

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

ABAP RESTful Application Programming Model (RAP)

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

Identity and Access Management

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

Manage API Snapshots

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

SAP Fiori Launchpad

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

Landscape Portal

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

Infrastructure

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