Modern SAP development is shifting from classic ABAP techniques toward the ABAP RESTful Application Programming Model (RAP). This transition affects how developers extend SAP systems, test code, and ensure upgrade stability. This comparison outlines five key areas: Extensibility, Testing, Upgrade Safety, Applicability, and Transition Path.
Classic ABAP is not disappearing, but RAP and clean core principles are clearly the direction of the future.
Extensibility: Clean Core Extensions vs Classic Customisations
In classic ABAP, extending SAP functionality often meant using modifications or user exit techniques that altered the core. Developers relied on user exits, BAdIs, or even core modifications. While powerful, these approaches tightly coupled custom code to SAP’s internal logic, creating technical debt and upgrade headaches.
RAP enforces SAP’s clean core model by requiring all extensions to remain independent of SAP’s core.
In-App (Key User) Extensibility allows adding fields, logic, or lightweight business objects directly in the system using Fiori-based tools.
Developer Extensibility (on-stack RAP) lets ABAP developers write extensions inside S/4HANA or SAP BTP using only released APIs and approved objects.
Side-by-Side Extensibility moves custom applications outside the ERP system entirely, hosted on SAP BTP and integrated through APIs or events.
Classic ABAP offered complete control at the expense of stability. RAP imposes controlled access to protect system integrity and guarantee that all extensions remain upgrade-safe.
Testing and Quality: Automated Testing vs Manual Efforts
Classic ABAP testing was mostly manual. Although ABAP Unit existed, it was rarely applied consistently. Developers typically validated functionality interactively in SE38 or SAPGUI, and integration testing relied on user intervention.
RAP promotes automated testing and structured quality control.
RAP business objects separate data, behaviour, and service layers, which simplifies the creation of ABAP Unit tests. The CDS Test Double Framework allows mocking of data sources, and Entity Manipulation Language (EML) supports direct programmatic testing of business logic.
Modern development pipelines integrate ATC and ABAP Unit checks into continuous integration. This ensures each transport meets strict code quality standards before deployment.
Testing in RAP shifts the focus from manual validation to automated assurance. It brings discipline, faster feedback, and more reliable releases compared to traditional ABAP development.
Upgrade Safety: Enforcing Clean Core Principles
Classic ABAP customisations often made upgrades complex. Enhancements and modifications had to be manually reconciled, increasing cost and risk.
RAP is designed for upgrade safety through strict development boundaries:
- Released Objects Only: RAP development allows only released APIs, CDS views, and language features. Direct table reads and unreleased function modules are blocked.
- No Core Modifications: Custom logic exists in extension layers using RAP behaviours, Cloud BAdIs, or side-by-side apps. The SAP core remains untouched.
- Stable Interfaces: RAP exposes business functionality through OData and behaviour definitions. Even if internal logic changes, the service contract remains stable.
- Upgrade Alignment: In cloud environments, SAP performs quarterly updates. RAP’s structure ensures that customer extensions survive these upgrades without disruption.
RAP eliminates the historical risks associated with upgrades. It makes stability a fundamental part of the development model.
Applicability: When to Use RAP (Cloud Mandate vs On-Premise)
SAP S/4HANA Cloud (Public Edition)
RAP is mandatory. Development occurs through ADT in Eclipse using the embedded ABAP environment. SE80 and classic user exits are unavailable.
SAP S/4HANA (On-Premise or Private Cloud)
RAP is available and recommended from S/4HANA 1909 onward. Classic ABAP tools remain usable, but new projects should be built in RAP to align with future compatibility and cloud-readiness.
SAP BTP ABAP Environment (Steampunk)
All development uses RAP. This environment supports fully decoupled, side-by-side applications that integrate with S/4HANA via released APIs.
Tooling
RAP development is performed exclusively in ABAP Development Tools (ADT). CDS views, behaviour definitions, and service bindings cannot be created or maintained in SAP GUI.
In summary:
- Cloud: RAP is mandatory.
- On-premise: RAP is strongly recommended.
- BTP: RAP is the foundation.
Transition Path: Roadmap from Classic ABAP to RAP
Transitioning to RAP requires structured upskilling and modern development practices.
- Adopt ADT (Eclipse): Move away from SE80. Learn to manage projects, packages, and version control using ABAPGit or gCTS.
- Object-Oriented ABAP: Use classes, interfaces, and modular design consistently. RAP is fully object-oriented.
- Core Data Services (CDS): Learn to model data and use annotations for UI and OData exposure.
- OData and REST Concepts: Understand how RAP publishes business objects as OData services consumed by Fiori.
- Behaviour Definition Language (BDL): Define and implement behaviour logic, validations, and actions.
- Entity Manipulation Language (EML): Call and test RAP business objects programmatically.
- Fiori Elements and UI Annotations: Learn to drive user interfaces declaratively instead of using classic screens.
- Governance: Use ATC with ABAP Cloud check variants to enforce compliance. Run Custom Code Migration tools to detect legacy risks.
- Performance: Optimise logic for HANA using CDS-based calculations instead of procedural loops.
- Clean Core Mindset: Always verify that an API or released object exists before extending. Build for upgrade resilience.
Conclusion
RAP is the modern standard for ABAP. It provides structure, testability, and upgrade safety while maintaining SAP’s core stability.
Classic ABAP gave developers total freedom. RAP delivers sustainability and predictable lifecycle management. It enforces modularity, supports continuous delivery, and aligns perfectly with SAP’s long-term S/4HANA and SAP BTP strategy.
For developers and architects, RAP is the essential next step. Those who learn it now will lead the next generation of SAP innovation with faster delivery, safer upgrades, and stronger long-term maintainability.