Free for the SAP Community · Clean Core & ABAP Transformation

The SAP Architect's Clean Core Accelerator

Generate the first Clean-Core-compliant draft for review and approval — grounded in SAP's own published object data, with the limits named before you upload, and the expert's judgment never replaced.

Quick Answer

Clean-Core.io accelerates Clean Core modernization — it speeds the work up for you, it doesn't blindly automate it. A deterministic engine parses your custom ABAP (classes, reports, custom tables) with deterministic static (token- and rule-based) and data-flow analysis, then maps direct database reads (e.g. VBAK, BSEG) to released successor APIs using SAP's official Cloudification Repository — the same source behind the SAP ABAP Test Cockpit (ATC) — plus hand-curated field-level mappings. Tightly-coupled logic is drafted into cloud-compliant SAP Business Technology Platform (BTP) Cloud Application Programming Model (CAP) services or in-app RESTful Application Programming Model (RAP) components for you to review. Every finding is evidence-backed and traceable — and frozen into a signed, exportable audit evidence pack, so you get a faster first draft and a defensible decision trail with an architect always in the loop.

Three Worked Examples

See a real ABAP program transformed

Three example programs, end to end: what each one is, what it does as a process, and what the engine turns it into. Every output below is a real transformation — verified, compiled and tested against Clean-Core Engine v2.7.0. Your own code goes through the same seven steps.

Business Context

A sales operations team needs to query open standard orders (type 'OR') from SAP to populate a real-time order fulfillment dashboard. The legacy ABAP directly reads the VBAK database table — a non-released internal structure that breaks during S/4HANA upgrades. The engine transforms this into a clean CDS view consuming the released I_SalesOrder API, preserving the exact filter logic while making it upgrade-safe and unit-testable.

What it does·Order-to-Cash · Order FulfilmentBPMN 2.0 · generated in stage 4
  1. Dashboard requests open ordersSystemStart
  2. Read sales order headersSystemService task
  3. Order type = OR?SystemGateway
  4. Collect open ordersSystemService task
  5. Dashboard populatedSales OperationsEnd
Legacy ABAP Input
Z_LEGACY_ORDERS.abap
" Direct table read — violates Clean Core
SELECT vbeln, erdat, netwr
  FROM vbak
  INTO TABLE @DATA(lt_orders)
  WHERE auart = 'OR'.
Generated RAP Output
ZI_SalesOrderCustom.cds
define view entity ZI_SalesOrderCustom
  as select from I_SalesOrder
{
  key SalesOrder      as SalesOrderNumber,
      CreationDate    as OrderDate,
      TotalNetAmount  as NetAmount
}
where SalesOrderType = 'OR';
Generated ABAP-Unit Test
ltcl_sales_order.abap
CLASS ltcl_sales_order DEFINITION FINAL FOR TESTING
  DURATION SHORT RISK LEVEL HARMLESS.
  PRIVATE SECTION.
    CLASS-DATA environment TYPE REF TO if_cds_test_environment.
    CLASS-METHODS class_setup.
    CLASS-METHODS class_teardown.
    METHODS test_order_filter FOR TESTING.
ENDCLASS.

CLASS ltcl_sales_order IMPLEMENTATION.
  METHOD class_setup.
    environment = cl_cds_test_environment=>create( i_for_entity = 'ZI_SALESORDERCUSTOM' ).
  ENDMETHOD.
  METHOD class_teardown.
    environment->destroy( ).
  ENDMETHOD.
  METHOD test_order_filter.
    " Arrange — insert test double data
    DATA lt_mock TYPE STANDARD TABLE OF I_SalesOrder.
    lt_mock = VALUE #(
      ( SalesOrder = '100' SalesOrderType = 'OR' )
      ( SalesOrder = '200' SalesOrderType = 'RE' ) ).
    environment->insert_test_data( i_data = lt_mock ).

    " Act — read via CDS projection
    DATA lt_result TYPE STANDARD TABLE OF ZI_SalesOrderCustom.
    SELECT * FROM ZI_SalesOrderCustom
      INTO TABLE @lt_result.

    " Assert — only type OR should pass the filter
    cl_abap_unit_assert=>assert_equals( act = lines( lt_result ) exp = 1 ).
  ENDMETHOD.
ENDCLASS.
Parser Insight

Table VBAK → Resolved to released API I_SalesOrder (SAP API Business Hub).

Deterministic object match — verify semantics
CDS test environment created
1 of 1 unit tests passed
Verified against Clean-Core Engine v2.7.0 · August 27, 2026
The Seven Steps

How a transformation actually runs

Upload, analyze, design, transform, test, document, deliver. Each step produces something you can read and check before the next one starts — and an architect signs the result, not the tool.

