Clean Core and Extensibility Types
Understand key-user extensibility, developer extensibility and side-by-side extensibility.
Explanation
S/4HANA extensibility can be understood in three broad categories. Key-user extensibility is used for simpler adaptations such as custom fields, UI changes and simple business logic without deep development. Developer extensibility is used when ABAP developers build extensions using released objects, BAdIs, CDS, RAP and APIs. Side-by-side extensibility is used when extensions are built outside the core, commonly on SAP BTP, and integrated using APIs/events. The right choice depends on complexity, coupling, lifecycle, performance and upgrade risk. A strong architect chooses the least invasive option that satisfies the business requirement.
Code example
* Extensibility decision examples:** Key-user extensibility:* - Add custom field to UI/report/API where supported.* - Simple validation or derivation.** Developer extensibility:* - Released BAdI implementation.* - RAP behavior extension.* - Released CDS/API consumption.** Side-by-side extensibility:* - BTP app using released S/4HANA APIs.* - Event-driven process extension.* - External scoring, workflow or analytics app. * Rule of thumb:* Choose the least invasive option that meets timing and business needs.Real project scenario
A custom field on sales order header was added using key-user extensibility, but a complex partner risk scoring app was built side-by-side on BTP because it consumed external data and did not need to modify the core transaction.
Common mistakes
- Using developer enhancement for simple custom field requirement. - Building side-by-side app for logic that must block save synchronously. - Ignoring lifecycle and ownership. - Using unreleased objects in developer extensibility.
Best practices
- Use key-user extensibility for simple supported changes. - Use developer extensibility for controlled ABAP extensions. - Use side-by-side for loosely coupled processes. - Avoid unnecessary core dependency.
Interview angle
Architect-level interviews often check whether you can compare key-user, developer and side-by-side extensibility.