RISE with SAP and Clean Core, Part 2 of 3: The Four-Level Extensibility Model Explained

RISE with SAP and Clean Core, Part 2 of 3: The Four-Level Extensibility Model Explained

The first part of this series covered RISE with SAP as a methodology: how it evolved from a sales package into a transformation framework, and why clean core sits at the center of that framework rather than beside it. This second part goes under the hood of one of clean core’s five principles, extensibility: how SAP now classifies a piece of custom code as clean or not, what separates a released API from a BAdI or a user exit in practice, how to decide whether an extension belongs on-stack or side-by-side, and the KPIs SAP recommends for measuring whether this piece of a clean core strategy is actually working. The third and final part covers the other four principles: business processes, data, integration, and operations.

Analysis | ~17 min read | By J. Torre

In brief

  • SAP replaced its original three-tier extensibility model with a four-level system (A through D) in 2025. The change responded to a practical complaint: under the old model, most non-greenfield customers found their entire codebase classified as “classic ABAP,” which made progress impossible to measure.
  • Each level maps to a specific category of SAP object and to a specific ABAP Test Cockpit (ATC) finding: Level A produces no finding, Level B an informational message, Level C a warning, and Level D an error.
  • User exits, classic BAdIs, and implicit enhancements — the techniques ABAP developers have relied on for two decades — mostly fall into Level B or lower, not automatically into Level D. The distinction that matters is whether the underlying SAP object is a released API, a classic API, an internal object, or explicitly unsupported.
  • The choice between on-stack and side-by-side extensibility is a technical decision, not just a governance preference: it depends on whether the extension needs transactional consistency with SAP standard tables and how tightly it must be coupled to the core.
  • SAP recommends tracking four extensibility KPIs — clean core share, technical debt score, unused code share, and business modifications — and watching their trend across releases, not just their value at any one point in time.

Why “clean” needed a more precise definition

For roughly three years, SAP described extensibility using a three-tier model: extensions built on released APIs sat at the top, everything else fell into an undifferentiated “classic ABAP” bucket. The model was simple to explain, but it turned out to be nearly useless for the customers it was supposed to help. Organizations that hadn’t started from a greenfield SAP S/4HANA Cloud deployment — which is to say, most enterprise customers with years of accumulated ABAP customization — found that nearly all of their existing custom code landed in that same bottom bucket, whether it used a well-documented BAPI or a direct write to an internal table. There was no way to tell which parts of the backlog were low-risk and which were genuinely dangerous going into an upgrade.

In August 2025, SAP replaced the three-tier model with what it calls the clean core level concept: a four-grade classification, Level A through Level D, based on which category of SAP object an extension touches and how it is built. The change did not relax the underlying goal — SAP still wants customers extending through released APIs wherever possible — but it gave the goal a scale that responds to gradual improvement instead of an all-or-nothing verdict. A migration team can now say “we moved forty objects from Level D to Level C last sprint,” which is a very different kind of statement than “we’re still on classic ABAP.”

The four clean core levels

Each level corresponds to a category of SAP object, and each has a matching behavior in the ABAP Test Cockpit, the automated tool SAP recommends running against custom code before every upgrade.

Level A — Extend with released APIs. Level A is reserved for extensions built exclusively on SAP objects and extension points that are officially released and governed by a documented stability contract. This includes both side-by-side extensions built on SAP Business AI Platform (through SAP Build, using either the Cloud Application Programming Model or ABAP Cloud) and on-stack extensions built directly within the ERP core using the ABAP Cloud development model. Released interfaces at this level are discoverable through the SAP Business Accelerator Hub and the Cloudification Repository, and they carry SAP’s guarantee that the interface won’t break in a way that isn’t documented in advance. An ATC scan against a pure Level A extension produces no finding at all.

Level B — Use classic APIs. Level B covers extensions that rely on objects SAP has designated “classic APIs” — interfaces and extension points that aren’t covered by a formal stability contract but have been explicitly nominated by SAP’s own product experts as safe, well-documented, and broadly recommended. This is where most of the extensibility techniques ABAP developers have used for years actually live: BAPIs, established user exits, classic BAdIs, and frameworks like SAP GUI’s ABAP List Viewer grid (built on classes such as CL_GUI_ALV_GRID) are explicitly nominated as classic APIs and are findable in the Cloudification Repository. An ATC scan flags Level B usage as a low-priority informational message, not a warning or an error.

