Knowledge & Trends

Modern ABAP: language, RAP, CDS, ABAP Cloud, and clean core at a glance

Aug 2026 | Blog

Blogartikel – Modernes ABAP

With CDS, RAP, and ABAP Cloud, the recommended development model of the SAP platform in particular has changed fundamentally: declarative data models, a standardized application model, and a dedicated set of rules for upgrade-stable extensions. This article provides an overview of the key terms and concepts of modern ABAP.

Why it’s worth taking a fresh look at ABAP

Anyone who last touched ABAP ten years ago almost inevitably underestimates the platform today. The common picture (procedural reports, SAP GUI, modifications to the standard) accurately describes many legacy systems, but no longer the platform itself. For tightly integrated S/4HANA extensions, ABAP remains the technology SAP intends; depending on the scenario, however, side-by-side approaches on BTP (for example with SAP CAP), integration solutions, or simply standard functionality can also be the better choice.

In established customer landscapes, we regularly see the same pattern: modern ABAP and classic legacy code have to coexist for years. The question is rarely “old or new,” but rather how to run both side by side in a controlled way and gradually bring them together. This article puts the building blocks you need to know for this trade-off into context.

The building blocks at a glance

The terms of modern ABAP describe different levels. This map helps put the following sections into context:

Übersichtstabelle: Ebenen, Bausteine und Aufgaben im modernen ABAP

What defines ABAP

Two characteristics have shaped ABAP to this day. First, its consistent focus on mass data processing in a business context: concepts such as internal tables, the deeply integrated database interface, and multi-client capability are built directly into the language. Second, the server-centric development model: development objects reside centrally in the system, and versioning and the transport system are part of the platform. With abapGit and gCTS (the Git-based transport system of the ABAP platform), bridges to the file-based Git world now exist.

Syntactically, ABAP visibly wears its COBOL heritage. Modern ABAP, however, is far removed from that: inline declarations, constructor expressions, string templates, and functional table operations have made the language considerably more concise since release 7.40.

ABAP OO: the foundation of modern frameworks

With ABAP Objects, the language was extended with an object-oriented model: classes, interfaces, inheritance, and events. Procedural and object-oriented programming coexist, which makes the gradual modernization of existing code easier.

In modern ABAP development, object orientation is central: ABAP Unit, the test framework, is class-based, RAP implementations are written in classes, and released APIs include classes and interfaces above all, alongside CDS views and cloud BAdIs. In practice, this means putting business logic behind interfaces, making dependencies injectable, and including tests with ABAP Unit and test doubles from the start, so that existing logic can also be decoupled step by step.

Code pushdown: ABAP SQL, CDS, and AMDP

With SAP HANA as the database under S/4HANA, the performance paradigm has been reversed: calculations move into the database (code to data) instead of pulling data to the application server. Three terms that are often confused here:

ABAP SQL is the former Open SQL: renamed and continuously expanded since then (joins, CASE, window functions, arithmetic expressions; the scope of functionality depends on the release). Database-independent and integrated into ABAP, it is usually the first approach for pushdown scenarios. Native SQL, by contrast, refers to database-specific SQL (via ADBC) and remains the exception.

This is what pushdown looks like in ABAP SQL (excerpt; lv_from contains the start date, out is the console output of an ADT example class):

Core Data Services (CDS) are the central modeling tool: data models are defined as view entities with relationships, additional information (annotations), and access control directly in the ABAP stack. Put simply, a CDS view describes which data is available, in what structure, and with what meaning. Fiori apps, analytics, and APIs build on this foundation.

The annotation @AccessControl.authorizationCheck: #CHECK only activates the check; the actual access control is defined separately as a CDS access control (DCL). Only this determines which user may see which data.

AMDP (ABAP Managed Database Procedures) with SQLScript complements ABAP selectively, where HANA-native functions bring real added value, such as with complex calculation logic. The standard recommendation is: CDS and ABAP SQL first, AMDP only where necessary.

UI and application model: Fiori and RAP

For new user interfaces, Web Dynpro ABAP is generally no longer the right choice; however, existing applications remain in production in many landscapes and continue to be supported. SAP’s target picture for new interfaces is SAP Fiori based on SAPUI5, often as Fiori Elements, where the UI is largely generated from CDS annotations.

The associated application model is the ABAP RESTful Application Programming Model (RAP). It can provide many technical functions that previously had to be developed individually for each project: validations and derived values, transactional changes with locking behavior, optional draft states that allow intermediate saving across sessions, and exposure as an OData service, either as a UI service for Fiori or as a web API for external consumers. Important for putting it in context: RAP is not a generator for Fiori services, but a transactional business object model. Besides OData, RAP objects can also be consumed locally and in a typed way (via the Entity Manipulation Language, EML) and can trigger business events. Which of these functions a specific business object uses is decided per object; drafts, for example, are optional. RAP supports both managed scenarios for new developments and unmanaged scenarios in which existing business logic is integrated.

ABAP Cloud and clean core

The most important turning point of recent years is ABAP Cloud: the development model that restricts development to released APIs and a modern scope of the language. Important to counter a common misconception: ABAP Cloud is a development model, not a hosting model; it can also be used in an on-premise system. In SAP S/4HANA Cloud Public Edition, it is mandatory; in the Private Edition and on-premise, it is available from release 2022 as developer extensibility, and additionally on SAP BTP in the ABAP environment. Technically, this is implemented through ABAP language versions: Standard ABAP for classic development, ABAP for Cloud Development for the cloud model. The goal is to reduce technical dependencies on the SAP standard and keep extensions upgrade-stable. This is not a guarantee, though: unsuitable extension points, weak architecture, or changed application behavior do not disappear through the language model.

