10.4 Clean Core: Definition, Benefits, the Five Principles, and Clean Core Levels
Key Takeaways
SAP defines a clean core as a system that is as close to standard as possible and runs cloud-compliant extensions and integrations built with SAP guidelines and best practices.
The five clean core principles are processes, extensions, data, integrations, and operations, each with its own mantra.
The extensions mantra is 'Decouple extensions from standard': use released APIs and the extensibility model (on-stack or side-by-side).
Clean core levels run from A (only released APIs) through B (classic APIs) and C (artifacts with a change log) to D (not clean); an extension takes the level of its least clean artifact.
Modifications, clones of standard programs, user exits, classic BAdIs, and implicit enhancements are forms of technical debt that must be governed.
Clean Core: Definition, Benefits, the Five Principles, and Clean Core Levels
The C_TS462 learning journey includes the course Introducing RISE with SAP Methodology for SAP Partners and Customers (SL_RISE419). About half of that course explains clean core, because an implementation consultant decides every day whether a requirement is solved with standard configuration, a clean extension, or a modification that will make future upgrades harder. In the system-based assessment you configure Sales in an SAP S/4HANA Cloud Private Edition system; clean core explains why the tasks use standard customizing and apps rather than custom code.
What a Clean Core Is
The course defines a clean core as a system that is as close to standard as possible, running cloud-compliant extensions and integrations that are created with standardized guidelines and best practices from SAP. Clean core does not mean "no customization". It means customization only where it adds competitive value, built in a way that does not block upgrades.
The course compares this with a new smartphone:
- Optimized out-of-the-box functionality: the standard system works efficiently in its delivered state and readily takes updates.
- Strategic customization: adding apps is fine, but excessive modifications hurt performance; customize where it differentiates the business.
- Effortless updates: a streamlined device updates easily; a clean core makes system upgrades smooth.
- Consistent long-term performance: staying close to the optimal state keeps the system reliable.
Why now? The course names transformation headwinds: markets change quickly, new technologies such as AI must be adopted, supply chains are disrupted, and customer preferences shift. A company with a heavily modified ERP cannot adapt fast enough.
Benefits for Users, IT, and the Company
The course uses the example of Gritty Pixel, a media production company with a fragmented SAP ECC system, separate non-SAP inventory and sales systems, interfaces between them, and large amounts of duplicated data.
| Stakeholder | Situation Before | Benefit of a Clean Core |
|---|---|---|
| Users | A clerk logs into several systems a day to reconcile sales, production, and purchase orders and waits for overnight batch reports that are already stale in the morning | Better decisions, faster, with higher data quality and availability in one integrated system |
| IT | Extensive custom code and complex landscapes prevent timely upgrades | Less technical debt, faster and predictable upgrades, more time for innovation instead of maintenance |
| Company | The ERP limits new business opportunities | Agility to adopt innovations, standardized processes, and the ability to scale |
The Five Clean Core Principles
Each principle has a mantra in the course:
| Principle | Mantra | What It Means in Practice |
|---|---|---|
| Processes | Keep competitiveness while reducing complexity | Adopt standard best-practice processes through fit-to-standard; govern deviations (internal variants, industry compliance, local regulations); measure KPIs such as cycle time, compliance, and automation rate |
| Extensions | Decouple extensions from standard | Use released APIs and the extensibility model (on-stack in SAP S/4HANA or side-by-side on SAP BTP); avoid modifications |
| Data | Control data according to the latest standards | Follow a data strategy that manages data quality across its lifecycle, so data stays a strategic asset |
| Integrations | Keep the landscape reliable and flexible | Define a target integration architecture with modern integration technology and released APIs, planned with the Integration Solution Advisory Methodology |
| Operations | Keep the operations effective and efficient | Run the landscape in a standardized, automated, non-disruptive way; assess maturity with SAP's Governance & Maturity Framework |
Operations is described as the ongoing discipline of running the system so that it stays clean. For RISE with SAP customers, the Operations View of the RISE with SAP Methodology Dashboard shows a system health score and KPIs calculated daily from SAP Cloud ALM metrics, with up to 30 days of history.
Extensions: Released APIs and the Clean Core Level Concept
A clean extension rests on two pillars: it uses released APIs (any ABAP repository object, such as a data element, CDS view, or class, that SAP has released and keeps stable across upgrades), and it follows the extensibility model, which places an extension either on-stack (in SAP S/4HANA) or side-by-side (on SAP BTP). Side-by-side keeps the core cleanest, but some use cases, such as implementing a BAdI, need an on-stack implementation.
For SAP Cloud ERP Private and on-premise systems, which contain existing custom code, SAP introduced the clean core level concept:
| Level | Meaning |
|---|---|
| A | Only released APIs are used. Fully clean core compliant and upgrade-stable. This is the only level permitted in SAP Cloud ERP (public edition). |
| B | Uses classic APIs: artifacts that are not formally released but are considered safe because they are highly unlikely to change. |
| C | Uses artifacts that carry some risk if they change. SAP provides a change log for them so incompatible changes can be found early. |
| D | Not clean: uses explicitly non-recommended artifacts or techniques. |
Customers should use levels A to C in that order of preference. An extension takes the level of its least clean component: an ABAP class that uses two released APIs (level A) and one classic API (level B) is a level B extension as a whole.
Technical Debt and Its Governance
The course defines technical debt as any customization that deviates from the standard, upgrade-stable SAP code base and architecture and therefore makes future maintenance and innovation more complex and expensive. It names these forms:
- Modifications to SAP standard code
- Clones of standard programs, which no longer receive SAP updates
- Old-school, tightly coupled enhancements: user exits, classic BAdIs, and implicit enhancements
Technical debt should be an informed decision that is documented and managed. The course proposes continuous governance for every new extension:
- Requirement: check whether standard SAP features or SAP Best Practices content can meet the need, and confirm the business value (for example, through a Solution Standardization Board).
- Design: choose the technical approach with clear guidelines and the SAP Application Extension Methodology, using the levels to guide architecture decisions.
- Implementation: follow development guidelines, prefer no-code or low-code options, and document technical debt transparently.
- Deployment: run mandatory checks with the ABAP Test Cockpit on transport release, with a documented exemption process.
Governance is a must for greenfield projects, and in brownfield systems every net-new development should follow the same cycle. Measuring technical debt with KPIs helps a company set realistic reduction goals.
A Sales Example: Clean Field Extension versus User Exit
Suppose the sales department wants a Sustainability Rating field on the sales order that also appears on the delivery and the invoice.
Clean approach (key-user extensibility, level A): In the Custom Fields app, create the field in the business context Sales: Sales Document and activate the business scenarios that copy it from the sales document to the delivery and to the billing document. When you publish, the system generates the database extensions, the CDS extensions, and the copy logic. Then use Adapt UI to place the field on the screen. No ABAP code is written, and the extension survives upgrades.
Classic approach (technical debt): Append the field to VBAK, LIKP, and VBRK and fill it in user exits such as USEREXIT_MOVE_FIELD_TO_VBAK in include MV45AFZZ (sales order) and in delivery and billing copy routines. User exits work directly on the program's global data, which makes errors in custom code affect standard processing and creates upgrade effort. In clean core terms, such code is technical debt and should be replaced over time, for example by released Cloud BAdIs for sales documents, which receive defined parameters and do not allow database commits.
| Aspect | Key-User Custom Field | Classic User Exit |
|---|---|---|
| Tooling | Custom Fields and Adapt UI apps | ABAP Workbench |
| Coupling | Uses released extension points | Works on internal global data |
| Upgrade impact | None expected | Must be checked after every upgrade |
| Clean core status | Clean (level A) | Technical debt (old-school enhancement) |
Tip
If an exam task asks for a new field that flows from the order to the delivery and invoice, think Custom Fields app plus business scenarios, not appends and user exits.
Which mantra does the RISE with SAP course assign to the clean core principle for extensions?
Keep competitiveness while reducing complexity
Keep the landscape reliable and flexible
Decouple extensions from standard
Control data according to the latest standards
A custom ABAP class in SAP S/4HANA Cloud Private Edition uses two released APIs and one classic API. Which clean core level applies to the class as a whole?
Level B, because the class takes the level of its least clean artifact
Level C, because classic APIs always come with a change log
Level A, because most of the APIs are released
Level D, because any non-released API makes an extension unclean
Which of the following does the course NOT list as a form of technical debt?
An implementation of a classic user exit
A custom field created with the Custom Fields app
A clone (copy) of a standard SAP program or class
A modification of SAP standard source code
Sections you finish are checked off in the contents.