Free Community Edition · Edition 2.2

The Clean Core Accelerator

A free, community-built accelerator for SAP Clean Core modernization. It runs a deterministic evidence engine first, then AI — turning legacy custom ABAP into Clean-Core-compliant drafts and cryptographically signed audit evidence for architect review. Complementary to SAP’s own tooling, never a replacement.

Author
Felix Frenzel
Platform
Clean-Core.io
Classification
Public · Community Guide
Edition
2.2 · v2.7.0

Audience: SAP architects · developers · transformation leads · security & audit reviewers

Section 01 / 08

What is Clean-Core.io?

Clean Core means keeping the standard SAP ERP core untouched. When custom code is mixed directly into standard classes and tables, every future S/4HANA update becomes slow, risky and expensive. Clean-Core.io turns that uncertainty into a structured, evidence-backed modernization backlog.

The governing principle — “belegt, nicht behauptet” (proven, not claimed)

A deterministic ABAP evidence engine runs before any AI. Every finding, score and routing decision is tied to concrete evidence in your code. The AI writes the human-readable narrative on top — and that narrative is deliberately excluded from the signed evidence, so a signature always attests to server-computed facts, not to free text.

What it is

An assessment, evidence and governance accelerator — fast enough for exploration, structured enough for governance, honest enough to hold up under review.

What it is not

A replacement for enterprise-architecture approval, SAP release checks, privacy review, penetration testing or production migration governance.

Section 02 / 08

Benefits, Part 1 — Evidence & Speed

Clean-Core.io is not a code translator — it is an evidence-first Clean Core accelerator. Architects, developers and decision-makers get immediate, defensible advantages:

Evidence, Not Opinions

A deterministic evidence scanner with token- and rule-based ABAP analysis maps custom-table access, RFC calls and dynpro patterns to concrete findings — before any AI runs. A defensible baseline you can take into an audit, not a black-box guess.

The Documentation Nobody Wrote

For most legacy programs the documentation was never written or is long gone, the process behind it was never described, and the person who built it has left. The source is the one document that still says what the thing does. A run reads it back in both directions — down into released SAP APIs for the developer, up into process, roles and procedure for the business — and hands both sides a draft to correct rather than a blank page.

Upgrade Resilience

Replacing unreleased database dependencies with officially released SAP APIs (e.g. I_Customer, API_PRODUCT_SRV) helps keep your ERP core upgrade-stable — reducing coupling between custom code and the core update cycle.

Automated Test Stubs

Matching unit tests are generated with the code — ABAP Unit doubles for RAP, or Express/Node suites for CAP — and executed in a sandboxed Node process (filesystem-scoped and time-limited). QA starts covered, not empty.

A guided 7-stage workflow takes you from Analyze → Design → Transformation → Documentation → Testing → TCO → Delivery, and lets you export a compiled package with all modularized files, standard abapGit export and tests.

Section 03 / 08

Benefits, Part 2 — Transparency & Governance

Version 2.2 makes the reasoning inspectable and the progress auditable — so a recommendation survives scrutiny in a board room, not just a demo.

“Why This Route & Score”

A transparency panel shows exactly why a route (RAP / CAP) and score were chosen: the deterministic router rationale, a confidence indicator, and the driving data-coupling findings by risk. Evidence you can defend.

Module Risk Heatmap

A LOC-weighted treemap of detected ABAP objects grouped by module: tile size = share of the codebase, colour = worst criticality inside it. See at a glance which modules carry the most weight and the most risk.

Architecture Decision Record

Every signed evidence pack includes a Markdown ADR: the decision, the engine recommendation and any architect override, the rationale, considered options, scope & consequences, and known limitations.

Run-Over-Run Progress

Because every analysis is an immutable, signed run, the board deck can show a tamper-evident trend: Clean Core Score, findings and complexity deltas versus the previous run — remediation progress, not a re-editable slide.

3 Scores
Clean Core · Complexity · Criticality
BPMN 2.0
+ RACI & Level-5 SOP blueprints
TCO & ROI
Upgrade-impact calculator

Portable by design: outputs are standard — abapGit ZIP, ABAP-Unit / Express tests, BPMN 2.0 XML (importable into SAP Signavio or SAP Build) and a signed audit pack. You own what you generate. No lock-in.

Section 04 / 08

Security, Part 1 — Your Keys & Your Code

Proprietary legacy source code is a highly confidential business asset. Clean-Core.io is engineered with strict, verifiable boundaries around credentials and AI processing.

BYOK — Server-Side AES-256-GCM

Bring Your Own Key is optional: without it, every account gets 5 free transformations on a shared community key; with your own Google Gemini key, usage is unlimited. Your key is encrypted at rest with AES-256-GCM in a server-only store — never returned to the browser (only the last four characters are shown), and used solely via a secure server-side proxy.

Keys Never Reach the Client

Every AI call is proxied through a hardened server route: a strict model allowlist, a prompt-size cap, per-user rate limiting, and an MFA gate on sensitive actions. Provider keys never touch client code.

Model-Training Isolation

Under Google’s applicable Gemini API data-use terms, the code you send is not used to train Google’s foundational models. When you use your own key (BYOK), the terms of your own Google account apply. Your IP stays yours.

Tenant Security