Behind this stands the clean core architecture principle, here in relation to ABAP-based extensions: custom developments are decoupled from the standard instead of modifying it. With the 2025 Clean Core Extensibility whitepaper, SAP replaced the earlier binary view with a four-level concept. Level A covers extensions in the ABAP Cloud model or side-by-side on BTP, built on released APIs with a formal stability contract. Level B stands for classic ABAP that exclusively uses interfaces classified by SAP as classic APIs; SAP classifies such extensions in the level model as clean core and upgrade-stable, without a formal release contract as with released APIs. Level C refers to the use of unclassified SAP objects and is only justifiable with additional monitoring of the changelog. Level D, finally, noAPI objects and modifications, is not clean core and should be dismantled first. The type of interface is also relevant here: local released APIs, remote APIs, and classified classic APIs are different categories with different stability commitments.

In practice, the decision is rarely difficult for new developments, but rather where critical custom code runs into missing releases. How this can be assessed case by case is a topic of its own and would go beyond the scope of this overview.

ABAP development tools

The central development environment remains the ABAP Development Tools (ADT) based on Eclipse. In addition, the ABAP Development Tools for Visual Studio Code are now generally available, initially focused on ABAP Cloud and RAP; for comprehensive ABAP development, especially in classic programming models, SAP continues to recommend Eclipse until feature parity is reached. When it comes to AI support, it is worth distinguishing three things: the ABAP Test Cockpit can offer automated quick fixes for certain findings, including in the clean core context; Joule for Developers supports code explanation and code generation; and for custom code migration from ECC to S/4HANA, SAP provides its own agentic migration assistant. The availability and scope of functionality of these tools depend on edition, release, and licensing. Quality assurance runs through the ABAP Test Cockpit (ATC), which also supports the assessment of existing code with cloud readiness and clean core checks.

Best Practices

Four basic rules:

1. Code pushdown with a sense of proportion
CDS and ABAP SQL first; AMDP only where HANA-native functions bring real added value, because every AMDP is tied to the database and harder to test.

2. Build ATC firmly into the process
The ABAP Test Cockpit with cloud readiness and clean core checks belongs in the development and transport process as a gate. Our rule of thumb at cobicon: no transport release for ATC findings of priority 1 and 2 without a documented exception.

3. Testability from the start
Object-oriented design with interfaces and dependency injection is what makes ABAP Unit effective in the first place, and it lowers the risk of every future upgrade.

4. Assess existing code instead of migrating it across the board
Not every custom development has to move to RAP or ABAP Cloud. An analysis by usage, criticality, API availability, and clean core level separates candidates for decommissioning from candidates for modernization and tolerated legacy code.

Conclusion

ABAP is not a legacy footnote, but a platform whose recommended development model has been fundamentally renewed with CDS, RAP, and ABAP Cloud, complemented by a level concept that handles existing code in a differentiated way rather than with blanket rules.

Whether and how your own custom code takes this path, however, is not a technology decision but an architecture decision, and it deserves an assessment of the existing code rather than a blanket rule.

▷ FAQ

▷ Is ABAP still up to date?
Yes, for tightly integrated extensions of SAP S/4HANA, ABAP remains the technology SAP intends. The platform has been comprehensively modernized in recent years (modern language features, CDS, RAP, ABAP Cloud). For highly decoupled scenarios, however, side-by-side approaches on SAP BTP can be the better choice.

▷ What is the difference between ABAP and ABAP Cloud?
ABAP Cloud is not a new ABAP, but a development model with rules: it restricts development to released SAP APIs and the language version ABAP for Cloud Development, so that extensions remain as unaffected as possible by SAP upgrades. Classic ABAP (Standard ABAP) remains available alongside it and is relevant for existing scenarios.

▷ Do I need to learn SQLScript for S/4HANA?
As a rule, no. The recommended path for data-centric logic is CDS views and ABAP SQL. SQLScript is only used in special AMDP cases where HANA-native functions are needed.

▷ What does clean core mean?
Clean core is an architecture principle: custom developments are decoupled from the SAP standard instead of modifying it. Since 2025, SAP has classified extensions for this purpose into four clean core levels, from A (ABAP Cloud or side-by-side) to D (modifications and noAPI objects). Clean core is therefore not an all-or-nothing decision, but is assessed per extension. At SAP, clean core encompasses not only extensions but also processes, data, integration, and operations; this article covers the extensibility dimension.

▷ What does C1 mean?
C1 is a release contract for development objects: a class or interface released with C1 may be used in ABAP Cloud, and the owner guarantees the stability of the released interface. Customer-owned objects, such as wrappers around classic APIs, can also be released via C1 for your own cloud development.

▷ Can classic ABAP be clean core?
Yes, within limits. Under the level concept, classic ABAP reaches level B if it exclusively uses interfaces classified by SAP as classic APIs and follows SAP’s recommendations. Modifications and the use of noAPI objects (level D), on the other hand, are not clean core.

▷ Is Web Dynpro ABAP being phased out?
For new developments, Web Dynpro is generally no longer the right choice; the standard is SAP Fiori. Existing Web Dynpro applications, however, remain supported and in productive use in many landscapes.

Author: Sebastian Nötzel | Last updated: 08/05/2026