Clean Core Academy

The shared vocabulary the whole course rests on: what Clean Core (keeping SAP's standard untouched and building beside it, so upgrades stay easy) actually means and why it lowers upgrade cost and risk. Covers the extensibility approaches (key-user / developer / side-by-side) and the Aug-2025 clean-core compliance levels A–D, Restricted ABAP, the C0–C3 release contracts, and the software-component boundary — the mental model the rest of the academy builds on.

• New
• Intermediate
• Expert
• Admin
• Management

• 1.1What Clean Core actually meansU
• 1.2Extensibility approaches and clean-core levels (A–D)An
• 1.3Restricted ABAP — what changesAn
• 1.4Release contracts: C0 / C1 / C2 / C3An
• 1.5The software-component boundaryU

Move to S/4HANA without the silent surprises. Switching to HANA — SAP’s in-memory database — quietly changes how existing code behaves: this covers what actually changes underneath your code, the common and less-obvious pitfalls that return incorrect results without an error, and the SCMON to ATC to baseline loop that scopes and manages the migration so risks surface before go-live, not after.

• New
• Intermediate
• Admin

• 2.1What actually changed when you moved to HANAU
• 2.2Common HANA pitfallsAn
• 2.3Less-obvious pitfallsAn
• 2.4What to actually do: SCMON → ATC → baselineA
• 2.5The Simplification DatabaseU

Bring aging ABAP up to today's standard so it is cheaper to maintain and ready for the cloud. Covers the obsolete constructs to hunt and their modern replacements, inline declarations with modern Open SQL, the constructor operators worth memorizing, string templates, and the class-based exception hierarchy that Clean ABAP (SAP's official style guide) defaults to.

• New
• Intermediate

• 3.1Obsolete language elements to huntA
• 3.2Inline declarations & modern Open SQLA
• 3.3Constructor operators worth memorizingA
• 3.4String templatesA
• 3.5Class-based exceptionsU

Build new apps that survive upgrades by design, using SAP's modern approach instead of the old patterns. Covers on-stack transactional apps the Clean Core way with RAP (SAP's modern transactional programming model): the five-artefact RAP scaffold, the behavior-pool implementation pattern, the Restricted ABAP forbidden list, and the BAdI rules — including the released-spot-with-unreleased-filter trap.

• Intermediate
• Expert

• 4.1The RAP scaffoldAn
• 4.2Behavior implementation patternA
• 4.3Restricted ABAP — the forbidden listAn
• 4.4BAdIs in ABAP CloudAn

