Lumivara ForgeClean Core
—
Back to Clean Core Academy

Get set up

Start here

The things you set once: pick the role you're learning as, check the course is a fit, and see what you'll walk away able to do. Your progress stays pinned on the right as you go.

At a glance

What's in this course

The full scope, before you commit time — modules, lessons, hands-on exercises, and how long it runs.

Modules
17
Lessons
88
Hands-on
4
exercises
Quiz questions
264
Practice exam
1
timed mock
Readiness audit
11
checks
Est. time
14 hr 30 min
read & try
Step 1

Your role

One course, many lenses. Pick the role you're learning as — it tailors which modules you see and survives across visits.

Choose your track

One course, many lenses — filter the modules to your role.

Developers
Business & stakeholders
Step 2

What you'll learn

The concrete outcomes for your role — pick a different role above and this list re-tailors.

Across the whole course — 17 modules.

Clean Core Foundations

  • Explain Clean Core as a contract about where extensions sit — not a ban on custom code.
  • Place any object in the right extensibility tier (key-user / developer / side-by-side).
  • Describe what Restricted ABAP forbids and why compile-time enforcement matters.
  • Read an object's API State and classify it C0 / C1 / C2 / C3.
  • Reason about the software-component boundary and released interfaces.

HANA Readiness: the DB Mindset

  • Name what actually changed moving to HANA: columnar store, no implicit sort, MVCC reads.
  • Avoid the common pitfalls — ORDER BY, SELECT SINGLE without a full key, FOR ALL ENTRIES.
  • Recognise the deeper internal-table and cursor pitfalls before they cause defects.
  • Run the scope-then-fix loop: SCMON → ATC → baseline → re-run per FPS.
  • Use the Simplification Database for your target release.

ABAP Language Modernization

  • Replace obsolete statements (MOVE, header lines, FORM/PERFORM, CONCATENATE) with modern equivalents.
  • Use inline declarations and modern Open SQL (comma field lists, @DATA).
  • Apply the constructor operators: VALUE, CORRESPONDING, COND, SWITCH, REDUCE, FILTER, FOR.
  • Format output with string templates.
  • Model errors with class-based exceptions (CX_STATIC_CHECK + IF_T100_MESSAGE).

ABAP Cloud Development & RAP

  • Identify the five mandatory artefacts of a managed RAP business object.
  • Implement behaviour with a behavior pool, local handlers, and strict(2).
  • List the statements Restricted ABAP forbids in a cloud package.
  • Consume and implement released BAdIs the Clean Core way.

Released APIs & Extensibility Contracts

  • Find released objects in ADT and on api.sap.com and read their API State.
  • Map common legacy APIs to their released replacements.
  • Use the XCO library for JSON, hashing, time, and repository introspection.
  • Read released CDS interface views (I_*) instead of physical tables.

CDS, AMDP & Code Pushdown

  • Order logic on the pushdown ladder: CDS → table function/AMDP → Open SQL → ABAP.
  • Write CDS views with aggregation, associations, and correct group by.
  • Build a CDS table function backed by AMDP with explicit client handling.
  • Express row-level authorization declaratively with DCL.

Performance & SQL on HANA

  • Apply the five rules that fix most slow SQL on HANA.
  • Pick the right diagnostic tool (ST05, SAT, SQLM, SWLT, PLANVIZ).
  • Rewrite loop lookups as projected, joined, declarative reads.
  • Use hints and buffering judiciously, and avoid the rarely-documented performance pitfalls.

ATC, Custom-Code Migration & Simplification

  • Choose the right ATC variant for the job.
  • Set up local, central/remote, and CI/CD ATC topologies.
  • Create and maintain an exemption baseline so only new debt surfaces.
  • Run the full custom-code migration loop and handle the high-impact Simplification Items.