The Clean-Core Process

Deep Code Intelligence

Legacy ABAP is analyzed in seconds. Business rules, dependencies, and Clean Core compliance scores are extracted fully automatically.

Clean-Core.io Deep Code Intelligence dashboard analyzing legacy SAP ABAP custom code, showing dependency graphs, business rules, and Clean Core compliance score.
One Reproducible Run

Nobody can say what this program does

Somewhere in your S/4HANA transformation a Z-object is blocking a keep, adapt or retire decision, because nobody can answer “do we still need this?” — so the row sits in the spreadsheet until the upgrade date makes it an emergency. Every custom code tool will size the work; none of them tells the business what the work is. This one answers both, with the limits published before you upload anything.

“Do we still need this program?”

What the run answers

“Checks open orders against the customer’s credit limit and blocks delivery when it is exceeded.”

Written by hand from the reference program we publish; your own upload is where the generator writes it. Download it and check the sentence.

And one call only the business can make

Credit Management Custom Logic · line 401

Evaluate if SAP FSCM / Advanced Credit Management (F1007) covers this use case. If standard coverage is insufficient, implement remaining gap as a Side-by-Side microservice on SAP BTP.

Produced by the run, quoted unedited — not written for this page.

With it come the process as BPMN 2.0, the operating procedure, who owns each step, and what the code is still worth. No technical terms: the generator is forbidden them.

“What will it cost us to move it?”

On the 907-line reference program we publish — 42 findings, split three ways:

Points at a released SAP successor — SAP’s own where it names one, the curated mapping otherwise. The finding says which. You review it; you do not have to find it.
Transformable, but somebody has to weigh business intent against the target design. The tool shows the evidence and stops.
Out of reach for any generator. Flagged and isolated rather than guessed at, so nothing false reaches your draft.

SAP’s own naming, from its published release data

  • KNA1I_CUSTOMER
  • KNB1I_CUSTOMERCOMPANY
  • MARAI_PRODUCT
  • MARDI_PRODUCTSTORAGELOCATIONBASIC
  • VBAKI_SALESDOCUMENT
  • VBAPI_SALESDOCUMENTITEM
  • … and 4 with no released path, named rather than guessed at.
  • These are the successors SAP’s release data names. The run may hand a developer a narrower target where a curated field-level mapping is the more practical one — each finding carries which of the two it came from.

Every tool in this market hands IT a longer list. This one closes the rows nobody could decide.

Complements Your SAP Toolchain

How we complement your SAP tools

The SAP ABAP Test Cockpit (ATC) is the authoritative check for Clean Core violations — keep using it. Clean-Core.io picks up from there: it maps each finding against SAP's Cloudification Repository and drafts BTP or RAP scaffolding for you to review, then validate back in your ABAP Development Tools (ADT) and ATC.

32,103 classified SAP objects · Auto-synced from SAP's official repository

Clean Core Violation Scanning

SAP Native ToolingStatic Check

Identifies unreleased APIs & direct database reads.

vs
clean-core.ioAutomated

Calculates Local Compliance score & prioritizes packages.

Developer HUD & Feedback

SAP Native ToolingStatic Logs

Requires manually parsing warning lists or waiting for PDF consulting reports.

vs
clean-core.ioInteractive

Visualizes compliance scores, code-minimap heatmaps, and developer checklists in real-time.

SAP Object Successor Mapping

SAP Native ToolingATC Flags Only

SAP ATC flags unreleased API usage but doesn't resolve to successors.

vs
clean-core.ioResolved + Synced

Maps against SAP's official Cloudification Repository (32,103 objects) with curated field-level precision. Auto-synced weekly.

Code Refactoring (Remediation)

SAP Native ToolingManual Only

Developers must rewrite legacy code from scratch.

vs
clean-core.ioRefactored

Converts legacy statements into BTP CAP Node.js/RAP syntax.

Sandbox Verification (BYOT)

SAP Native ToolingNot Available

Requires separate manual testing frameworks.

vs
clean-core.ioValidated

Runs test suites against your S/4HANA sandbox via encrypted, read-only connection. Never targets production.

Business Process Blueprinting

SAP Native ToolingNot Available

No process flow visualization available.

vs
clean-core.ioVisualized

Generates Business Process Model and Notation (BPMN 2.0) flows directly from custom code analysis.

Live Today

What you can do today

Every feature listed here is live and free to use — start with 5 transformations or bring your own API key for unlimited access.

Extensibility Routing & Sign-Off

Classifies legacy custom logic against SAP Clean Core guidelines, routes between In-App RAP and Side-by-Side CAP tracks, and gates transformation behind an explicit architecture decision.