Level C — Conditionally clean, internal objects. Level C covers extensions that reach into SAP-internal objects: things SAP hasn’t declared released, recommended, or cloud-ready, but also hasn’t explicitly forbidden. There’s no guaranteed documentation and no promise of long-term stability, but SAP acknowledges the pattern is common, especially in legacy code, and has introduced a “changelog for SAP objects” that lets customers check whether an internal object they depend on has changed incompatibly between releases. A worked example from SAP’s practitioner community illustrates the boundary clearly: a custom report that runs SELECT kunnr, name1 FROM kna1 — a direct read of the internal standard table KNA1 — classifies as Level C and produces an ATC warning. Rewriting the same logic against the released CDS view I_Customer (SELECT Customer, CustomerName FROM I_Customer) turns the identical business logic into a Level A extension with no ATC finding at all. The data being read doesn’t change; the interface used to reach it does.

Level D — Not-recommended extensions. Level D covers SAP objects explicitly classified as unfit for customer use (marked “noAPI” in the Cloudification Repository), direct modifications to SAP standard code outside of any extension point, and specific patterns SAP has flagged as risky, such as write access to SAP standard tables or implicit enhancements. A commonly cited example is the function module RFC_READ_TABLE, which is explicitly marked noAPI in the Cloudification Repository — not just because it’s unsupported, but because of documented security concerns around exposing arbitrary table reads. Level D extensions produce a priority-one ATC error and represent the extensions most likely to break during an upgrade without warning.

Two details of the model matter beyond the four definitions themselves. First, an extension is graded by its weakest link: if a single extension combines Level A technologies with one Level C dependency, the whole extension is classified as Level C, not partially A and partially C. Second, Level C is explicitly transitional rather than a stable resting point — SAP describes it as “conditionally clean,” and an object sitting there today is expected to eventually move toward Level B (if SAP formally recommends the object) or get flagged toward Level D (if SAP decides against it). Leaving a large population of custom code parked indefinitely at Level C defers a decision rather than making one.

What the old enhancement techniques actually are

Part one of this series mentioned that clean core extensibility means moving away from “old-school” techniques — user exits, classic BAdIs, and implicit enhancements — without spelling out what those terms mean mechanically. It’s worth being precise here, because the four-level model doesn’t ban these techniques outright; it classifies them.

A user exit is a predefined subroutine SAP built directly into a standard program at a specific point, intended for customers to insert custom logic without modifying the surrounding standard code. User exits are old — many originated in SAP R/3 — and their scope is fixed at wherever SAP placed the exit; there’s no flexibility to define new extension points. A classic BAdI (Business Add-In) is a more structured successor: an interface-based extension point that lets multiple customers and partners implement custom logic against the same enhancement spot without conflicting with each other, using SAP’s own object-oriented enhancement framework. Classic BAdIs are more disciplined than user exits, but they’re still tied to wherever SAP originally defined the enhancement spot in the standard code. An implicit enhancement is different in kind: rather than plugging into a point SAP explicitly designed for extension, it inserts custom code directly before or after a line inside a standard program, using a generic enhancement framework that works almost anywhere in the codebase. Implicit enhancements are the least disciplined of the three, because they aren’t tied to a location SAP vetted for extensibility — they can be inserted almost arbitrarily deep inside standard logic.

Under the four-level model, a well-established, SAP-nominated classic BAdI generally lands at Level B: it’s a documented, broadly recommended technique even without a formal stability contract. An older or narrowly-scoped user exit that hasn’t been explicitly nominated as a classic API may land at Level C. Implicit enhancements are called out by name in SAP’s own materials as a Level D pattern, precisely because they aren’t anchored to a defined, SAP-sanctioned extension point — the framework lets a developer insert code almost anywhere, which is exactly the property that makes it dangerous during an upgrade. The practical implication is that “stop using user exits” is not quite the right instruction; the more accurate one is “check whether the specific user exit or BAdI you’re using has been nominated as a classic API, and if it hasn’t, treat it as technical debt to be prioritized.”

On-stack or side-by-side: how the decision actually gets made

SAP Cloud ERP Private customers extending their systems choose, for each requirement, between two architectural approaches.

On-stack extensibility — building within the ERP core itself, generally via the ABAP Cloud development model — is the right fit when an extension needs to operate in close proximity to SAP S/4HANA data, transactions, or applications. SAP’s own guidance points to several concrete signals: the extension needs transactional consistency, meaning it updates SAP standard and custom tables or fields together within a single logical unit of work; it reads high volumes of data requiring complex SQL joins that would be inefficient across a network boundary; it accesses and changes SAP standard data frequently enough that round-trips to an external system would be costly; or it adapts an existing SAP Cloud ERP Private application directly, such as a UI adaptation or a custom field on a standard screen.

