Free for the SAP Community
SAP Clean Core AcceleratorFrom custom ABAP nobody understands to a reviewed, tested rebuild.
Clean-Core.io reads the program before any model does, draws the process it runs — and carries the same evidence on to a target design, a transformed code draft and tests — run against mocks in an isolated runner, or with ABAP Unit in your own SAP system. Every step points to the line it came from; what a model suggested is marked; what could not be determined is said.
One chain of evidence
The code is a draft for review. Tests here run in an isolated runner against mocks, not in your S/4HANA system; an ABAP Unit result from your own system is recorded as imported or self-declared. A signature proves where a run came from and that it is unchanged — not that it is right.
Free for the SAP community. The demo project is waiting in your workspace after you sign in — nothing you do there is saved.
Your process
Demo · Z_MM_PO_APPROVAL
ReconstructedFound in the code
12 business rules hard-coded in the program — , , , …
10 not determined Not determined
Local function-module call ×5 · Include whose source was not uploaded ×2 · Dynamic call or field access · Classic list output ×2 · 2 includes not uploaded
77FORM check_requisition.78 IF gs_eban-matnr IS INITIAL.79 PERFORM reject USING 'Material missing on the requisition'.80 RETURN.81 ENDIF.82 IF gs_eban-frgkz = 'X'.83 PERFORM reject USING 'Requisition is blocked for release'.84 RETURN.85 ENDIF.86 PERFORM check_material_status.87 IF gv_rejected = abap_true.88 RETURN.89 ENDIF.90 PERFORM check_account_assignment.91 IF gv_rejected = abap_true.92 RETURN.93 ENDIF.94 "Plant 1000 is the central warehouse95 IF gs_eban-werks = '1000'.96 gv_skip_limit = abap_true.97 ENDIF.98ENDFORM.
Decision point: Material given? — line 78 of the program, where the map draws it.
97 of 97 elements of the whole program carry a line anchor.
What is Clean-Core.io?
Other tools explain code, or rewrite it. Clean-Core.io does both — on one chain of evidence.
Tools that explain code
Explain what a program does — in words, a summary or a diagram.
Tools that rewrite code
Produce new code from the old program.
Clean-Core.io
Explains, rebuilds, tests — one chain of evidence.
Reads your code before any model does, so every finding points to a line. Says what it could not determine, and never passes an assumption off as a fact.
One chain of evidence
Five steps on the same evidence. Each one says where it stands, and each points back to the line of code it came from.
Process
The business process as BPMN, read from the code. Every element points to its line, or says why it has none — the plant 1000 rule of the demo to L95.
Reconstructedline anchor
Design
A target design for the route the evidence points to, built on the run the server signed — a proposal until you record the target you accept.
Model proposalrun reference
Code draft
The transformed code, generated from the source, the analysis and the design; its plan names every finding at its line. A draft you review, not a finished product.
Model proposalline anchor
Tests
Test scenarios for the generated code. On the CAP track they run in an isolated runner against mocks, and the server records what ran, on which code; on the RAP track you record the ABAP Unit result from your own SAP system.
Demonstrated · mocktest receipt
Handover
An audit pack the server signs over the run, with HMAC and Ed25519, that anyone can verify offline.
Provensignature
The code is a draft for review, not a finished product. On the CAP track the tests run in an isolated runner against mocks: they check the generated code against test scenarios, not that it runs in your S/4HANA system. On the RAP track nothing runs here: the ABAP Unit result comes from your own system, as an imported file or your own confirmation, never as proven. A signature proves where a run came from and that it is unchanged — not that it is right.
Deep dives: ABAP code analysisExtensibility routingAudit evidenceModernization assessmentHow-to guide
One case, three views
Business, IT and Management look at the same facts. Each view answers its own question — Do I still need this? What exactly, where to? What do I risk, what do I decide? — and none of them changes a result.
werks = '1000'L95Do I still need this?
Requisitions for plant 1000 are approved without the limit check
What exactly, where to?
Sets gv_skip_limit, and DECIDE_APPROVAL then leaves out CHECK_LIMIT
Z_MM_PO_APPROVALL88L425a literal in the code, not customizingWhat do I risk, what do I decide?
Not decided yet — keep, rebuild, move to SAP standard or retire is yours
Business
Do I still need this?
werks = '1000'L95Requisitions for plant 1000 are approved without the limit check
IT
What exactly, where to?
werks = '1000'L95Sets gv_skip_limit, and DECIDE_APPROVAL then leaves out CHECK_LIMIT
Z_MM_PO_APPROVALL88L425a literal in the code, not customizingManagement
What do I risk, what do I decide?
werks = '1000'L95Not decided yet — keep, rebuild, move to SAP standard or retire is yours
Plays once. Hover or focus pauses it; choose a view to take over.
A view orders what you see. It is never stored with a project, a run, a signature or an audit pack, and it changes no result. You confirm as the signed-in account — a self-declaration, not an organisational mandate.
Business
Do I still need this, and what changes for me?
Opens with one next step, then the process as numbered steps in plain words with their lines, what it decides and what it changes, and the business rules — the hard-coded ones too — unanswered first.
IT
What exactly, where to, and is it right?
Opens with the findings at their line, the successor named and who names it, and the chain from requirement to anchor, finding and target draft.
Management
What do I risk, what do I decide?
Opens with the decision — keep, rebuild, move to SAP standard or retire — what it rests on, the open conditions in plain words and fit to standard as one figure; costs only as a simulation.
What does clean core mean?
Clean core keeps SAP S/4HANA standard. Clean core extensibility means extensions use only released, upgrade-stable interfaces — in-app with ABAP Cloud or side-by-side on SAP BTP, part of the SAP Business AI Platform.
What clean core means
Keep the SAP core standard: extensions use only released, upgrade-stable interfaces — in-app with ABAP Cloud or side-by-side on SAP BTP.
The four levels
Select a level to see what it means and an example: a real SAP object on that level.
Example
I_SALESDOCUMENTImported· SAP release dataReleased CDS view. SAP's own release data names it as the successor of table VBAK.
Levels follow SAP's clean core level concept. The level shown for an object is our reading of SAP's published data — an orientation, never part of a signed audit pack. Confirm with ABAP Test Cockpit.
How levels are assignedObject classification A–DClean Core Score — a grade, not a compliance percentage
Where the evidence comes from
Select a station to see what it contributes.
Every statement keeps its program, include and line — that is what a line anchor points to. Includes that were not uploaded are named as not determined.
Look up an SAP object's release state and successor
The SAP object catalog is a free viewer of SAP's Cloudification Repository and object classification: 33,877 objects classified, each with release state, clean core level and successor, synced 2026-10-01.
How is the process reconstructed from ABAP?
Clean-Core.io draws the process as BPMN from what the ABAP code does, puts a line anchor on every element, or the reason it has none, and names what the code cannot show instead of drawing it.
Large processes stay readable
Levels instead of zoom: the map opens as an overview of phases. Open a phase in place, follow the path at the top, or read the same level as a list of steps. Try it on the 1,000-line example — with the mouse, the keyboard, or as a list of steps.
opens a phase in place · L182 the line the step was read from · Enter or click opens, Escape goes one level up · Steps shows the same content as a list
13 technical helpers folded in: bdc_dynpro, bdc_field, build_fieldcatalog, append_fieldcat, add_log, finalize_run, count_orders_native, rule_custom_order_type, rule_foreign_high_value, rule_credit_status, rule_billing_block, rule_rejected_items, rule_stock_shortageShowHide
bdc_dynprocalled 3× L491–497bdc_fieldcalled 6× L499–504build_fieldcatalogcalled 1× L601–610append_fieldcatcalled 8× L612–619add_logcalled 13× L640–655finalize_runcalled 1× L657–663count_orders_nativecalled 1× L665–673rule_custom_order_typecalled 1× L737–752rule_foreign_high_valuecalled 1× L754–766rule_credit_statuscalled 1× L798–811rule_billing_blockcalled 1× L813–824rule_rejected_itemscalled 1× L826–844rule_stock_shortagecalled 1× L917–929
Every element points to its lines
Start and end events, tasks, decision points and sub-processes each carry a line anchor. Decision points keep their condition from the code; proposed lanes are marked as proposals, never as your organisation.
Business rules come out of the code
Literals in conditions — tolerances, plants, vendor lists, date limits — become rule candidates with their anchor. You keep, change or drop each one, or mark it to clarify.
Unreached code is named, not drawn
Forms no entry point calls stay off the map and are listed underneath with their lines. Identical forms are grouped, technical helpers fold into their caller.
Leaves as a BPMN 2.0 XML file
Export the process as standard BPMN 2.0 XML; collapsed sub-processes stay real sub-processes. Import into SAP Signavio has not been verified yet. There is no connection to a Signavio workspace — only files.
Deep dives: Process blueprintsRAP and CAP draftsCloudification catalog
Verify it yourself
Run the published 1,000-line example and you get the same result: the engine is deterministic, the source file ships with the product, and every completed analysis is sealed as a signed run you can verify.
The reference run
ZLEGACY_ORDER_FULFILLMENT_AUDIT_1000LOC.abap, analysed by the same engine the product uses, computed from the file when the page is built.
- 16the tool settles
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.
- 20your decision
Transformable, but somebody has to weigh business intent against the target design. The tool shows the evidence and stops.
- 4stays hand work
Out of reach for any generator. Flagged and isolated rather than guessed at, so nothing false reaches your draft.
SAP objects this run touched
With the successor from SAP's own release data. Where the engine uses a curated field-level mapping instead, the finding says so.
- KNA1
I_CUSTOMER - KNB1
I_CUSTOMERCOMPANY - MARA
I_PRODUCT - MARD
I_PRODUCTSTORAGELOCATIONBASIC - T001
I_COMPANYCODE - TVKO
I_SALESORGANIZATION - VBAK
I_SALESDOCUMENT - VBAP
I_SALESDOCUMENTITEM
One finding lands on the business: Credit Management Custom Logic (L407). The engine's recommendation, quoted unedited: “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.”
- 1 · Import the draftImport the generated abapGit package into Eclipse ADT.
- 2 · Compile and testCompile the code, run the ABAP Unit tests in your own sandbox and record the result in Testing.
- 3 · Check the sealVerify the signed audit pack — verify a pack.
How do I know what is proven and what is not?
Every statement carries its source as a word, an icon and a shape. Nothing simulated passes as proven: missing stays missing, simulated stays simulated, reconstructed stays reconstructed.
Where a statement comes from
One fixed list. The shape says how firm a statement is.
Filledsettled
Outlinederived or imported
Dashedprovisional
Four buckets, one rule per object
The first rule that applies wins, and every assignment shows its evidence. The buckets depend on the project's target platform.
Retire
The rule it serves is confirmed “Drop”, or a usage import shows no executions over at least 13 months — then it is a candidate, an open check, not a verdict.
The object goes away. Nothing has to be built for it.
Why 13 months: period-end and year-end programs run once a year, so a shorter usage window never makes an object a retire candidate.
No catalogued path
Needed, below the target platform’s bar, and SAP’s Cloudification Repository names no released API and no successor for it.
Nobody has named a way yet. SAP's repository names no released API and no successor for these objects, or does not list them at all, so the next step is a question someone has to answer — not work this project can plan, and not a fault in this code.
Rebuild
Needed, below the bar, and a successor or an extension path is named — and every modification or own write to an SAP table.
The way is known and the work sits with this project: SAP names a successor or an extension path to move to, or the object is the project's own work — its own code, a modification or a direct write.
Keep
Needed and permitted on the target platform: SAP S/4HANA Cloud Public Edition (part of SAP Cloud ERP) level A only, SAP Cloud ERP Private (formerly SAP S/4HANA Cloud Private Edition) level A or B.
The object stays as it is on the chosen platform. Nothing has to be built for it.
The same level B object is Keep in SAP Cloud ERP Private and Rebuild or No catalogued path in Public Edition. Change the target platform and the page says what moved.
Does it replace SAP's own tools?
No. ABAP Test Cockpit stays the authoritative check, ADT stays where code is built and tested, and SAP's agents fix code inside your system; Clean-Core.io prepares the evidence and the decision around them.
Can I try it before I upload my own code?
Yes. Every account has the same demo project: the engine's reading of the example Z_MM_PO_APPROVAL on every stage — fictitious code, a guided tour, and nothing you do there is saved or counted.
Demo project
Demo · Z_MM_PO_APPROVAL
DemoAt the end of the tour
Your turn: start with an example (free) or your own code
A sub-process has its own level. Pick a level to see only its steps; the path above the map says where you are.
What the tour walks through
- First insights into your process
- The process map and its source
- Levels of a large process
- What we could not determine
- Decide on rules
- Standard fit
- The IT chain
- The Management view
- Four buckets
- Costs are a simulation
- The decision
- Handover
- Confirm, decide, filter and edit. The state lives only in your browser and is gone with “Reset demo”.
- Nothing counts against your analysis runs, and a demo run is never signed.
- One demo for every account, rebuilt when the engine or its rules change — always on the current product.
Needs a free account. The demo is the first row in My workspace.
The tools in your workspace
Behind the three views sit seven stages, each a tool you open from the workspace. Each one produces something you can read and check before the next — and a person signs the result, not the tool. The demo project walks through all of them with a guided tour.
1 · Analyze
A deterministic engine reads the ABAP before any model does: every finding at its line, a map of where in the program they sit, and the Clean Core Score on a scale that says what the number means and what moved it.
The result is recorded as a signed run, the extensibility route follows from fixed rules, and every later stage builds on it.
Done by the deterministic engine
2 · Design
The target architecture as a canvas, drawn from the run: what stays inside SAP S/4HANA behind the clean core boundary, which released API replaces which lines, what has no released successor, and on the side-by-side track what runs on SAP BTP, part of the SAP Business AI Platform.
A model writes the design document beside it when the stage opens; you record which target you accept — a self-declaration, not a mandate.
Drafted by a model — a person decides
3 · Transformation
A model generates the target code from the source, the analysis and the design: ABAP Cloud artefacts on the RAP track, a Node.js project on the CAP track. Beside it, the engine’s plan shows where every finding goes.
Nothing compiles or tests it in this stage; it is a draft you review.
Drafted by a model — a person decides
4 · Documentation
When the stage opens, the analysed source is written up as a process description a successor can read — what it covers, how a run starts, the process with its map and who acts at each step, decision points and business rules, exceptions, what it changes, systems and data, and open questions — every step with its line, details and evidence as an appendix.
It exports to Confluence, Markdown and Word; a business layer with SOPs and a RACI matrix is a model draft, written only when you ask for it.
Done by the deterministic engine
5 · Testing
A model writes test scenarios for the generated code; on the CAP track they run against mocks in an isolated test runner, never on your system. The engine lists what a tester has to check by hand, with the lines.
On the RAP track the scenarios are an ABAP Unit class that runs only in your own system: you upload its result file or confirm the result yourself, marked as imported or self-declared, never as proven. A pass against mocks never means the code works in SAP.
Drafted by a model — a person decides
6 · Economics
A demonstration model compares doing nothing, keeping the code and moving to SAP standard on cost figures you enter and assumed coefficients, and lists every input still open.
It is not a business case, and it shows no forecast until your own figures are in.
Done by the deterministic engine
7 · Delivery
Delivery shows the chain from requirement to decision, receipt and artefact, what a handover still needs, and the audit pack the server signs over the signed run — blocked while anything was built for a previous source.
A pack can be checked on the Verify Pack page; whether to deploy stays an architect’s decision.
Done by the deterministic engine
Real run of the example program · fictitious code · captured from the workspace A deterministic engine reads the ABAP before any model does: every finding at its line, a map of where in the program they sit, and the Clean Core Score on a scale that says what the number means and what moved it.
The result is recorded as a signed run, the extensibility route follows from fixed rules, and every later stage builds on it.
ProvenDone by the deterministic engine
Real run of the example program · fictitious code · captured from the workspace The target architecture as a canvas, drawn from the run: what stays inside SAP S/4HANA behind the clean core boundary, which released API replaces which lines, what has no released successor, and on the side-by-side track what runs on SAP BTP, part of the SAP Business AI Platform.
A model writes the design document beside it when the stage opens; you record which target you accept — a self-declaration, not a mandate.
ReconstructedModel proposalConfirmedDrafted by a model — a person decides
Demo project · fictitious code · captured from the workspace A model generates the target code from the source, the analysis and the design: ABAP Cloud artefacts on the RAP track, a Node.js project on the CAP track. Beside it, the engine’s plan shows where every finding goes.
Nothing compiles or tests it in this stage; it is a draft you review.
Model proposalDrafted by a model — a person decides
Demo project · fictitious code · captured from the workspace When the stage opens, the analysed source is written up as a process description a successor can read — what it covers, how a run starts, the process with its map and who acts at each step, decision points and business rules, exceptions, what it changes, systems and data, and open questions — every step with its line, details and evidence as an appendix.
It exports to Confluence, Markdown and Word; a business layer with SOPs and a RACI matrix is a model draft, written only when you ask for it.
ReconstructedModel proposalDone by the deterministic engine
Demo project · fictitious code · captured from the workspace A model writes test scenarios for the generated code; on the CAP track they run against mocks in an isolated test runner, never on your system. The engine lists what a tester has to check by hand, with the lines.
On the RAP track the scenarios are an ABAP Unit class that runs only in your own system: you upload its result file or confirm the result yourself, marked as imported or self-declared, never as proven. A pass against mocks never means the code works in SAP.
Model proposalDemonstrated · mockImportedConfirmedDrafted by a model — a person decides
Demo project · fictitious code · captured from the workspace A demonstration model compares doing nothing, keeping the code and moving to SAP standard on cost figures you enter and assumed coefficients, and lists every input still open.
It is not a business case, and it shows no forecast until your own figures are in.
SimulationDone by the deterministic engine
Real run of the example program · fictitious code · captured from the workspace Delivery shows the chain from requirement to decision, receipt and artefact, what a handover still needs, and the audit pack the server signs over the signed run — blocked while anything was built for a previous source.
A pack can be checked on the Verify Pack page; whether to deploy stays an architect’s decision.
ProvenDone by the deterministic engine
How do I start, and what does it cost?
Nothing — Clean-Core.io is free. Each of the 7 examples runs once at no cost, your own code uses one of five free analysis runs, and after that you continue with your own Gemini API key.
Create a free account
Sign up with Google or with e-mail and password. No payment, no card.
Open the demo, an example or your code
The engine reads the source first. The process, its rules and what could not be determined appear with line anchors.
Answer and decide
Answer the rules — keep, change, drop or clarify — record the decision for the program and hand over. Every completed analysis is sealed as a signed, unchangeable run.
Try an example
7 fictitious programs. Select one to see what it shows.
Z_MM_PO_APPROVAL
Approves emergency purchase requisitions: vendor block list, price tolerance against the info record, approval by department head or manager, and a purchase order via BAPI with a batch-input fallback.
Shows: Business rules hard-coded in the program — and what cannot be determined from the code alone: a dynamic function call and two includes that are not part of the upload.
Free the first time you run it. Running it again uses one of your analysis runs — you are told before it starts.
Free Community Edition
- Five free analysis runs per account — once, not per month
- Each example free the first time
- Every stage and every view included
Free, with your own key
- No quota on analysis runs
- Your key is stored encrypted and used only through our server
- Google bills your key under your own agreement with Google
Your data stays yours
Your code is stored in the EU, reaches the Google Gemini API only through our server, and is never sold or commercially used. Each line below links to the document that says so.
What you confirm
By uploading, you confirm you may share this code for analysis, including with the Google Gemini API. (Terms §5, Terms §8)
What we do so you can trust us
Stored in the EU — Google Cloud, Belgium (europe-west1).
Only the account that created this project can open it, and anyone that account chooses to invite; no one else has standing access.
Model calls go through our server; keys never reach the browser. Your own key is stored encrypted.
Every completed analysis is sealed as a signed, unchangeable run.
No analytics, advertising or tracking cookies.
Delete your account and its projects at any time; backup copies age out within 30 days.
With our community key, Google does not use your code to train its models — the paid Gemini API terms apply. With your own key, your Google account's terms apply.
Our security model is public.
A free community project
Clean-Core.io is a free community project: there is no paid tier, we accept no payment, and we do not sell, rent or commercially use your code.
Clean-Core.io is independent and not affiliated with or endorsed by SAP SE. Generated output is a draft that you review before any productive use. The code of this product is public: github.com/sonnyfrenzel-rgb/clean-core.io.
Questions people ask first
What is SAP clean core?
Clean core keeps the SAP S/4HANA standard unmodified: extensions use only released, upgrade-stable interfaces — in-app with ABAP Cloud or side-by-side on SAP BTP, part of the SAP Business AI Platform. SAP’s clean core level concept grades what an extension uses from A (released APIs and extension points) to D (not recommended: modifications, implicit enhancements, writes to SAP tables).
What does Clean-Core.io do with my ABAP?
A deterministic engine reads the program before any language model does. It reconstructs the business process with a line anchor on every element, or the reason it has none, lists the business rules hard-coded in the program, shows the clean core level of each SAP object the code uses, or Unknown where SAP’s published data holds no answer, and names what it could not determine. The same evidence then carries a target design, a transformed code draft and test scenarios — on the CAP track run against mocks in an isolated runner, on the RAP track an ABAP Unit class for your own system, whose result you record from that system — and every completed analysis is sealed as a signed run. The code is a draft you review; a run against mocks checks it against test scenarios, not in your S/4HANA system.
What is Clean-Core.io as of v3.0.x?
As of v3.0.19 (released 2026-10-21), Clean-Core.io is a free, independent web workspace for deciding what happens to one custom ABAP program. A deterministic engine reads the code before any language model does and reconstructs the business process as BPMN, with a line anchor on every element or the reason it has none, including the business rules hard-coded in the program. Each SAP object the code uses gets a Level A–D under a versioned rule, read from SAP’s published Cloudification Repository and object classification, or Unknown where neither holds an answer. On that evidence the Management view asks for one decision — keep, rebuild, move to SAP standard or retire — and Design, Transformation and Testing carry the same evidence to a target design, a code draft and test scenarios, each marked as a Model proposal for a person to review. Every completed analysis is stored as an immutable run signed by the server with HMAC; the audit pack exported from it is signed with HMAC and Ed25519, and its Ed25519 signature can be verified offline. What the engine could not determine is listed as not determined, not guessed.
What changed in Clean-Core.io 3.0?
Clean-Core.io 3.0, released 2026-10-03, gives every project one workspace, and the seven stages are no longer the product: they are tools inside it. A project opens on the business process reconstructed from its ABAP code as BPMN, shown in three views of the same facts — Business, IT and Management. A view orders what is shown; it changes no result and is never stored on a run or a signature. The Management view leads with the decision — keep, rebuild, move to SAP standard or retire. Also new in 3.0: a BPMN editor in which every save is an immutable revision and the reconstruction stays revision 1, with BPMN 2.0 XML files in and out and no connection to a Signavio workspace; documentation written from the engine’s reading of the code, no longer by a model reading only the start of it; and a demo project with a guided tour in every account. Sign-up and accounts did not change. The releases since then, up to v3.0.19 (2026-10-21), refine 3.0; the release notes are in CHANGELOG.md of the public repository, github.com/sonnyfrenzel-rgb/clean-core.io.
How does Clean-Core.io turn ABAP code into a BPMN process?
Clean-Core.io’s deterministic engine reads the ABAP program and reconstructs the business process it runs as a BPMN 2.0 diagram: every task, gateway and event points to the ABAP line it came from, or says why it has none. Business names that a language model suggests are marked as a model proposal. The process can be edited in the built-in BPMN editor; every save is a new revision, and the reconstruction itself is never overwritten.
Is my code used to train models?
With our community key, Google does not use your code to train its models — the paid Gemini API terms apply. With your own key, your Google account's terms apply.
What does it cost?
Nothing. Clean-Core.io is a free community project with no paid tier, and we accept no payment. An account has five analysis runs; each starter example is free the first time you run it. After that you continue with your own Gemini API key, which Google bills under your own agreement with Google.
Is the generated code ready to go live?
No. The transformed RAP or CAP code from Clean-Core.io is a draft for a person to review. On the CAP track its test scenarios run in an isolated runner against mocks, so they do not show that the code runs in a real SAP S/4HANA system; on the RAP track they are an ABAP Unit class that runs only in your own system, and nothing is run here — you record its result as an imported file or your own confirmation, never as proven. A signed run proves where a result came from and that it has not changed since — not that it is correct. What the engine could not determine is listed as not determined rather than guessed.
Does it replace ABAP Test Cockpit?
No. ABAP Test Cockpit stays the check to rely on. The level Clean-Core.io shows is its reading of SAP’s published data — an orientation, never part of a signed audit pack. Confirm with ABAP Test Cockpit, and import your ATC results to compare them with the engine.
Does it replace Joule for Developers or SAP’s Custom Code Migration Agent?
No. SAP’s agents work inside your system and tell developers what to fix. Clean-Core.io shows the business what the code does, then carries the same evidence through a design, a code draft and tests to a decision — including whether the program is still needed at all. What stays goes to the developers and their tools, and ABAP Test Cockpit stays the authority.
Does it work with SAP Signavio?
Clean-Core.io exchanges standard BPMN 2.0 XML files: it exports the reconstructed process, and a BPMN 2.0 XML file can be imported back into its process editor as a new revision. Import into SAP Signavio has not been verified yet, so we do not claim it, and there is no connection to a Signavio workspace.
What are the Business, IT and Management views?
Three ways to read the same Clean-Core.io project. The Business view answers “Do I still need this, and what changes for me?”, the IT view “What exactly, where to, and is it right?”, and the Management view “What do I risk, what do I decide?”. A view only orders what is shown; it changes no result, and it is never stored on a run or a signature.
What is the Clean Core Score?
The Clean Core Score is a 5–100 measure, published by Clean-Core.io, of how far the analysed custom ABAP is decoupled from the SAP standard core; higher is better. It falls into four bands: Far from clean core (5–59), Significant rework (60–80), Some rework (81–90), Close to clean core (91–100). SAP publishes no metric of that name, and it is not SAP’s Technical Debt Score, which runs the other way.
What is the SAP Cloudification Repository viewer?
The SAP object catalog on Clean-Core.io shows SAP’s published Cloudification Repository and object classification: for each SAP object its release state, the clean core level Clean-Core.io derives from it and, where SAP names one, its successor — synced from SAP’s public repository. It needs no account.
Who can see my projects?
Only the account that created a project, and anyone that account invites. An invitation is bound to one confirmed e-mail address and gives read access including the source code until it is withdrawn, which can happen at any time. Its link expires if nobody accepts it. There are no public links.
Where is my data stored?
Stored in the EU — Google Cloud, Belgium (europe-west1). No analytics, advertising or tracking cookies. Delete your account and its projects at any time; backup copies age out within 30 days.
Can I try the demo without an account?
No. The demo project lives in your workspace, so it needs a free account. Inside it nothing you do is saved, and nothing counts against your analysis runs.
How does clean core reduce S/4HANA upgrade risk?
Custom code that reads or modifies the SAP standard directly is what makes an upgrade expensive: a modification has to be adjusted in SPAU before the upgrade can proceed, native SQL bypasses the database abstraction, and every direct table read relies on a structure SAP never promised to keep. Clean core replaces those with released APIs. Clean-Core.io names them in your own ABAP, object by object against SAP’s published Cloudification Repository, and flags what a generator cannot reach instead of transforming it into something plausible and wrong.
Is Clean-Core.io an SAP product?
No. It is an independent community project, not affiliated with or endorsed by SAP SE. It follows SAP’s clean core level concept and reads SAP’s published Cloudification Repository.