Lesser-Known Tools & Utilities

  • Adopt ABAP Cleaner and abaplint into the editor and CI.
  • Use abapGit's lesser-known features (background mode, offline repos).
  • Pick between SCMON, UPL, and SUSG for usage analysis.
  • Decouple standard-API calls with the Decoupling Cockpit and test with the double frameworks.

Common Pitfalls & Defect Patterns

  • Identify the Open SQL and internal-table pitfalls that produce silently incorrect results.
  • Avoid the RAP and CDS pitfalls (ETag, IN LOCAL MODE, #CHECK without DCL).
  • Handle the AMDP and ABAP Cloud edge cases.
  • Transport CDS/DCL/behaviour artefacts together to avoid half-working objects.

Advanced Techniques & Lesser-Known APIs

  • Use lesser-known language features (IS INSTANCE OF, CDS built-ins, SWITCH on strings).
  • Discover ADT and ATC tooling shortcuts.
  • Reach for lesser-known released APIs (GZIP, BASE64, HMAC, parallel processing).
  • Choose the right numeric types for money, counters, and timestamps.

How-To Recipes

  • Release an object for downstream consumption.
  • Run remote ATC and create a baseline.
  • Migrate FORM/PERFORM code to classes and write a CDS unit test.
  • Wire ATC into a CI/CD pipeline and write a MANDT-safe AMDP.

Capstone Scenarios

  • Sequence a 12-month custom-code migration from zero to ATC-green.
  • Build a greenfield extension released-API-first, end to end.
  • Run a performance-forensics investigation from symptom to fix.

Delivering Clean Core: People, Conflict & Cadence

  • Justify Clean Core as a managed cross-team programme, not ad-hoc cleanup.
  • Size a migration from measurable drivers and express duration as phases with exit criteria.
  • Name the team interfaces (functional, Basis, security, SAP) and run handoffs with a shared definition of done.
  • Prevent transport collisions and resolve priority friction with impersonal, pre-agreed rules.
  • Prioritise the backlog by usage × standard-impact × cost, weighted by upgrade severity.
  • Recognise the common programme issues and apply the known resolution for each.

Clean Core for Management & Leads

  • Make the business case for Clean Core in terms of upgrade cost and innovation speed.
  • Treat the 3-tier model as an investment decision.
  • Stand up governance: variant ownership, baselines, exemptions with an audit trail.
  • Frame the migration roadmap and the KPIs that track it.

Clean Core for Key & End Users

  • Explain what Clean Core means for the work key users do.
  • Use in-app (key-user) extensibility for fields, views, and logic.
  • Know what you can self-serve and when to involve a developer.
  • Keep extensions upgrade-safe and out of shadow processes.

Clean Core Orientation for Stakeholders

  • Describe Clean Core in plain language.
  • Name the five Clean Core dimensions.
  • Explain why released contracts make upgrades easier.
  • Recognise the common vocabulary and read a readiness report.
Step 3

Is this course right for you?

A quick self-check of what this course assumes — and when it isn't the right fit.

This course assumes working ABAP and walks through modernizing it toward SAP Clean Core — keeping SAP's standard system untouched and building custom needs beside it, so upgrades stay easy. You don't need a live system to read the lessons, but a sandbox makes the exercises stick.

Prerequisites — check before starting

What this journey assumes

  • ATC with the Clean Core variantsABAP_CLOUD_DEVELOPMENT_DEFAULT (with ABAP_CLEAN_CORE_DEVELOPMENT, new in 2025, grading against clean-core Levels A–D) plus the target-release S4HANA_READINESS_<year> are the authoritative checks (the course pins examples to S/4HANA 2023, so S4HANA_READINESS_2023 there); abaplint catches the style layer.

This may not be the right journey if…

  • You're looking for a beginner ABAP syntax course — this assumes you already write ABAP.
  • You want SAP functional/config training — this is a developer modernization course.
Official sources:SAP — ABAP Extensibility Guide: Clean CoreSource cookbooks — palimkarakshay/abap-utilities /docs