What each module builds

Explain Clean Core as a contract about where extensions sit, not 'no Z code'

Place any object in the right extensibility approach (key-user / developer / side-by-side) and grade its cleanliness (Levels A–D)

Name what Restricted ABAP forbids and why it protects upgrades

Read an object's API State and classify it C0/C1/C2/C3

Reason about the software-component boundary and released interfaces

Explain the five conceptual shifts HANA introduces (columnar, no implicit sort, MVCC)

Identify and fix the common HANA pitfalls (empty-driver FAE, missing ORDER BY, partial-key SELECT SINGLE)

Avoid the deep-cut internal-table and SQL traps that produce wrong results without a dump

Run a custom-code migration loop: SCMON usage scoping, ATC quality scan, exemption baseline

Use the Simplification Database and the right release-aligned ATC variant

Hunt obsolete language elements and replace them with modern equivalents

Write modern Open SQL with inline declarations and a projected field list

Apply the core constructor operators (VALUE, CORRESPONDING, COND, SWITCH, REDUCE, FILTER, FOR)

Replace CONCATENATE with formatted string templates

Choose the right class-based exception category and wire IF_T100_MESSAGE texts

Assemble the five mandatory artefacts of a managed RAP business object

Implement a behavior pool with local handlers using READ/MODIFY ENTITIES in local mode

Recognise the classic statements that are syntax errors in a Cloud Development package

Implement a released BAdI without referencing its unreleased filter values

Locate released APIs via ADT Released Objects, api.sap.com, and the API State property

Map a high-yield legacy API to its released replacement

Use the XCO library for cross-cutting concerns like JSON parsing

Read released I_* CDS views instead of selecting from underlying tables

Rank read-heavy logic on the pushdown ladder and pick the most declarative layer that fits

Write a CDS view entity with aggregation, associations and a group by that covers every non-aggregated field

Implement a CDS table function over an AMDP read method with explicit client handling and window functions

Write an AMDP write procedure with a complete USING list, explicit client filter and correct READ-ONLY use

Move authorization into the model with a DCL role and wire it to @AccessControl.authorizationCheck

Apply the five rules that fix most slow SQL: push aggregation down, project narrowly, treat FAE with care, key internal tables, drop ENDSELECT

Pick the right diagnostic tool (ST05, SAT, SQLM, SWLT, DBACOCKPIT, PLANVIZ, SCMON, SCOV, SUSG) for a given symptom

Rewrite per-row SELECT SINGLE in a loop into a single projected INNER JOIN or CDS read

Reason about %_HINTS HDB, statement rewrites over hints, ABAP buffering modes and why FAE bypasses the buffer

Avoid the rarely-documented pitfalls: FOR UPDATE locks, counter serialization, dynamic Open SQL, and silently dropped duplicate keys

Pick the right ATC variant (readiness, cloud, performance, security) and compose a team union variant with severities

Explain local vs central/remote ATC and how CI/CD invokes it through the Code Inspector API

Create and maintain an exemption baseline so ATC reports only new debt, and transport it across systems

Run the full Custom Code Migration loop from usage scoping through re-baseline each sprint

Map high-impact Simplification Items to their successor tables and bridge old reads with the released interface views (I_*) over the new model

Use ABAP Cleaner for in-ADT auto-fixes and abaplint for offline git-based linting in CI

Exploit abapGit beyond the basics: background mode, offline repos, and ATC in the stage step

Distinguish UPL, SCMON, and SUSG and time SCMON activation before a decommission decision

Apply the Decoupling Cockpit to wrap a standard internal API behind a Z-namespace boundary

Choose the right test-double framework for interfaces, CDS views, and RAP behavior

Reach for the right ADT goody or hidden t-code (source search, CDS where-used, STC01, SE95, SQVI)

Guard Open SQL against empty-driver FAE, undefined SELECT SINGLE rows, and silent de-duplication

Choose ASSIGNING vs INTO and avoid undefined BINARY SEARCH / unstable SORT in internal tables

Avoid RAP traps: dead ETags, IN LOCAL MODE auth, dropped UPDATE FIELDS, late-numbering order

Read CDS cardinality, #CHECK/DCL coupling and @Consumption layering as declarations, not guarantees

Write AMDP/ABAP Cloud that survives: READ-ONLY, full USING, SQLScript types, drifting ATC variant

Transport DCL roles, BDEFs and draft tables together so the target system isn't half-wired

Use IS INSTANCE OF, SWITCH (any comparable type, strings included), CDS let/cast and conversion built-ins for cleaner code

Drive ADT faster: command palette, ATC Quick Fix, abapGit Explorer, Open Type across ABAP+CDS

Reach for released helper APIs (gzip, base64, HMAC, URL coding, parallel) instead of hand-rolling

Know the operations touchpoints: RZ70 SLD, SE63 translation, the Release Information Note per FPS

Read the release state of a USE, the 'Replaced By' successor, and the green-light release status

Pick the right number type: DECFLOAT for money, explicit DECIMALS, INT8, UTCLONG for timestamps

Release an object as a C1 API so downstream code can consume it

Run remote ATC against a package and create a findings baseline

Refactor a FORM/PERFORM program into a class with one method per FORM

Write a CDS unit test with cl_cds_test_environment and assert results

Wire static lint and remote ATC into a CI/CD pull-request gate

Write a client-safe AMDP that filters MANDT explicitly

Design a 12-month Clean Core migration roadmap for a large legacy codebase

Architect a released-API-first RAP extension end to end with tests and ATC

Run a HANA performance-forensics path from SAT through PLANVIZ to a fix decision

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

Articulate the business case for Clean Core to a budget owner

Frame the extensibility approaches as an investment decision

Define the governance roles for variants, baselines, and exemptions

Sequence a migration roadmap from zero to ATC-green

Choose KPIs that make Clean Core progress visible

Size and fund the programme — a driver-based duration range and protected capacity

Set decision rights and pre-decide the response to the common programme issues

Explain what Clean Core means for your own daily work

Recognise what key-user (in-app) extensibility lets you do

Add custom fields and simple logic without a developer

Decide when to involve a developer and what to ask for

Keep your extensions upgrade-safe and avoid shadow processes

Define Clean Core in one plain-language sentence

Name the six Clean Core dimensions and why they span the whole solution

Explain in plain terms why upgrades get easier under Clean Core

Recognise the common Clean Core vocabulary in a conversation

Read a readiness report and focus on the trend, not the headline number