AWS Builder Center

Know your S/4HANA readiness before you commit a date: AI-assisted ABAP assessment on AWS

How SAP teams get an honest, object-by-object picture of what custom ABAP is and isn't cloud-ready for S/4HANA, with plain-English findings and effort sizing, using Claude Opus 4.8 on Amazon Bedrock.

Series: AI Assisted SAP ABAP workflows using Kiro Agents (3 articles)

  1. 1
    Know your S/4HANA readiness before you commit a date: AI-assisted ABAP assessment on AWS This article
You are three weeks into planning the S/4HANA move, and the spreadsheet has 3,412 rows. Every row is an ABAP Test Cockpit (ATC) finding from your custom code. Some are tiny. Some are landmines. The steering committee wants a date, and right now the only honest answer you have is "it depends." That gap, between a flat list of thousands of findings and a plan you can actually defend, is where most S/4HANA programs lose their first month.
This post is about closing that gap. Not fixing the code yet, just getting an honest, ranked, plain-English picture of where you stand: which objects are clean, which are blockers, what each finding actually means, and roughly how much work each one is. The engine is agentic AI on AWS, Anthropic Claude Opus 4.8 on Amazon Bedrock, driven by Kiro CLI. There is a  hands-on workshop  at the end so you can run the assessment against a sample system yourself.
This post is about readiness assessment only, the read-only part where you size the job. Actually draining the backlog at scale is a separate story (that is the Clean Core Remediation Factory post). It also assumes you already know  abapctl  exists. If you don't, start with the intro article,  Bring your SAP development workflows into the agentic era using abapctl , then come back here.

The problem: you can't plan what you can't see clearly

Meet Anika, a lead ABAP developer at a manufacturer running SAP on AWS. She is early in an ECC-to-S/4HANA program, and her job this quarter is not to fix anything. It is to tell the program office how big the job is, and to be right, because a date is getting locked either way.
Finding the problems is the easy part. SAP Readiness Check shows her the shape of the mountain, and ATC with the cloud-readiness variant gives her the object-by-object list of what is not cloud-ready. She has thousands of findings across dozens of custom packages. She knows what is wrong. What she does not have is a way to turn that pile into a plan:
  • The list is flat. Three thousand findings all look equally urgent in a spreadsheet. Which packages are almost clean and which are wall-to-wall blockers? Without that, teams sequence the work by gut feeling and burn the calendar on the wrong things first.
  • Every finding needs a translation. "Usage of not released ABAP Platform APIs" tells you something is wrong, but not whether it is a five-minute swap or a two-day rewrite. Somebody has to open each one and figure out what it really means.
  • Effort is a guess. Because nobody has sized the findings, the estimate is a finger in the air. Eight months? Three? The honest answer is that nobody knows yet, and that is exactly what makes the date dangerous.
  • The picture goes stale. Even if Anika triages everything by hand this month, developers keep committing code, and by next sprint her careful count is out of date.
None of this is a detection problem. ATC already detected everything. It is a "turn detection into a plan" problem, and that is slow, boring, human work. Which is precisely the kind of work an agent is good at.

The capability: an assessment that reads, explains, and ranks

