If you are preparing for a Senior ABAP Developer, Lead Consultant, or Solution Architect screen in 2026, you already know that classical questions (such as LOOP AT ... ASSIGNING vs INTO or classic PBO/PAI flow logic) are virtually never asked in high-bracket screens (€60k–€100k+ or €800+/day contracts).
Instead, hiring committees at global systems integrators (Deloitte, Accenture, Capgemini, PwC) and enterprise clients evaluate whether you understand the Clean Core 3-Tier model, lifecycle release contracts, RAP transaction phases, and zero-debt integration patterns.
Here is the definitive architectural breakdown of the 15 questions you must master:
Part 1: Clean Core & Extensibility Governance
Question 01: Explain the Clean Core 3-Tier Extensibility Model and the boundary rules between them.
Model Answer:
The SAP Clean Core extensibility model establishes three distinct architectural tiers to isolate customer extensions from standard upgrades:
- Tier 1 (In-App Developer Extensibility): Written in ABAP Cloud (Language Version 5). Directly on-stack inside the core system, but restricted strictly to released SAP APIs (Release Contract C1/C2) and Core Data Services (CDS) view entities. It is 100% cloud-ready and upgrade-stable.
- Tier 2 (On-Stack Cloudification Repository): Quarantined custom development inside the core system that wraps unreleased SAP objects (classic BAPIs, standard tables) behind strict C1-compliant custom interfaces. It isolates technical debt into designated packages.
- Tier 3 (Side-by-Side Extensibility on SAP BTP): Autonomous custom applications hosted outside S/4HANA on SAP Business Technology Platform (BTP). Communicates strictly via public REST/OData APIs or asynchronous event streaming (SAP Event Mesh).
Question 02: A project requires reading attributes from VBAK or BSEG that are unreleased in C1 CDS views. How do you design this cleanly?
Model Answer:
Directly querying unreleased tables like VBAK or BSEG inside Tier 1 code violates Clean Core and fails syntax checks in ABAP Cloud. The recommended architecture follows a three-step evaluation:
-
Check SAP Business Accelerator Hub: Verify if a successor released CDS view exists (e.g.,
I_SalesOrderTPorI_JournalEntry). - Key-User Custom Fields Flow: If the data represents custom attributes, configure them via the Client 100 Custom Fields App, which automatically propagates values to CDS and OData views without custom SQL.
- Tier 2 Quarantine Wrapper: If no released API exists, implement a dedicated wrapper class in a Tier 2 package (Standard ABAP Level B). The wrapper executes the legacy read and exposes a strictly typed, released C1 interface to Tier 1 callers, documented via an Architecture Decision Record (ADR).
Question 03: What is the exact distinction between Release Contract C1 (System Internal) and C2 (Public API)?
Model Answer:
- Release Contract C1 (Use in System-Internal Extensibility): Guarantees API stability for extensions running on the same stack (Tier 1 ABAP Cloud). SAP guarantees that the signature, semantics, and behavior will not break during system upgrades.
- Release Contract C2 (Use as Remote API): Guarantees stability for remote clients and side-by-side extensions (Tier 3 BTP). It covers OData services and SOAP interfaces exposed over HTTP.
Part 2: RAP (RESTful Application Programming Model)
Question 04: When MUST you choose an Unmanaged scenario with Custom Save instead of a Managed RAP scenario?
Model Answer:
You must choose an Unmanaged scenario with Custom Save when your business entity relies on existing legacy transactional APIs (such as classic BAPIs or update function modules) that perform classical updates (IN UPDATE TASK) and commit sequences outside RAP runtime control.
In a Managed scenario, the RAP orchestration runtime generates and manages the complete persistence sequence. If standard tables or transactional logic cannot be fully governed by the RAP managed buffer, the Unmanaged Custom Save allows the architect to explicitly orchestrate the legacy update phase inside save_modified without violating framework contracts.
Question 05: Why is calling COMMIT WORK or ROLLBACK WORK inside RAP Determinations strictly forbidden?
Model Answer:
RAP enforces a strict separation between the Interaction Phase (where determinations, validations, and feature controls execute) and the Save Sequence (finalize, check_before_save, adjust_numbers, save_modified).
Calling COMMIT WORK during determinations prematurely commits database buffers, invalidates transactional isolation, releases SAP enqueue locks before validations are complete, and causes fatal ST22 runtime dump COMMIT_IN_POSTING.
Question 06: Compare Early Numbering vs. Late Numbering in RAP business entities.
Model Answer:
-
Early Numbering: The primary key is generated immediately during the
CREATEoperation (usually a UUID viacl_system_uuid). Essential for draft-enabled entities so child items can reference the parent entity across multiple user interactions before final save. -
Late Numbering: The final business key (such as an incremental document number from a classical Number Range interval) is assigned at the very end of the transaction inside the
adjust_numberssave phase. This guarantees gapless numbering and avoids burning range numbers when a transaction is aborted.
📘 Fast-Track Your Interview Preparation
If you are preparing for high-bracket technical screens, these scenarios are drawn directly from the SAP Clean Core & ABAP Cloud Technical Interview Kit (Senior & Lead Edition).
The complete kit includes:
- 50 Real-World Enterprise Scenarios & Model Answers (Governance, RAP, APIs, Concurrency & Boardroom Case Studies)
- The "Interview Morning" 1-Page Emergency Cheat Sheet (10 golden rules to review 30 minutes before your call)
- Seniority Self-Assessment Rubric (Junior to Solution Architect)
Claim a 20% discount with launch coupon
LEAD2026at checkout.
Part 3: Cloud Integrations & Resiliency
Question 07: How do you guarantee idempotency and handle HTTP 429/5xx transient errors without classical LUW commits?
Model Answer:
Modern cloud integrations must adhere to two architectural patterns:
- The Transactional Outbox Pattern: Never trigger external HTTP requests synchronously inside transactional save sequences. Instead, write an outbound message record to a persistent database Outbox table within the same commit.
- Exponential Backoff with Full Jitter: Outbound background workers polling the Outbox must compute randomized retry delays to prevent the "thundering herd" problem when an external endpoint returns HTTP 429 (Rate Limited):
" Exponential Backoff with Jitter pattern in ABAP Cloud
DATA(lv_delay_ms) = lv_base_delay_ms * ( 2 ** ( lv_attempt - 1 ) ).
DATA(lv_jitter_ms) = cl_abap_random_int=>create(
seed = cl_abap_context=>get_uuid( )
min = 0
max = lv_max_jitter_ms )->get_next( ).
DATA(lv_total_sleep) = ( lv_delay_ms + lv_jitter_ms ) / 1000.
Question 08: How does GDPR / PII data masking work in ABAP Cloud integration logging?
Model Answer:
When logging external REST/JSON payloads for observability, personal identifiable information (PII) like IBANs, credit cards, emails, and authorization tokens must be obfuscated before writing to database logs. In ABAP Cloud, utilities apply cloud-safe PCRE regex to mask sensitive keys in JSON payloads while preserving debugging structure.
Part 4: Senior Architectural Dilemmas
Question 09: When should logic be placed on SAP BTP (Tier 3) vs. In-App ABAP Cloud (Tier 1)?
Model Answer:
Evaluate based on Data Locality and Lifecycle Coupling:
- Keep In-App (Tier 1): High-volume data processing that requires direct join capabilities with S/4HANA transactional tables (e.g., custom financial ledger validations). Transferring millions of rows to BTP creates costly network egress and latency.
- Push to BTP (Tier 3): Multi-channel customer-facing apps, independent microservices, integrations with non-SAP platforms, heavy AI/LLM workloads (GenAI Hub), or applications with release cycles decoupled from S/4HANA release schedules.
Question 10: How do you prevent ST22 memory exhaustion dumps in ABAP Cloud high-volume processing?
Model Answer:
In ABAP Cloud, classical statements like FREE MEMORY are eliminated. Memory safety requires:
- Streaming queries using modern CDS Cursor fetching or ABAP internal table package batching (
PACKAGE SIZE 5000). - Utilizing memory-efficient CDS View Entities with strict projection lists rather than
SELECT *. - Decoupling bulk operations into asynchronous background jobs via the Application Jobs framework (
CL_APJ_RT_API).
Conclusion & Open-Source Code
All code examples and Clean Core retry utilities (ZCL_CC_RETRY) referenced in this guide are available in the open-source repository:
👉 GitLab: https://gitlab.com/22andrea/abap-clean-core-kit
Top comments (0)