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. Save days of manual mapping and boilerplate generation—without replacing the judgment of the expert.

Quick Answer

How do you automate SAP Clean Core custom ABAP refactoring?

Clean-Core.io automatically modernizes legacy SAP architectures by parsing custom ABAP code (classes, reports, custom tables) via syntax trees and data-flow analyses. It maps direct database reads (e.g., VBAK, BSEG) to standard, released OData/REST APIs in the SAP API Business Hub, refactoring tightly-coupled logic into cloud-compliant BTP CAP Node.js microservices or in-app RAP components.

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.
Methodological Honesty

Verifiable Integrity.
No AI Black-Box Promises.

Clean-Core.io accelerates your ABAP-to-Clean-Core migration—deterministic, with transparent coverage and honest limitations. You see exactly what is automated, what needs review, and what is structurally blocked per transformation—proven, not claimed.

Fully Grounded

Standard tables mapped to released CDS views, static calls, and single-class inheritance. Verified with a green result-set diff.

Quirk Review

Complex Joins (3+ tables), `FOR ALL ENTRIES` and `INTO CORRESPONDING` are flagged. Remediated via strict custom prompt rules.

Manual Handover

GUI Dynpro screens, dynamic call routing, and kernel internals cannot be resolved by AI. Isolated cleanly for architect refactoring.

Beyond Static Code Analysis

Technical Capability Comparison

SAP native tools report where dependencies fail compliance. clean-core.io automates the replacement mappings and compiles ready-to-run BTP or RAP structures.

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.

Automated SAP API Hub Mapping

SAP Native ToolingManual Only

Requires manual search in documentation.

vs
clean-core.ioResolved

Resolves database reads (VBAK, BSEG) directly to standard APIs.

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 Supported

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 Supported

No process flow visualization available.

vs
clean-core.ioVisualized

Generates BPMN 2.0 flows directly from custom code analysis.

Real Verified Output

Transformation Showroom

Representative engine outputs. Every example is a real transformation—verified, compiled, and tested against Clean-Core Engine v1.12.2.

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.

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).

Confidence: High — deterministic rule match
CDS test environment created
1 of 1 unit tests passed
Verified against Clean-Core Engine v1.12.2 · June 2026

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 API Hub Mapping

Maps legacy database table operations to released, standard SAP APIs with interactive references to official API Hub listings.

Learn more

Dual RAP & CAP Engine

Generates clean In-App ABAP Cloud RAP handlers or decoupled BTP CAP services. Powered by a deterministic AST resolver that linearizes OO inheritance chains before translation, preventing 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 SOP

Maps modernized processes into standard BPMN 2.0 XML with swimlanes. Features a two-stage blueprint layer with RACI matrices, Level 5 SOP narratives, and internal compliance controls.

Learn more
🛡️ Sovereign & Secured

Your Data Stays Yours

European hosting, GDPR-compliant by design, with full self-service data erasure control. We built the security architecture the way we'd want it for our own SAP systems.

Belgium Hosting (Europe)

All workspaces, analytical engines, and database systems are hosted strictly in the europe-west1 GCP region (Belgium) ensuring high-speed processing.

DSGVO / GDPR Compliant

Full enforcement of Art. 17 DSGVO. Purge all user footprints, uploads, and data in Settings. Transactional emails are securely routed via Resend API with DSGVO imprints.

Cloud-Native Security

Fully containerized on Google Cloud Run with server-side encryption, stateless APIs, and zero persistent local data. All processing happens in hardened, 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

Start immediately with 5 free transformations, or bring your own API key to unlock unlimited access and full exports.

Pilot Sandbox

Evaluate
Free5 transformations

Register with name and email — approval within 24 hours.

  • Up to 5 standard ABAP-to-Cloud transformations
  • Syntax analysis & compliance scoring
  • SAP API Business Hub mapping preview
  • Online code preview (input vs. output)
  • Solution design architecture catalog
Recommended

Developer Upgrade

BYOK
FreeUnlimited transformations

Bring your own Google Gemini API key — saved locally in your browser.

  • Includes all Pilot Sandbox features
  • Unlimited code transformations (via BYOK)*
  • Full multi-file abapGit ZIP export (src/ + abapgit.xml)
  • Automated ABAP-Unit test class generation
  • Granular sandbox test execution & runs
  • BPMN 2.0 & Confluence blueprint exports
  • S/4HANA sandbox connection (encrypted, read-only, admin-gated)
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 in memory and never stored on our servers.

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 and stored locally in your browser—it is never sent to or saved on our servers, ensuring absolute privacy and data sovereignty.* Usage is subject to your Google Gemini API key quota and billing — clean-core.io does not charge any platform fees.