The AWS AI capability here is agentic readiness assessment. Foundation models on Amazon Bedrock, driven by Kiro CLI, run a deterministic ABAP tool against your SAP system over ADT's REST APIs. Everything in this post is read-only. Nothing gets written to your system. The model's job is not to change code, it is to help you understand it. Here is what that buys you.
1. Object-level classification into SAP's Clean Core levels. The assess step runs ATC with the cloud-readiness variant across a package and sorts every object into one of SAP's four levels. The level is set by the object's worst finding.
Level
ATC findings
What it means
What you do about it
A
none
Fully clean
Cloud-ready, leave it alone
B
info (P3)
Uses documented extension points
Fine, low upgrade risk
C
warnings (P2)
Uses internal or undocumented APIs
Plan a change, check before upgrade
D
errors (P1)
Non-released APIs, modifications, blocked patterns
Must fix, this is a cloud blocker
Because this is read-only and fast, you can run it across every custom package and get a ranked view: which packages are mostly D (look at these first), which are already A or B (don't waste time there). Re-run it whenever you want a fresh count.
2. Plain-English explanations of what each finding means. This is where the model earns its keep. Instead of leaving Anika to decode "restricted language scope (Open SQL)" on her own, the agent reads the finding, the surrounding code, and the ATC metadata, and tells her in normal words what the code is doing wrong and why S/4HANA cares. It is the difference between a cryptic error code and a sentence a human can act on.
3. Effort sizing, honestly. For every finding the agent checks one thing that changes your whole plan: does SAP ship an automatic fix for this, or not? Findings with a canned quick fix are cheap and mechanical. Findings with "no quick fix offered" are the ones that need real thought later. Splitting the backlog along that line turns a scary flat number into two piles you can actually estimate.
4. Prioritization you can hand to a committee. Roll the per-object levels up to the package level and you get a heat map: package D-density, ranked high to low. That single ranked list is something a steering committee can read and act on, which is more than you can say for a 3,412-row export.
5. Safe and repeatable. Every call the tool makes is tagged read-only. Nothing is written, nothing is previewed for change, nothing lands in a transport. That means you can point it at any package, any time, including from a pipeline, without a change-management conversation. The worst it can do is read.

Assessment in action: a real package on a live system

Everything below came from pointing the assessment at a live S/4HANA development system (SID  S4H , client 100) and running the readiness variant  ABAP_CLOUD_READINESS  against a custom package,  ZSFLIGHT . Every command was read-only. Nothing was written. This is the real output, not a mock-up.
Step 1: assess the whole package. One read-only run sorted all 143 objects:
Package: ZSFLIGHT | System: S4H/100 | Variant: ABAP_CLOUD_READINESS
Levels:
A (clean): 26 objects (18%)
B (pragmatic): 0 objects
C (plan): 1 object ( 1%)
D (blocked): 116 objects (81%)
81% of the package is a cloud blocker. That is the wall Anika is trying to size. Notice she now has a number she can defend, not a feeling.
Step 2: look inside one object.  ZCL_SFLIGHT_BOOKING_DAO  comes back Level D with 37 findings. Reading their quick-fix metadata (still read-only) splits them cleanly, and this split is the whole point of the exercise:
[P1] Syntax error in restricted language scope (Open SQL)
.../zcl_sflight_booking_dao/source/main:63:0
fix: manual, automatic tag: REF_OBJ_NAME=SELECT
[P1] Usage of not released ABAP Platform APIs.
.../zcl_sflight_booking_dao/source/main:10:0
(no quick fix offered for this finding)
Two kinds of findings, two very different price tags:
  • 6 of the 37 are obsolete Open SQL that ATC ships an automatic quick fix for. These are cheap. When it is time to fix them, they are mostly a button press, and they are provably safe. For planning, treat them as bulk mechanical work.
  • 31 of the 37 are "Usage of not released ABAP Platform APIs" with no quick fix offered. There is no canned rewrite. Each one needs somebody to find the sanctioned replacement, check that it returns the same data, and rewrite the call. For planning, treat these as the real work.
Here is what one of those cheap findings is actually pointing at, so the category feels concrete. The agent flags this  SELECT  as old-style Open SQL that ABAP Cloud no longer allows:
" Flagged Level D: non-strict Open SQL, but SAP ships an automatic fix for it
SELECT SINGLE carrid connid fldate bookid customid custtype
class forcuram forcurkey cancelled
FROM sbook
INTO CORRESPONDING FIELDS OF rs_data
WHERE carrid = iv_carrid
AND connid = iv_connid
AND fldate = iv_fldate
AND bookid = iv_bookid.
For readiness, you do not need to write the fix today. You need to know that this one is in the cheap pile and the not-released-API findings are in the expensive pile. That 6-versus-31 split, multiplied across 116 D-level objects, is your effort estimate in miniature.
You just watched a package go from "3,412 scary rows" to "here is what is clean, here is what blocks you, and here is the cheap-versus-expensive split." You can run this same read-only assessment against a sandbox in the workshop linked below.

Performance at scale

These figures are from the same live S/4HANA dev system, using read-only commands only.
Test setup: SID  S4H , client 100, package  ZSFLIGHT  (143 objects), variant  ABAP_CLOUD_READINESS , a single automation host.
Metric
Value
Source
Assessment of the full package
143 objects classified in about 15 seconds (~10 objects/sec)
measured
Re-run cost
read-only and repeatable, safe to run every sprint or in a pipeline
measured
Finding split (sample  ZCL_SFLIGHT_BOOKING_DAO , 37 findings)
6 cheap auto-fixable vs 31 that need real work
measured
Fifteen seconds for a package is fast enough that readiness stops being a one-time project milestone and becomes something you check continuously. Run it nightly across the estate and your D count is never more than a day out of date. The 6-versus-31 split is the planning number you actually care about: it tells you how much of a package is a button press later and how much is real engineering.

How to run it

There are four steps. The workshop has the click-by-click version.
  1. Prerequisites: the CLI on your automation host, Kiro CLI, an AWS account with Amazon Bedrock access, and a DEV or sandbox SAP connection.
  1. Connect: point a connection profile at the DEV system's ADT endpoint, and supply the SAP password from AWS Secrets Manager at runtime, never from disk.
  1. Assess: run assess across a package, or across every package, to get the A/B/C/D breakdown and the per-object findings. All read-only.
  1. Read the report: the tool writes human-readable reports and per-object findings to disk. That is your plan input.
The diagram below shows where each piece runs.

Build it in your landscape

There are two ways to wire this up, depending on how you run SAP on AWS. In both, Kiro CLI and the CLI run on a small automation host (a laptop for interactive work, or an EC2 instance for batch runs), the model is called through Amazon Bedrock, and all SAP traffic is HTTPS to the ADT REST endpoints of a development or sandbox system. Never production.

Pattern A: AWS-native (self-managed SAP on AWS)

Architecture: AWS-native. An automation host running Kiro CLI and abapctl in the customer VPC

You own the VPC and the SAP system, so the automation host talks straight to the DEV system's ADT endpoint. Use IAM on the AWS side and an SAP developer user on the SAP side, with the password pulled from AWS Secrets Manager at runtime. Reach Bedrock over a VPC endpoint (PrivateLink) so model traffic stays private, and keep the model in-region for data residency.

Pattern B: SAP RISE on AWS

Architecture: SAP RISE on AWS. The S/4HANA DEV system sits in the SAP-managed RISE VPC

In RISE, SAP runs the landscape in its own account. You run the automation host in your account and reach the development system's ADT endpoint over the connectivity path your RISE contract gives you. You do not get direct DB or OS access, and you do not need it here, because the assessment only uses the same ADT REST surface that Eclipse uses. Model inference stays in your account on Bedrock.
What differs between A and B, and you should say it out loud in your design:
  • Network path is customer-owned in A, and a shared design with SAP in B.
  • Data egress: even for a read-only assessment, ABAP source travels from the SAP-managed landscape to your account for the model to read. That is a governed decision, so document what leaves, where it is processed, and the region. On Bedrock, your prompts and completions are not used to train the base models and stay in your chosen region. Put that in the sign-off.
  • Identity spans SAP-managed access plus your AWS IAM in B.

Which model, and what it costs you

The model. The reading and explaining runs on Anthropic Claude Opus 4.8 on Amazon Bedrock, driven by Kiro CLI, which is the standard model for this workflow. For assessment, the model's value is that its explanations and effort calls are trustworthy enough to plan against. Because the model is a Bedrock setting, you can move the cost-versus-quality dial without touching the workflow.
Model on Bedrock
Relative cost/token
Quality on this task
What it means for you
Claude Opus 4.8 (standard here)
$$$
Highest
Best plain-English explanations and the most reliable cheap-vs-expensive calls
Claude Sonnet-class
$$
High
Cheaper per token, solid explanations, a little rougher on the ambiguous findings
Amazon Nova or Haiku-class
$
Lower on nuance
Cheapest and fastest, fine for bulk classification, weaker on the tricky explanations
The classification itself comes from ATC, not the model, so the level counts are the same no matter which model you pick. The model only shapes how good the explanations and effort estimates are. So this is a cost-versus-clarity choice, not a cost-versus-correctness one.

What it costs

Illustrative. Confirm live prices on the  Amazon Bedrock pricing page  and the  AWS Pricing Calculator .
  • The assessment itself is nearly free. Running assess is just ADT calls to your SAP system, a few seconds of compute, no model tokens at all for the raw classification.
  • The model cost is only for explaining and sizing. When you ask the agent to explain findings and split them into cheap-versus-expensive, a class the size of  ZCL_SFLIGHT_BOOKING_DAO  with its finding list runs on the order of a few thousand input tokens and a small output, so pennies per object, dollars for a whole package.
  • Non-model costs: the automation host (a small EC2 instance or a laptop) and normal AWS API usage.
  • The point: getting a defensible, explained, ranked readiness picture costs about the price of a coffee in inference. Compare that to the days a team spends hand-triaging the same spreadsheet.

Alternatives, and when to choose them

You have options here, and being straight about them is how you pick well.
  • SAP Readiness Check and the Custom Code Migration app. These are first-party and give you the official readiness picture. Use them for the high-level program view and the sanctioned numbers. Choose the AWS and Kiro plus Bedrock path when you want the finding-by-finding explanations and effort split in plain language, scriptable, in your own account, and repeatable from a pipeline. Most teams use both: Readiness Check for the program story, the agent for the developer-level detail.
  • Reading ATC output by hand. Maximum control, and honestly fine for one small package. It stops scaling the moment the finding count runs into the thousands, which is the whole reason Anika is stuck.
  • Rules-based scanners. Fast at spotting known patterns. They tell you what is wrong but not, in plain words, how hard it is to fix or which sanctioned replacement applies. That reasoning is where the agent adds value.

Security, data, and responsibility

  • Read-only, and non-production. Point the assessment at DEV or sandbox. It only reads, so there is no change to promote and nothing to roll back.
  • Credentials. SAP passwords come from AWS Secrets Manager at runtime, never on disk, never in logs. Use least-privilege IAM for the automation host and a scoped SAP developer user.
  • Private connectivity. Reach Bedrock over VPC endpoints. In RISE, reach ADT over the agreed private path.
  • Data handling. ABAP source is sent to the model to read and explain. On Amazon Bedrock, prompts and completions are not used to train the base models and stay in-region. Still, classify your source and get data-egress sign-off, especially under RISE.
  • Auditability. Every call is a read against your SAP system and shows up in the normal audit trail, plus a local log.

SAP authorizations you'll need

This is the part your Basis and security team cares about, and the good news is that readiness is a read-only job, so the ask is small. The technical user the assessment connects with needs read access and nothing more.
Action in the assessment
SAP authorization (typical)
Tier
Reach the ADT REST surface
active  /sap/bc/adt  ICF services (SICF) plus developer access
read
Run ATC cloud-readiness checks and read findings
ATC execution authorization
read
Read source and metadata
 S_DEVELOP  (ACTVT 03 display)
read
That is the whole list. Because assessment never writes, you can hand the whole portfolio to a read-only developer user and get your A/B/C/D picture with zero write risk. The mutating authorizations (writing code, creating transports) only come into play when you move on to actual remediation, which is a different conversation and a different post.

Try it yourself

You have seen how the assessment reads a package, sorts every object into A/B/C/D, explains what each finding means in plain words, and splits the cheap fixes from the expensive ones, all without writing a thing. Now run it against a sandbox:
 AI Assisted SAP ABAP workflows using Kiro Agents , start with Use Case 1: Readiness.
  • You'll build: a working read-only assessment against a sample package, and watch a wall of findings turn into a ranked, explained, sized plan.
  • You'll leave with: a repeatable assessment you can point at your own DEV system and run every sprint, or even wire into a pipeline as a readiness check.
  • What you need: an AWS account with Amazon Bedrock access and a dev or sandbox SAP connection. The workshop walks you through the setup, so no prior agent experience is required.
  • RISE customer? The same assessment applies. You connect over your RISE-provided path.

Wrap-up and where to go next

S/4HANA programs do not stall because teams can't find the problems. They stall because a flat list of thousands of findings is not a plan, and turning it into one by hand eats the calendar. An agentic assessment on AWS, foundation models on Amazon Bedrock reading and explaining ATC's own output, turns that pile into something you can actually commit a date to: what is clean, what blocks you, what each finding means, and how much of the work is cheap versus real.
Once you know the shape of the mountain, the next question is how to climb it fast. That is a separate job, running the fixes at scale as a governed production line, and it is the subject of the Clean Core Remediation Factory post.
  • 🏭 Ready to fix at scale? See the Clean Core Remediation Factory post in the upcoming blog post
  • 📚 Background: SAP's Clean Core Extensibility whitepaper (the A to D model) and SAP Readiness Check.

Series: AI Assisted SAP ABAP workflows using Kiro Agents (3 articles)

  1. 1
    Know your S/4HANA readiness before you commit a date: AI-assisted ABAP assessment on AWS This article
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article