Side-by-side extensibility — building on SAP Business AI Platform, loosely coupled to the ERP core — fits the opposite profile: stand-alone applications or new process steps that can run independently, where the custom data doesn’t need transactional consistency with SAP standard tables; a need to use programming languages and skill sets beyond ABAP, such as Java, JavaScript, or open-source libraries; applications serving external users who don’t have an SAP Cloud ERP Private account; or a need for independent scaling, deployment, and release cycles that don’t follow the ERP system’s own upgrade calendar.

In practice, many real extensions combine both: a side-by-side application might expose a custom remote API or event that an on-stack extension consumes to trigger a process inside the core, or an on-stack extension might expose a released local API that a side-by-side mobile app consumes for its UI. SAP calls this the “best of both worlds” pattern, and it’s common enough that treating on-stack and side-by-side as a binary choice for an entire project, rather than a decision made extension-by-extension or even component-by-component within a single extension, usually produces a worse architecture than necessary.

Measuring progress: the four extensibility KPIs

Clean core levels classify individual objects; the KPIs SAP recommends are what let a governance body like the Solution Standardization Board (introduced in part one of this series) track whether the system as a whole is moving in the right direction.

Clean core share classifies every custom code object according to its weakest reference level and reports the resulting distribution — for example, Level A: 10% of objects, Level B: 50%, Level C: 35%, Level D: 5%. It’s a portfolio-level view rather than an object-level one, and it’s most useful for spotting whether the proportion of Level D objects is shrinking release over release.

Technical debt score is more granular and more actionable. It’s calculated per object as a weighted sum of ATC findings: SAP’s recommended weighting assigns 10 points per error-level finding, 5 points per warning, and 1 point per informational message. An object with 5 errors, 20 warnings, and 10 informational findings scores 5×10 + 20×5 + 10×1 = 160 points. Aggregating this score across a development package identifies exactly where the largest concentration of technical debt sits, rather than treating all custom code as equally risky.

Unused code share measures the proportion of custom objects that aren’t actually being called in production, using SAP’s ABAP Call Monitor (transaction SCMON) and the SUSG transaction for aggregating usage data over time. If 300 of 1,000 custom objects show no usage, the unused code share is 30%. Since every custom object — used or not — is a candidate for technical debt, this KPI identifies straightforward cleanup opportunities that don’t require any remediation work, only deletion.

Business modifications count direct changes to SAP standard code made outside of any extension point, logged in the SMODILOG table. Because modifications by definition don’t go through a sanctioned extension mechanism, they carry the highest upgrade risk of anything the KPI set measures, and SAP’s guidance is explicit that this number should trend toward zero rather than simply staying flat.

SAP has been direct that the more useful signal from these KPIs is their trajectory across releases rather than their absolute value at a single point in time. A shrinking Level D share release over release indicates the governance process is working; a Level D count that stays flat or grows while a team reports “remediation progress” on paper suggests new technical debt is entering faster than old debt is being resolved — worth watching closely given that the same automated tooling that accelerates legitimate development (AI-assisted ABAP generation among the newer entrants) can just as easily accelerate the accumulation of ungoverned Level C and D code if it isn’t checked against these same criteria before release.

Stay Clean and Get Clean

SAP frames the operational side of clean core as two complementary patterns rather than a single process. Stay Clean is preventative: before any new extension gets built, the requirement goes through a rigorous check — can this be met with standard SAP functionality or configuration instead of custom code, does it have a genuine business case, and does the proposed architecture route through the SAP Application Extension Methodology so the same governed decision-making applies consistently across teams. During implementation, this gets backed up by authorization checks and automated ATC scans; during deployment, only code that has passed those quality checks moves into production. Get Clean addresses the debt that already exists: measuring the four KPIs above to find where the worst technical debt concentrates, applying what SAP calls the “boy scout principle” — leaving code cleaner than a developer found it during any modification, factored into project time estimates rather than treated as free extra work — and setting deliberately realistic (not “100% clean overnight”) reduction targets for legacy technical debt.