Learn more

SAP Cloudification Catalog

Maps legacy objects against SAP's official Cloudification Repository — the same source behind SAP ATC checks — layered with curated field-level mappings. Weekly auto-synced, versioned, and audit-traceable.

Learn more

Dual RAP & CAP Engine

Generates clean In-App ABAP Cloud RAP handlers or decoupled BTP CAP services. Powered by a deterministic evidence resolver that linearizes OO inheritance chains before translation, reducing structural AI hallucinations.

Learn more

Modernization AssessmentNEW

Computes complexity and business-criticality scores, extracts a full code inventory, and maps data coupling with standard SAP table risk analysis — all before transformation.

Learn more

Compliance & Audit Evidence

Visual compliance dashboard with exportable audit pack: input fingerprints, architecture decision records, model cards, and known limitations — ready for governance reviews.

Learn more

BPMN 2.0 & Business Standard Operating Procedures

Maps modernized processes into standard BPMN 2.0 XML with swimlanes. Features a two-stage blueprint layer with Responsible-Accountable-Consulted-Informed (RACI) matrices, Level 5 Standard Operating Procedure (SOP) narratives, and internal compliance controls.

Learn more
Sovereign & Secured

Your data stays yours

European hosting, designed to support GDPR-aligned processing and erasure workflows, with self-service data erasure control. We built the security architecture the way we'd want it for our own SAP systems.

Belgium Hosting (Europe)

Application storage and primary processing run in the europe-west1 GCP region (Belgium); AI and transactional-email subprocessors are disclosed separately.

DSGVO / GDPR-aligned

Art. 17 DSGVO erasure: purge all your uploads and data in Settings. Transactional emails are routed via the Resend API; subprocessors process data under their own terms.

Cloud-Native Security

Runs on Google Cloud Run with server-side encryption and stateless request handling — no persistent local data on the request path. Processing happens in managed, ephemeral containers.

Hardened Stateless APIs

Your BYOK API credentials are encrypted in transit, proxied securely server-side, and never trained or exposed to public LLM builders.

100% Free — No Credit Card Required

Community access

Every feature is included for free — no locked exports, no premium tiers. The only limit is 5 transformations; bring your own Gemini API key for unlimited runs. Both are 100 % free.

Free to use

Free for the SAP community — 5 transformations at no cost, or bring your own Gemini key (BYOK) for unlimited runs under your own terms.

Built on open standards & open data

Our object catalog is grounded in SAP’s Apache-2.0 Cloudification Repository, and your output is portable — standard abapGit and tests. You own what you generate. No lock-in.

Transparent by design

Every finding is tied to evidence and a source; coverage is shown per object — including the honest cases where there is no clean path. Belegt, nicht behauptet.

A complement, not a replacement

We accelerate the first assessment and draft. The architecture decisions — and the judgment — stay with you. An independent product, not affiliated with or endorsed by SAP SE.

Free Community Edition

No API key needed
Free5 transformations

Register with name and email — your workspace is live straight away.

  • Full 7-stage modernization workflow — every feature included
  • Up to 5 ABAP-to-Cloud transformations (RAP / CAP)
  • Deterministic evidence engine + compliance & criticality scoring
  • SAP API Business Hub mapping & Clean Core routing
  • abapGit ZIP export, ABAP-Unit tests, BPMN & Confluence exports
  • Server-signed audit evidence pack
Unlimited · Free

Free + Your Own Key

BYOK
FreeUnlimited transformations

Bring your own Google Gemini API key — encrypted and stored securely.

  • Everything in the Free Community Edition — no features locked
  • Unlimited code transformations (via BYOK)*
  • Live S/4HANA sandbox connection (encrypted, read-only, admin-gated)
  • Ideal for developers running large or ongoing modernizations
S/4HANA Sandbox Connection — Security Profile

Sandbox Only · Read-Only

Connections are restricted to non-production sandbox systems. Only OData metadata reads and test execution — no write operations, no production access.

Learn more

Encrypted · Stateless

Credentials are AES-256-GCM encrypted. SAP transaction data is processed statelessly in memory — no customer ERP data is persisted on our infrastructure.

Learn more

Admin-Gated Onboarding

Every sandbox connection request is manually reviewed and approved by an administrator before activation.

Learn more
* BYOK (Bring Your Own Key)Use your own Google Gemini API key to run unlimited transformations without any platform limits. Your API key is encrypted (AES-256-GCM) and stored in your authenticated user profile—it is used exclusively via our secure backend proxy and never exposed in plaintext.* Usage is subject to your Google Gemini API key quota and billing — clean-core.io does not charge any platform fees.