Swap fragile legacy connections for the official interfaces SAP promises to keep stable — so upgrades stop breaking your code. Covers released APIs (the official, upgrade-safe interfaces SAP supports) that replace legacy ones: where the released-objects catalog lives, the high-yield legacy-to-released replacement map, the XCO helper library, and the rule that the interface CDS view (SAP's modern data-modeling layer) — not the table — is the contract.

• Intermediate
• Expert

• 5.1Where to find released APIsU
• 5.2High-yield legacy → released replacementsA
• 5.3The XCO libraryA
• 5.4Released DDIC artefacts — read CDS, not tablesAn

Get reports and heavy calculations to run far faster by letting the database do the work. This is where Clean Core meets HANA performance using CDS (SAP's modern data-modeling layer) and AMDP (database procedures written in ABAP): the pushdown ladder, CDS patterns that compress code, CDS table functions over AMDP, AMDP write paths, and CDS access control via DCL. Push logic down to the database in the most declarative form that can express it.

• Intermediate
• Expert

• 6.1The pushdown ladderAn
• 6.2CDS patterns that compress codeA
• 6.3CDS table function + AMDPA
• 6.4AMDP write pathsAn
• 6.5CDS access control (DCL)U

Find and fix the slow programs that frustrate users and tie up the system — most of it comes down to a handful of habits. Covers the five rules that fix 80% of slow database queries, the diagnostics toolkit, the declarative-projected-joined pattern that wins, hints and buffering, and the performance pitfalls rarely written down. How to make ABAP fast on HANA’s columnar, set-oriented database.

• Intermediate
• Admin

• 7.1Five rules that fix 80% of slow SQLA
• 7.2The diagnostics toolkitU
• 7.3Declarative, projected, joinedAn
• 7.4Hints & bufferingAn
• 7.5Rarely-documented performance pitfallsAn

Measure where your custom code stands and clean it up in a controlled, repeatable way — turning a vague risk into a tracked plan. Built around ATC (SAP’s automated code-quality checker): the variants every team should know, the local/central/CI-CD topology, the exemption baseline that hides today’s debt, the full Custom Code Migration loop, and the Simplification Items with the greatest upgrade impact.

• Intermediate
• Expert
• Admin

• 8.1ATC variants every team should knowU
• 8.2ATC topology: local, central, CI/CDAn
• 8.3The exemption baselineAn
• 8.4The full Custom Code Migration loopAn
• 8.5High-impact Simplification ItemsAn

The free, underused tools that make the team faster and the cleanup cheaper — most teams already have them and don't realise it. Covers ABAP Cleaner and abaplint (automatic code tidy-up and checking), abapGit beyond the basics, the SCMON/UPL/SUSG trio that shows what code is actually used, the Decoupling Cockpit, the test-double frameworks, and the ADT (SAP's modern Eclipse-based editor) goodies and hidden t-codes seniors actually use.

• Intermediate
• Expert
• Admin

• 9.1ABAP Cleaner & abaplintU
• 9.2abapGit beyond the basicsAn
• 9.3SCMON / UPL / SUSGAn
• 9.4The Decoupling CockpitAn
• 9.5Test-double frameworksAn
• 9.6ADT goodies & hidden t-codesU

The silent defects that pass review and then cause wrong results or production incidents later — the kind of defect that erodes trust in a system. A catalogue of Open SQL, internal-table, RAP, CDS, AMDP / ABAP Cloud, and transport-topology pitfalls every team should recognise, each with the mechanism behind it so you can spot it before it ships.

• New
• Intermediate
• Expert

• 10.1Open SQL pitfallsAn
• 10.2Internal-table pitfallsAn
• 10.3RAP pitfallsAn
• 10.4CDS pitfallsAn
• 10.5AMDP & ABAP Cloud pitfallsAn
• 10.6Transport & topology pitfallsAn

Small, high-leverage techniques that save real time and prevent quiet correctness bugs — the things experienced developers wish they’d known sooner. Modern language features, ADT (SAP’s modern editor) tooling shortcuts, released helper classes you’d otherwise implement by hand, the operations touchpoints, the subtler Clean Core release mechanics, and the numeric types that quietly decide whether money adds up.

• New
• Intermediate
• Expert
• Admin

• 11.1Lesser-known language featuresU
• 11.2ADT productivity featuresU
• 11.3Lesser-known released APIsU
• 11.4Operations touchpointsU
• 11.5Subtle Clean Core mechanicsAn
• 11.6Numeric-type pitfallsAn

Six common modernization jobs, broken into ordered, repeatable steps a developer can follow start to finish. Each recipe is a procedure a senior ABAP developer runs by hand: release an object as a stable interface, run a code-quality scan and baseline it, convert old procedural code into classes, add an automated test for a data model, gate a delivery pipeline on quality checks, and write a multi-tenant-safe database procedure. The rationale is in the prose; the ordered steps are in the key points.

• New
• Intermediate
• Admin

• 12.1Release an object for downstream consumptionA
• 12.2Run remote ATC and create a baselineA
• 12.3Migrate FORM/PERFORM to classesA
• 12.4Write a CDS unit testA
• 12.5ATC in a CI/CD pipelineA
• 12.6Write an AMDP that respects MANDTA

Put it all together on three realistic, end-to-end scenarios — the kind of judgement calls a lead or architect makes on a real programme. The capstones cover planning a 12-month Clean Core roadmap for a 4M-LOC codebase, building a released-API-first RAP (SAP's modern programming model) extension from scratch, and tracing a HANA performance regression to a defensible fix. The quizzes test sequencing, tool choice, and decision-making.

• Expert
• Management

• 14.1Capstone A — From 0 to ATC-greenC
• 14.2Capstone B — Released-API-first new developmentC
• 14.3Capstone C — Performance forensicsE

How to actually run a Clean Core programme to completion — the people, planning, and conflict side that decides whether the technical work lands. Sitting over modules 8 and 13, it covers why this needs deliberate project management, how long it takes and what drives that, how to collaborate across teams, how to resolve transport and priority conflicts, how to prioritise the backlog, and the issues every programme hits — with the move that resolves each.

• Intermediate
• Expert
• Admin

• 14.1Why Clean Core delivery has to be managedU
• 14.2How long, and what drives itAn
• 14.3Collaborating across teamsAn
• 14.4Conflicts: transport collisions and team frictionAn
• 14.5Prioritising the backlogAn
• 14.6The issues you'll hit, and the resolution playbookE

Clean Core for decision-makers: why it lowers the cost of change, how the extensibility approaches are really an investment choice, who owns governance, the roadmap from zero to a clean bill of health, the KPIs that prove you are getting there, and how to size, fund, and steer the programme — duration, decision rights, conflict, and the issues to expect.

• Management

• M.1The business case for Clean CoreU
• M.2Extensibility approaches as an investment decisionAn
• M.3Governance: variants, baselines, exemptions, ownershipAn
• M.4The migration roadmap (0 → ATC-green)An
• M.5Measuring progress (KPIs)An
• M.6How long, what it costs, and how to staff itAn
• M.7Running the programme: decision rights, conflict, and issuesAn

Clean Core for the people who use and configure SAP every day: why the in-app tools keep your changes safe through upgrades, what you can build yourself, when to bring in a developer, and how to avoid the shadow spreadsheets and workarounds that quietly break.

• Key users

• K.1What Clean Core means for youU
• K.2Key-user (in-app) extensibilityU
• K.3Custom fields & logic without a developerA
• K.4When to involve a developer (and what to ask for)An
• K.5Staying upgrade-safeAn

A plain-language orientation to Clean Core for anyone who needs to follow the conversation: what it is, the six dimensions it spans, why it makes upgrades easier, the vocabulary everyone keeps using, and how to read a readiness report without a technical background.

• Stakeholders
• Management
• Key users

• O.1What is Clean Core? (plain language)U
• O.2The six Clean Core dimensionsU
• O.3Why upgrades get easierU
• O.4The vocabulary everyone keeps using (glossary)R
• O.5How to read a readiness reportAn