Optional S/4HANA connections are strictly read-only (OData metadata reads and test execution) — no write operations. Credentials are encrypted at rest (AES-256-GCM), stored server-side only and never returned to the browser; live connections are restricted to an administrator-managed allowlist; every live-tenant request is admin-approved before activation.

Honest boundary: for the paid Gemini API the “not used for training” terms apply directly; if you bring a free-tier key, Google’s free-tier data-use terms govern instead. We state the applicable terms rather than an absolute promise we cannot control.

Section 05 / 08

Security, Part 2 — Trust Chain & Data Protection

The output is only trustworthy if it is tamper-evident and your data is handled to EU standards. Both are built in.

Immutable, Signed Runs

Every analysis is captured as an immutable, HMAC-signed “Run”. The evidence pack is generated and signed server-side, so a valid signature protects the integrity of the generated package; provenance is shown per evidence class.

Three-Tier Verification

Anyone can verify a pack’s manifest hash and signature. The AI narrative is deliberately excluded from the signed payload — the signature attests to evidence, not to free text.

EU-Hosted & Art. 17 Erasure

Application storage and primary processing run in europe-west1 (Belgium). Account deletion runs an idempotent, multi-system erasure of your live database and authentication entries; residual encrypted backups age out within 30 days. AI and email subprocessors are disclosed separately under their own terms and transfer safeguards.

Hardening & Supply Chain

A Content-Security-Policy (with documented compatibility exceptions), server-side HTML sanitization, CI secret scanning, a dependency-audit gate and a CycloneDX SBOM generated by the security workflow. Only strictly necessary Firebase Auth storage — no analytics or marketing trackers.

Section 06 / 08

Technical: RAP vs. CAP & API Mapping

During analysis, the engine decides — from syntax and coupling evidence — which extensibility path best fits each object:

Runtime engine
RAP: Runs natively within the S/4HANA core.
CAP: Runs decoupled on SAP BTP (Node.js/TS).
Interfaces
RAP: Synchronous released CDS views.
CAP: Decoupled via OData APIs or Event Mesh.
RISE compliance
RAP: Strict SaaS compliance (zero core modifications).
CAP: Upgrade-resilient classic custom API wrappers.
Focus case
RAP: Immediate database updates and transactional locks.
CAP: Customer portals, mobile apps, external SaaS.
Automated API mapping

Direct reads and writes to internal tables carry different Clean Core weight — direct writes to standard tables are the more critical case. The engine maps such access to released standard interfaces, grounded in SAP’s Apache-2.0 Cloudification Repository:

KNA1Customer MasterCDS View I_Customer
BSEGAccounting SegmentCDS View I_JournalEntryItem
MARAMaterial MasterOData API API_PRODUCT_SRV
VBAKSales HeaderRAP Entity I_SalesOrderTP

Built on open data: the object catalog is grounded in SAP’s Apache-2.0-licensed Cloudification Repository, merged with Clean-Core.io’s curated mappings. The platform is free to use and built on open standards — the reasoning is transparent, the outputs are portable.

Section 07 / 08

Evidence — a run you can reproduce

Claims about tools like this are usually unverifiable. This one is not. The figures below come from analysing a legacy ABAP program that ships in our public repository, computed when this page is rendered rather than written into it. Download the file, run it, and compare.

907
Lines of ABAP
42
Findings
34
Clean Core Score
11
Construct classes tracked

Of those 42 findings, 21 resolve to a released SAP successor looked up in SAP’s own published data, 17 need an architect’s decision because business intent has to be weighed against the target design, and 4 are handed back untouched as structurally out of reach for any generator. Of the 11 ABAP construct classes we track, 4 are fully covered, 5 require sign-off and 2 are not supported — published per class, before you upload anything.

One synthetic reference program is not a codebase, and your ratio will differ. It is published so the method and the boundary can be checked, not as a forecast. See the full run.

Honest Scope

Trust is built on being clear about the boundaries. Here is what Clean-Core.io deliberately does — and does not — do.

What it does
  • Generates a first Clean-Core-compliant draft plus signed evidence.
  • Runs deterministic analysis before any AI.
  • Recommends RAP / CAP with a transparent rationale.
  • Produces tests, BPMN, TCO and an audit pack.
What it does not do
  • Perform or guarantee an automated migration.
  • Replace SAP’s own tools (ADT, ATC) or expert judgment.
  • Deliver production-ready code without architect review.
  • Transform SAP GUI dynpro screens, core modifications, native SQL, dynamic call routing or kernel internals — these are flagged and handed back, never guessed at.
  • Promise a time saving. How long the work takes depends on the decisions, and those stay with you.
  • Claim any affiliation with or endorsement by SAP SE.

All generated output is a draft for expert evaluation. Review, test and approve it with a qualified SAP architect before any productive use. Clean-Core.io is a free, non-commercial community project provided for research and evaluation — independent, and not affiliated with SAP SE or Google LLC.

Section 08 / 08

Start with a non-production sample

Generate the first Clean-Core-compliant draft for review, walk the decision with your SAP architect, and export a governed delivery package. Start with 5 free transformations, or bring your own Gemini API key (BYOK) for unlimited access — no credit card required.

FF
Felix Frenzel
Founder & Community Architect · Bamberg, Germany