The distinction matters because a Clean Core report — a one-time assessment of where a system’s custom code currently sits across the four levels — only describes the present state. It says nothing about whether next quarter’s development will add more Level D objects than this quarter’s remediation removed. Practitioners who work with these programs regularly note that a static report tends to create a periodic cleanup exercise rather than an actual operating discipline; the KPIs and the Stay Clean/Get Clean patterns exist specifically to convert clean core from a one-time inspection into a continuous practice embedded in how new requirements get approved, specified, built, and released.

Why the timeline matters

Clean core discipline has a concrete deadline attached to it, separate from any individual customer’s own transformation schedule. SAP has confirmed that mainstream maintenance for SAP Business Suite 7 core applications — SAP ERP 6.0, SAP CRM 7.0, SAP SCM 7.0, SAP SRM 7.0, and SAP Business Suite powered by SAP HANA — ends at the end of 2027, with an optional extended maintenance window, at a two-percentage-point premium on the maintenance fee, running through the end of 2030. Customers who haven’t converted by 2028 either pay that premium for three more years or move to customer-specific maintenance arrangements outside SAP’s standard support. That fixed horizon is a large part of why customers are running migration, extension remediation, and clean core governance work in parallel rather than sequentially, and it’s part of why the RISE with SAP Methodology (covered in part one) bundles a Clean Core Success Plan into onboarding rather than treating it as an optional add-on.

What the SAP ecosystem is saying

SAP’s own materials present the shift from the three-tier model to the four-level concept as an unambiguous improvement, and on the narrow question of measurability, independent practitioner commentary generally agrees. One ABAP-focused technical blog that has tracked SAP’s extensibility guidance closely described the old three-tier model as too coarse for anything but greenfield deployments, since most existing customers found their entire codebase landing in the same undifferentiated bucket — and credited the new A-through-D scale with making incremental progress measurable for the first time, while cautioning that Level C remains a genuinely undefined middle ground that customers still need to actively track rather than ignore.

A separate piece from a practitioner who has since built a commercial classification tool around the new model makes a related but more operational point: understanding the four-level concept is straightforward, but manually grading thousands of existing custom objects against it, across a codebase that has grown over a decade or more, is still largely manual work today. The ABAP Test Cockpit flags individual objects, and the Cloudification Repository documents which SAP objects are released, but turning that raw output into a prioritized, per-object remediation backlog remains a project in itself rather than something the tooling does automatically end to end.

A third perspective, from a vendor selling AI-assisted ABAP development tooling raises a more forward-looking concern: AI code generation tools are now writing ABAP fast enough that the traditional constraint on technical debt creation (the fact that a human had to write, review, and test every line) is loosening, and first-pass AI-generated ABAP commonly still depends on internal or unsupported SAP objects unless clean core criteria are checked before the code is accepted, not just after. The underlying observation — that governance checks placed only at the end of a development cycle catch problems later and more expensively than checks placed at the point code is generated — is consistent with what SAP’s own Stay Clean pattern already recommends, and doesn’t depend on any particular tool to be true.

One principle of five

Taken together, the two parts of this series so far describe a fairly coherent picture of clean core’s extensibility principle: RISE with SAP evolved from a bundled sales package into the methodology and governance framework for a cloud transformation, and clean core’s extensibility rules are the architectural discipline that framework exists to enforce for custom code specifically — not as an abstract principle, but as a four-level classification system with a defined ATC behavior at each level, a documented decision process for on-stack versus side-by-side extensions, four measurable KPIs with explicit calculation methods, and a fixed maintenance deadline that gives the whole effort a real timeline rather than an open-ended one. None of this guarantees that any individual transformation goes smoothly — the independent survey data cited in part one showed real gaps between what SAP’s methodology promises and what customers report experiencing in practice — but the mechanics themselves are considerably more concrete, and more checkable, than “keep the core clean” as a slogan would suggest on its own.

Extensibility is also only one of clean core’s five principles. The third and final part of this series covers the other four — business processes, data, integration, and operations — and the single measurement framework SAP uses to score all five together.

Sources

SAP White Paper: Clean core extensibility for SAP S/4HANA Cloud

ABAP Test Cockpit (ATC) recommendations for governance of clean core ABAP development | SAP Community

Clean Core Levels A-D: how to classify your custom ABAP | SAP Community

ABAP Cloud – Clean Core Level Concept | Software-Heroes

Maintenance Strategy: SAP S/4HANA and SAP Business Suite 7 | SAP Support Portal

SAP Clean Core: A Continuous Practice, Not a Report | AiFA Labs