To effectively perform level based development work several pieces of information are useful:
- Software components must be created and packages must be assigned thereto.
- Developer authorizations must be assigned.
- ABAP Test Cockpit Check Variants should be utilized.
- ABAP Language versions must be assigned to development objects.

To set up an SAP S/4HANA Cloud Private Edition system for level based development work, the following factors are considered:
- Initial setup
- Understanding release state, release contracts, and usage visibility
- Understanding developer authorizations
- Understanding ABAP test cockpit checks
Initial Setup
The initial setup comprises the following:
Software Component Setup
Using the report RSMAINTAIN_SWCOMPONENTS, which is available as of ABAP Platform 2022, administrators can create and configure software components. Software components created will be classified as either "ABAP Cloud" or "ABAP Classic", along with transportability (either Transportable or Local).
All objects created in a software component of the type ABAP Cloud must follow the ABAP cloud development model. By contrast, objects in software components of the type ABAP classic can be of any type. ABAP Cloud based software components effectively map to clean core level "A" and ABAP Classic based software components map to levels "B", "C" and "D" respectively.
Structure Package
To facilitate the structuring of customer software projects, a structure package should be created for each software component created by the customer.
Development Packages
Underneath the structure packages, one or more development packages (depending on individual project needs) can be created to hold all needed development artifacts.
Authorizations
There are a few authorization objects to make note of. First, for administrators setting up software components, the authorization object S_CTS_ADMI is required.
Second, if customers desire to restrict developers to level A development only, or if some developers will work in level A while others will work in levels B, C and D, then the authorization object S_ABPLNGVS can be used to design the appropriate permissions to developers. The procedure is as follows:
- Using the transaction code SACF, activate authority checks using the authorization object S_ABPLNGVS.
Create two roles. One role will be assigned to developers who are restricted to level A development only. The other will be assigned to developers who are allowed to develop in all other levels (i.e., B, C or D), if applicable to the customer. Both roles can be created by using the transaction code PFCG and by using the role SAP_BC_ABAP_DEVELOPER_5 as a template for copying. This role contains the S_ABPLNGVS authorization object.
Maintain the authorization field ABP_LNG_VS for each individual developer. For developers who will develop in level A only, the value to be maintained is ABAP For Cloud Development. For all other developers, the value is All activities (that is, levels B, C or D).
ABAP Test Cockpit Check Variants

There are several ABAP Test Cockpit check variants that a developer should be familiar with. Two of particular importance are:
- ABAP_CLOUD_DEVELOPMENT_DEFAULT
This variant can be used to confirm that your ABAP code is cloud compliant. With this check variant, basic ABAP Cloud rules can be enforced.
- ABAP_CLOUD_READINESS
This variant can be useful when checking code to see if it is "ABAP Cloud ready". It checks that only object types available in ABAP Cloud are developed, only ABAP Cloud language statements are used, and that only released SAP APIs are called. When this variant is used a worklist of ATC findings will appear detailing the issues that will need fixing. Depending on the issue "Quick Fix" functionality can be utilized to immediately adapt the code.
Setup of ATC Check Variant for Clean Core Checks
In addition to the two variants noted above customers can create a custom variant tailored to the new clean core level guidelines (i.e., Released APIs, Classic APIs, etc.) which will verify the usage of SAP standard objects based on those guidelines. When used the ATC finding will show the following:
- Released APIs: Level A: No finding in ATC.
- Classic APIs: Level B: Priority 3 (Info Message).
- Internal Objects: Level C: Priority 2 (Warning Message).
- Not Recommended: Level D: Priority 1 (Error Message).
Creating this custom variant is straightforward. Simply perform the following steps:
- Copy the ABAP_CLOUD_DEVELOPMENT_DEFAULT variant listed above into a newly named variant.
- Add to that newly named variant the following additional ATC checks:
- Allowed SAP enhancement technologies
- Usage of APIs
- Critical statements
- Search for customer modifications
- Code Vulnerability Analyzer (CVA) (if CVA is licensed accordingly)
For additional information on how ABAP development tools for Eclipse offers different capabilities to support your development tasks with clean core check out the blog: ABAP test cockpit (ATC) recommendations for governance of clean core ABAP development.
Release State, Release Contracts, and Usage Visibility

We have mentioned frequently in the course about the importance of released APIs. Clean core level A compliance requires the usage of released APIs only. As discussed earlier, software updates with cloud software happen regularly and extensions designed and implemented at level A will not encounter any disruptions for customers when upgrading .
To facilitate stability and transparency, development objects intended to be used with extension development are explicitly released and also maintained with a release contract and a use visibility. All three options are maintained simultaneously on the same screen.
The options that must be maintained are as follows:
- Release State
This parameter indicates that the development object is "released" (that is, available for usage).
- Release Contracts
- Extend (C0)
A development object that is enabled for extensibility has the release contract Extend (C0) assigned. Depending on the type of object in question, there may be additional prerequisites before extension points can be defined.
- Use System-Internally (C1)
This designation is for development objects that are used for consumption. The assignment of C1 is required for any development object used in an extension implementation if clean core level A is the goal.
- Usage Visibility
The following two options can be set for usage visibility:
- Use In Key User Apps is for released objects that are intended to be used by key user extensibility tools.
- Use In Cloud Development is for released objects that are intended to be used by on-stack developer extensibility.
- Extend (C0)
For additional information on how ABAP development tools for Eclipse offers different capabilities to support your development tasks with ABAP Cloud check out the blog: Make use of ABAP Cloud support in the ABAP development tools for Eclipse (ADT) .