Developing SAP S/4HANA Add-ons and SAP Fiori Tools with ABAP and SAP BTP

Developing SAP S/4HANA Add-ons and SAP Fiori Tools with ABAP and SAP BTP

This guide offers a step-by-step walkthrough for developing custom add-ons and tools for SAP S/4HANA and SAP Fiori. It covers the essential concepts and technologies: SAP ABAP for the backend, SAP Business Technology Platform (SAP BTP) for cloud services, and SAP Fiori/SAPUI5 for the user interface. We'll also dive into setting up your development environment, building ABAP extensions and Fiori apps, integration methods, monetization strategies, and best practices. Designed for developers with intermediate knowledge, this content provides detailed explanations, sample code, and clear screenshots to simplify your learning journey.

1. Introduction to SAP Add-on Development

Overview of SAP S/4HANA and SAP Fiori:

SAP S/4HANA is SAP's next-generation ERP business suite, running on the SAP HANA in-memory database. It leverages modern data processing innovations and a simplified data model to deliver real-time analytics and optimized business processes.

SAP Fiori is SAP's modern user experience (UX), comprising web-based applications developed with SAPUI5. It offers intuitive, role-based user guidance across various devices and is increasingly replacing the classic SAP GUI as the primary user interface in SAP S/4HANA.

Instead of monolithic transaction screens, Fiori offers a collection of focused apps (tiles) for specific tasks, like creating a sales order or approving leave requests. You can access these apps through the Fiori Launchpad. By consistently following design guidelines and leveraging a responsive, HTML5-based approach, Fiori significantly boosts usability and productivity.

Importance of Add-ons and Tools:

Every business has unique requirements. Add-ons (custom extensions or plugins) and tools (individual applications, reports, integrations) allow organizations to tailor standard SAP S/4HANA to their specific needs without modifying the core SAP code. By developing add-ons, companies can bridge functional gaps, automate custom processes, or boost user productivity.

SAP offers official extension mechanisms, letting custom code adapt the system to specific requirements while keeping the core stable. Well-designed add-ons help maximize the ROI of an SAP implementation by adapting to business processes and evolving independently of SAP upgrades, which helps maintain a 'clean core.' In the SAP ecosystem, a robust add-on can even become a standalone product that others can reuse or acquire – a great incentive for partners and developers to drive innovation on the platform.

Central Technologies

• SAP ABAP: ABAP (Advanced Business Application Programming) is the primary programming language for the SAP S/4HANA backend. ABAP runs on the ABAP Application Server and is used to develop custom reports, transactions, data dictionary objects, enhancements, and business logic. In S/4HANA (on-premise and private cloud), ABAP remains central for extensions.

ABAP is also available in SAP BTP (via the ABAP Environment, also known as "Steampunk") for developing cloud-based extensions with a "clean core" approach. ABAP's deep integration with the database (including ABAP Core Data Services for advanced views) and its numerous frameworks (BAPIs, Enhancement Spots, etc.) make it a powerful tool for enterprise development.

• SAP Business Technology Platform (BTP): SAP BTP is the cloud platform that provides services and environments for developing and running applications that extend or integrate SAP systems. It includes various runtime environments (Cloud Foundry, ABAP Environment, Kyma, etc.), as well as services for authentication, databases, integration, analytics, AI, and more.

For our purposes, BTP enables the deployment of custom applications (e.g., a Fiori UI5 app or an ABAP service) in the cloud and their connection to an S/4HANA system (on-premise or cloud). It supports the development of extension applications without impacting the on-premise system, aligning with SAP's "clean core" strategy. In summary, BTP provides the infrastructure and services for developing cloud applications, integrations, and innovations based on SAP solutions.

• SAP Fiori/UI5: SAP Fiori is the UX framework, and SAPUI5 is the underlying frontend technology (a JavaScript UI toolkit) for developing responsive web applications. Fiori apps are web applications that follow SAP's Fiori design guidelines for consistency and user-friendliness. They retrieve business data via OData services from the SAP backend and present it in intuitive user interfaces.

SAPUI5 (and its open-source variant OpenUI5) is the HTML5 framework used to develop these apps. Understanding Fiori requires knowledge of developing SAPUI5 applications (controllers, views, models) and deploying them either on an SAP Frontend Server (for on-premise Fiori) or on SAP BTP (for cloud deployments). In practice, developers use tools like SAP Web IDE or SAP Business Application Studio to build UI5 apps and make them available to users via the Fiori Launchpad.

By mastering ABAP, SAP BTP, and Fiori/UI5, a developer can build powerful end-to-end solutions:

• ABAP for custom business logic and data processing,

• Fiori/UI5 for the user interface,

• SAP BTP for cloud deployment and integration.

2. Setting Up Your Development Environment

Before development can begin, it is essential to set up a suitable SAP development environment. This includes Access an SAP S/4HANA system for ABAP development, the installation of the necessary IDEs and tools, and the provision of cloud resources on SAP BTP for the development and deployment of Fiori apps.

Required Software and Tools

The following table summarizes the key components you'll need to install or access:

Tool / Component

Purpose

SAP S/4HANA System (Developer Access)

An SAP S/4HANA instance with ABAP development access. This could be an on-premise installation or a sandbox/test system. It serves as the backend for creating custom tables, ABAP programs, OData services, and so on.

SAP GUI for Windows (and/or SAP Business Client)

Traditional desktop client for logging into SAP systems. Required for using classic SAP development transactions (SE11, SE80, SE38, etc.) and verifying backend functionality. The latest SAP GUI versions support S/4HANA and include SAP Logon for managing connections.

Eclipse IDE with ABAP Development Tools (ADT)

Modern IDE for ABAP development. ABAP Development Tools is an Eclipse plugin that provides an ABAP-specific development environment for coding, designing CDS views, debugging, version control (transports), and so on. This is essential for working with advanced features like ABAP CDS and new programming models. You can download Eclipse (e.g., Eclipse 2023-xx) and add the ADT plugin via the update site https://tools.hana.ondemand.com.

SAP Business Technology Platform (BTP) Account

An SAP BTP account (either a free trial or an enterprise account) is needed to use cloud services. Within BTP, you'll create a subaccount, activate services like SAP Business Application Studio or SAP Web IDE, and configure destinations for connecting to your S/4HANA system. The BTP Cockpit is the web interface for managing these resources.

SAP Business Application Studio (BAS) or SAP Web IDE

Cloud-based IDEs for developing SAPUI5/Fiori apps. BAS is the newer, container-based dev environment on BTP, offering a desktop-like experience right in your browser (and it's replaced Web IDE). Web IDE Full-Stack is an older (now deprecated) tool that also runs in the cloud or on-premise, providing templates and wizards for Fiori development. You'll use one of these environments to build and deploy your Fiori/UI5 app.

SAP Cloud Connector (optional, for on-premise integration)

If your S/4HANA system is running on-premise, the SAP Cloud Connector acts as a small on-premise component to establish a secure link between the SAP BTP cloud and your local network. This works hand-in-hand with BTP destination configurations to let your cloud apps securely talk to on-premise S/4HANA OData services.

Installing SAP GUI and ABAP Development Tools

To install SAP GUI, grab the installer (SAP GUI for Windows 7.70 or 8.00) from the SAP Marketplace (you'll need an S-User ID) or use a test environment that already has it. The installation is wizard-driven. Once it's installed, set up a connection to your SAP S/4HANA system in SAP Logon (you'll need the application server host, system number, and client). After connecting, you can open SAP GUI and jump into transactions like SE11 (Data Dictionary), SE38 (ABAP Editor), and so on.

For ABAP in Eclipse (ADT), first install a supported Eclipse IDE on your machine (like Eclipse IDE for Java Developers). SAP suggests using the latest stable Eclipse version. After Eclipse is installed, add the ABAP Development Tools Plugin:

1. Open Eclipse and head to Help > Install New Software.

2. Enter the update site URL for ADT (e.g., https://tools.hana.ondemand.com/latest).

3. Pick ABAP Development Tools from the list and continue with the installation.

4. After a restart, open the ABAP Perspective in Eclipse.

5. In the ABAP Perspective, create a new ABAP Project by connecting to your S/4HANA system (you can do this either via an SAP Logon entry or by manually entering the connection parameters).

6. From there, you can browse ABAP packages and objects in Eclipse and handle development tasks with advanced features like syntax checking, code completion, debugging, and Git integration via abapGit.

Setting Up SAP BTP

If you don't have an SAP BTP account yet, go ahead and sign up for an SAP BTP Trial or Free-Tier version. Once you've got a global account on SAP BTP, open the SAP BTP Cockpit in your web browser and do the following basic configuration:

1. Create a Subaccount

• The Subaccount is basically an isolated environment (Region + Platform).

• Pick a Region (like Europe Frankfurt) and a Subaccount Name.

• Choose the Entitlements (services) you want to use (e.g., SAP Business Application Studio, Portal Service (Launchpad), Destination Service, Cloud Connector, and so on).

2. Space (Cloud Foundry Runtime)

• If you're using the Cloud Foundry Runtime (for deploying HTML5 apps, for example), enable Cloud Foundry and create an Organization and Space within your Subaccount.

• This is a must if you want to use certain services or deploy web applications.

3. Tools & Services

• Head over to the Service Marketplace in your Subaccount and enable the SAP Business Application Studio (BAS) or SAP Web IDE service.

• If you're using BAS, create a Service Instance (Dev Space) of type SAP Fiori (it comes pre-configured with SAPUI5 tools).

• If you're using Web IDE, activate the subscription for SAP Web IDE Full-Stack and launch it from the BTP Cockpit.

4. Set up Destinations

• If your Fiori app needs to fetch OData services from S/4HANA, set up a Destination in the BTP Cockpit.

• Go to Connectivity > Destinations and configure a new Destination using the URL to your S/4HANA system's OData endpoint (e.g., SAP Gateway Server URL), authentication details (OAuth or Basic Auth with a technical user), and so on.

• If your S/4 system is on-premise, you'll also need to set up the SAP Cloud Connector to map the on-prem host to an accessible virtual host.

• To do this, install the SAP Cloud Connector on a server in your network and log in with your BTP account to establish the connection.

Destinations are essential, as they enable cloud applications to consume secure on-premise OData services via SAP's connectivity layer.

Configuring the Fiori/UI5 Development Environment

Once BAS or Web IDE is activated, configure your Fiori development environment:

• In SAP Business Application Studio (BAS)

• Open your Dev Space, which already includes the SAPUI5 SDK and the necessary tools.

• If needed, import relevant SDKs or set up a Git repository for your project.

• BAS is usually pre-configured for Fiori development.

• In SAP Web IDE

• Launch Web IDE via the BTP Cockpit (Service > SAP Web IDE > Open Web IDE).

• No local installation is required, as it runs directly in your browser.

• Check that the Destination to the S/4HANA system is correctly configured (Web IDE uses the Destinations defined in the BTP Cockpit to discover OData services).

• Ensure SAPUI5 Library Version

• Make sure you have access to an SAPUI5 version that matches your S/4HANA Fiori frontend version.

• In BAS/Web IDE, you can select the SAPUI5 version (e.g., 1.108 or 1.96, depending on your S/4HANA version).

• Alternative On-Premise Development for UI5

• If you prefer on-premise development, you could alternatively install the SAP Web IDE Personal Edition locally.

• You can also use any other IDE and work with the UI5 CLI tools.

• However, using the SAP Cloud IDEs is recommended, as they offer seamless integration with SAP systems.

Your development environment is now ready

With this setup, you'll have:

✅ ABAP Development Access (via SAP GUI and Eclipse ADT) for backend development

✅ SAP BTP with a Fiori development environment (BAS or Web IDE) for UI development

In the next sections, we'll develop ABAP add-ons and Fiori apps using this environment. 🚀

3. Developing SAP Add-ons with ABAP

SAP ABAP is used to extend S/4HANA by creating custom objects and enhancing standard functionalities. In this section, we'll cover the core ABAP development tasks:

• Creating custom tables and function modules,

• Developing reports and transactions,

• Utilizing enhancement frameworks (BADIs and User Exits) to modify standard behavior,

• Creating ABAP Core Data Services (CDS) Views.

We assume you're familiar with the SAP development environment (SE11, SE80, etc.).

ABAP Development Concepts

In SAP, development objects (like programs, tables, data elements, classes, etc.) are typically created in the ABAP Workbench (SE80) or using the Eclipse-based ADT (ABAP Development Tools). ABAP follows a modular approach:

• Data structures are created in the ABAP Dictionary (transaction SE11). These include tables, data elements (field definitions), structures, views, and search helps.

• Reusable logic can be encapsulated in function modules (SE37), class methods (SE24 for classes), or BAPIs.

• Reports (executable programs) are created via SE38 or in Eclipse ADT (REPORT or PROGRAM statement). Transactions (T-codes) are set up via SE93 to make these programs or function modules executable for end-users.

• SAP enhancement techniques (User Exits, Customer Exits, BADIs, Enhancement Spots) allow you to insert custom logic into standard SAP processes without modifying the original code.

• ABAP CDS Views are defined in Eclipse ADT as .ddl source files, offering a powerful way to create data models and expose them for OData.

We'll cover these aspects step-by-step below.

Creating a Custom Table and Function Module

Creating a Custom Table

Let's say we want to create a custom database table to store company-specific data, like 'Customer Revenue by Region'. To do this, we'll use transaction SE11 (ABAP Dictionary) and follow these steps:

1. Open SE11 and select Database table. Enter a name for the new table (e.g., ZCUST_REV – custom objects usually start with 'Z' or 'Y') and click Create.

2. Enter a short description for the table, choose a delivery class (e.g., 'A' for application tables), and define the table maintenance attributes (e.g., whether entries can be maintained via SM30).

3. In the 'Fields' tab, define the table fields:

• Field Name

• Data Element or Predefined Type

• Length

• Key Field (Primary Key)

• Example Fields:

• ZCUST_NO (Customer Number, NUMC(6), Key Field)

• ZREGION (Region, CHAR(3), Key Field)

• ZREVENUE (Revenue, DEC(15,2))

• If no predefined data elements are available, you can use the 'Predefined Type' button to define types directly.

4. Define technical settings (configure Data Class and Size Category via the 'Technical Settings' button) to define the database storage parameters.

5. Save and activate the table – Activation creates the physical table in the database. Afterward, you can access it via SE11 or SE16/SE16N to enter test data.

Figure: Defining a custom table in the ABAP Dictionary (SE11). In this example, the table ZCUST_REV is created with fields (e.g., Customer Number). The developer specifies the name, data type (NUMC with length 6 for the customer number), and key flag for each field. These custom tables allow for the persistent storage of application-specific data within the S/4HANA database.

Once the table is activated, it can be written to by ABAP programs, or a maintenance dialog can be created for users to edit entries. Custom tables are transported across systems using Workbench transports.

Function Module

To create a reusable function (like one for calculating a bonus or querying aggregated data), you'll use SE37 (Function Builder):

1. Open SE37, choose Create Function Module, and give it a name (e.g., ZCALC_BONUS) within a custom function group (functions live in groups). Also, provide a short description.

2. Define import parameters, export parameters, and exceptions in the upper section of the Function Builder. These parameters make up the function's interface.

3. Implement your ABAP logic in the Source Code section. For instance:

• Import an employee ID

• Query the database for sales data

• Calculate a bonus

• Return the bonus amount as an export value

4. Save and activate the function module. It can now be called from any ABAP program or exposed as a remote-enabled API (RFC).

Function modules can also serve as User Exits (SAP sometimes provides empty function modules that are called during specific events and filled by customers). Plus, they can be integrated into OData or SOAP services and exposed to external systems.

Developing a Custom Report and Transaction Code

Creating a Custom Report and Transaction Code

Custom Report

ABAP reports are standalone executable programs often used for data queries, simple outputs, or batch jobs. To create a report:

1. Open SE38 (ABAP Editor) and create a new program (Type: “Executable”).

2. Alternatively, you can create a new ABAP program in Eclipse ADT.

A simple report listing customers and their revenues might look like this:

REPORT zcustomer_revenue_report.

TABLES: zcust_rev.  " declare usage of the custom table

SELECT zcust_no AS Customer, SUM(zrevenue) AS Total_Revenue
  FROM zcust_rev
  GROUP BY zcust_no
  INTO TABLE @DATA(lt_rev_by_cust).

LOOP AT lt_rev_by_cust INTO DATA(ls_line).
  WRITE: / ls_line-Customer, ls_line-Total_Revenue.
ENDLOOP.

This program performs a SELECT query on the custom table to aggregate revenue by customer. Then, it outputs the results in a loop. In practice, reports are often built with ALV Grid Display for a better UI and selection screens for user input (using PARAMETERS or SELECT-OPTIONS in the code).

After creating the report, it needs to be activated. You can run it directly in SE38 or via SA38 by entering the program name.

If end-users need to easily launch this report, you can create a transaction code:

1. Open SE93 (Maintain Transactions).

2. Select Create and enter a transaction code (e.g., ZCUST_REV_REP).

3. Choose “Program and selection screen” as the transaction type and link the transaction to your report program.

4. Save the transaction – users can then execute the report via this transaction code from the SAP Easy Access menu.

Custom transactions can also be integrated into user menus or roles, so they appear in the SAP Fiori Launchpad (as GUI transactions) or the SAP GUI Easy Access menu.

Extending SAP Standard Functionality (BADIs and User Exits)

SAP offers extension mechanisms that let you execute custom code at predefined hook points within standard programs. This ensures that SAP standard code isn't modified (which would make future upgrades a pain), while still allowing you to inject your own logic. The two most common extension techniques are User Exits (including Customer Exits) and BADIs (Business Add-Ins):

User Exits / Customer Exits

These are classic (mostly procedural) extension techniques. A User Exit is a subroutine or function module that SAP calls at specific points in a program. By default, these exits don't do anything, but customers can implement them.

📌 Example:

In the SD module, the User Exit MV45AFZZ lets you insert custom checks during sales order processing.

How to implement a User Exit:

1. Find the relevant SMOD/CMOD enhancement. SAP often groups several exits into an SMOD enhancement under a specific name.

2. Open CMOD, create a project, assign the relevant enhancement, and then insert your code into the designated includes or function modules.

3. After activation, your custom code will be automatically executed as part of the standard process.

➡ User Exits often require code within includes or function modules that SAP has defined as exit points.

BADIs (Business Add-Ins)

BADIs are a more modern, object-oriented extension technique. A BADI is an interface with one or more methods that SAP provides at a specific point in the code. Developers can create one or more implementations of this interface to run their custom code.

BADIs are managed using transactions SE18 (for definitions, provided by SAP) and SE19 (for implementations, created by customers). SAP provides BADI definitions (e.g., there's a BADI to extend invoice posting). The developer then creates a BADI implementation, where they implement the logic within one of the offered methods.

Key differences between User Exits and BADIs:

✅ User Exits are older, procedural methods that are often more limited (e.g., embedded in includes).

✅ BADIs are fully object-oriented and can have multiple implementations (some BADIs even allow parallel or filter-dependent implementations).

Implementing a BADI – Step by Step

1. Finding the Right BADI Definition

• Use SE18, SAP documentation, or the 'Where Used' search in SAP GUI with the term 'BADI'.

• In newer systems, many enhancements are managed via Enhancement Spots, which can contain multiple BADIs.

2. Creating a New Implementation in SE19

• Open SE19, create a new BADI implementation, give it a name, and select the appropriate BADI definition.

3. Creating the Class for the Implementation

• The system will prompt you to create a class that implements the BADI interface.

• In this class, you write the custom logic in the provided methods.

4. Activate BADI Implementation

• Once the implementation is active, your code will automatically execute when the standard program calls the BADI via CALL BADI or the Enhancement Framework.

• If there are multiple implementations, either all of them will run in parallel or only the matching implementation will execute based on a filter condition – it all depends on the BADI configuration.

Example of a BADI Implementation

Let's say SAP's standard invoice posting uses the BADI BADI_INVOICE_POST with the method CHECK_DATA, which is called for data validation before the invoice is posted.

➡ A developer could implement this BADI to perform additional checks, for example:

✅ Checking a custom table for specific rules

✅ Reconciling with an external system before the invoice is posted

📌 Important:

The BADI mechanism ensures that custom code runs without altering SAP's standard logic, allowing for a flexible and maintainable extension of SAP functionality.

📖 According to official SAP documentation:

“BADIs (Business Add-Ins) are a powerful mechanism in ABAP for extending standard SAP functionality without modifying the core code. They provide a flexible and maintainable way to customize SAP applications.”

Similarly, User Exits allow for enhancements at predefined points (e.g., at the end of form routines, etc.). Both techniques can be used within a project:

📌 Example: A User Exit is used to add a new field to a screen, while a BADI is used to populate the value for that field.

Steps to Implement a User Exit (Quick Overview)

1. Identify the Exit – via SAP Notes or development documentation.

• For example: An SAP SD exit for sales orders might be found in program MV45AFZZ.

2. Call CMOD → Create a project → Assign the relevant enhancement (an enhancement groups related exits).

3. For each component of the enhancement (e.g., an include or function module), click on Components and navigate to the corresponding include.

• Write your custom code within the include (between FORM…ENDFORM or as specified).

4. Activate the project – The code in the includes will now execute as part of the standard SAP process.

Steps to Implement a BADI (Quick Overview)

1. Find the BADI name

• Check via SE18 or by debugging/SQL trace if GET_INSTANCE is called for a specific process.

2. Open SE19 → Create a new BADI implementation → enter the BADI definition.

3. Specify an implementation class (or use the default one) and navigate to the Class Editor.

4. Write code in the method

• Example: If the CHECK_DATA method has import parameters, you can implement a check, set an export flag if necessary, or raise an exception.

5. Activate the implementation.

Additional BADI Options

Many BADIs come with a filter option, which means the implementation can be restricted to specific criteria (like company code or country). You'll find these settings in the BADI implementation configuration.

Extension Framework in SAP (ECC 6.0 and S/4HANA onwards)

With ECC 6.0 and S/4HANA, SAP rolled out Implicit and Explicit Enhancements.

These let you inject enhancements into specific coding blocks or at the start/end of form routines.

📌 These are managed directly in the ABAP Editor using the "Enhance" option, offering another way to extend standard or custom code.

📢 However, for medium-sized development projects, BADIs and User Exits are the most commonly used techniques and should be the focus.

Creating and Deploying ABAP CDS Views

ABAP Core Data Services (CDS) Views are a core component of S/4HANA development and play a crucial role in SAP's strategy for in-memory optimized programming.

📌 CDS Views let you push complex logic and calculations directly to the HANA database layer. This means they can be efficiently reused in user interfaces (Fiori) or integration scenarios.

➡️ CDS Views are defined in ABAP using an Eclipse-based editor.

➡️ They use a declarative, SQL-like syntax and, once activated, integrate with the ABAP Data Dictionary.

Key Features of CDS Views

✔️ CDS Views are defined using the syntax DEFINE VIEW within a DDL source file.

• They can reference base tables or other views,

• Apply filters, joins, associations, and even simple calculations.

✔️ CDS Views support annotations – metadata that:

• Exposes the view as an OData service,

• Controls UI behavior in Fiori Elements.

✔️ Once activated, a CDS View generates:

• A SQL view in the HANA database,

• A runtime object in ABAP that can be used like a table in ABAP programs via a SELECT query.

Creating a CDS View (Step-by-Step)

1️⃣ In Eclipse ADT:

• Create a new ABAP DDL source document (e.g., ZCUST_REVENUE_VIEW).

• A transport request and a package need to be selected depending on the project.

2️⃣ Using CDS syntax to define the view.

• Example:

@AbapCatalog.sqlViewName: 'ZCUSTREVV'  
@AbapCatalog.compiler.compareFilter: true  
@OData.publish: true  
define view ZCUST_REVENUE_VIEW 
  as select from zcust_rev 
{
    zcust_no,
    zregion,
    sum( zrevenue ) as total_revenue
}
group by zcust_no, zregion

This defines a CDS view that aggregates the custom table by customer and region and sums up the revenue.

The annotations used here specify the corresponding SQL view name and enable the OData expose function.

📌 @OData.publish: true would automatically generate an OData service for this view in SAP S/4HANA.

Steps after defining the CDS View

1️⃣ Activate CDS View

• Activation creates the database view and makes the OData service available.

• If OData is used, SAP automatically generates a service in the background, which you can find in transaction /IWFND/MAINT_SERVICE and activate for use.

2️⃣ Test CDS View

• Perform a data preview in Eclipse or

• Call up the generated SQL view in SE16.

CDS Views as a Multi-Layered Architecture

CDS Views can be divided into layers:

📌 Basic Layer → Composite Layer → Consumption Layer (Consumption Views).

✅ CDS Views are heavily utilized in S/4HANA – many pre-configured S/4HANA analytics and Fiori elements are based on them.

✅ A big advantage is that a CDS view can be exposed as an OData service with just a few annotations.

• This often eliminates the need for manual creation of an OData service for simple read operations – the platform automatically generates this.

Deployment and Transport of CDS Views

• Once created, CDS Views can be transferred to other systems using standard SAP transports.

• CDS Views are objects of type R3TR DDLS and can be transported from DEV to QA and Production once they've been developed and tested.

Summary

ABAP development for add-ons typically includes:

✔ Creating custom Dictionary objects (tables, data elements),

✔ Writing ABAP programs or extending existing ones,

✔ Utilizing ABAP frameworks like CDS and Enhancement Spots to enhance standard functionalities in an upgrade-safe way.

4. Developing Fiori Applications with SAP BTP

In this section, we'll switch gears to frontend development:

📌 SAP Fiori applications using SAPUI5.

These applications run in your web browser (or the Fiori Launchpad) and talk to the SAP S/4HANA backend via OData services.

➡ We'll be using SAP's cloud-based development environments (SAP Web IDE or SAP Business Application Studio on SAP BTP) to create, test, and deploy a Fiori app.

Overview of the SAP Fiori/UI5 Architecture

An SAP Fiori application typically follows a client-server model:

✔ Client-side → The SAPUI5 app (an HTML5/JavaScript application) runs in the browser and handles the user interface and interactions.

✔ Server-side →

• The SAP S/4HANA system (or an SAP BTP ABAP environment) provides business data via OData services.

• The SAP Gateway component (integrated into S/4HANA) publishes these OData REST endpoints, which the UI5 app then uses to create, read, update, or delete data (CRUD operations).

SAP Fiori Launchpad – The Central Entry Point

SAP Fiori apps are launched from the SAP Fiori Launchpad.

📌 The Launchpad is a web platform that acts as a central homepage, featuring tiles for each app.

✔ Each tile represents a Fiori app (or a link to a classic GUI transaction).

✔ The tile is linked to an OData service and a UI5 component name.

✔ When a user clicks a tile, the UI5 app loads in the browser and calls the OData services in the backend to fetch or send data.

🔹 Fiori apps are role-based:

• Users only see the apps they're authorized for.

• Authorizations control which actions are possible within the app.

Architecture: UI and backend separation via OData

Fiori uses a decoupled model where the UI is separated from the backend by OData services:

✅ The same OData service can serve multiple UIs (web UI, mobile UI, etc.).

✅ The UI doesn't communicate directly with the database, but rather via defined service APIs.

Summary

➡ “SAP Fiori apps are developed with SAPUI5, launched via the SAP Fiori Launchpad, and retrieve business data from the SAP S/4HANA backend using OData services.”

✔ The architecture is stateless (each OData call is independent → better scalability).

✔ Modern concepts like “Draft Handling” for long-running transactions are supported.

Let's develop a Fiori app now – step by step. 🚀

Creating a Fiori App with SAP Web IDE / Business Application Studio

In this example, we're using SAP Web IDE (Full-Stack) to develop a Fiori app.

📌 The steps are very similar in SAP Business Application Studio (BAS).

Step-by-step guide to creating a Fiori app

1️⃣ Start SAP Web IDE

• Open SAP Web IDE via the SAP BTP Cockpit (make sure it was activated beforehand, as described in Section 2).

• The web-based development environment should now be visible.

• Select File > New > Project from Template to start the project wizard for a new Fiori app.

• (In Business Application Studio: Open a Dev Space and use the command “Fiori: Create Project” or the Yeoman templates.)

2️⃣ Select Project Template

• SAP Web IDE offers predefined project templates, for example:

• SAP Fiori Worklist Application

• SAPUI5 Application

• Master-Detail Application

• For example, select the SAP Fiori Master-Detail Application and click Next.

3️⃣ Configure Project

• Enter a project name (e.g., CustomerRevenueApp).

• If required, define a namespace.

• Select the data source for the app:

• If an OData service already exists (e.g., a previously created CDS View or an SAP standard service), select Service Catalog.

• Then select the pre-configured destination and the OData service from S/4HANA.

• The wizard automatically retrieves the service metadata.

• Select the Entity Set to be displayed in the app (e.g., an entity for customer revenues).

4️⃣ Complete Wizard

• The Web IDE now generates a complete project with all necessary files:

• Controller (JavaScript)

• Views (XML)

• i18n texts (multilanguage support)

• manifest.json (application description)

• This generated project is ready to run and can be tested immediately.

5️⃣ Run and Test App

• Right-click on the newly created project folder and select Run > Run as Web Application.

• This opens a new browser tab with a test URL (often Port 8080 for local tests or an FLP sandbox mode in the cloud).

• The app loads and calls the OData service (via the configured destination).

• If everything is set up correctly, you'll now see real data from your backend, e.g.:

• A customer list

• A detail page with revenue data for each customer.

6️⃣ Further Develop the App

• Now you can customize the generated code:

• Open the View XML files to change the UI layout or labels.

• Edit the Controller JS files to add additional logic (e.g., input validation, dynamic navigation).

• Customize the i18n property files to localize texts.

• Add new UI elements (charts, tables, filters) using SAPUI5 controls and bind them with OData data.

Typical development tasks in a Fiori app

✅ Data formatting (using formatters in UI5).

✅ Navigation between views (if not included in the template).

✅ Custom OData calls – method calls for actions like approvals or data changes.

✅ Performance optimization

• Using $select or $expand in OData queries to minimize the data load.

Debugging and testing during development

🛠 During development, we often:

✔ Use the browser console (Chrome DevTools) for debugging.

✔ Utilize the UI5 debugging tools.

✔ Use the Fiori Launchpad Sandbox mode in SAP Web IDE or BAS to test multiple apps in a simulated Launchpad environment.

🚀 Next Step: Further develop the Fiori app and deploy it for productive use!

Figure: Example of an SAP Fiori Launchpad homepage with tiles
Each tile (square icon) represents a Fiori app or a business task (e.g., managing orders, team calendar). The Fiori Launchpad provides a role-based, personalized entry point for end-users.
Clicking a tile launches the SAPUI5 app, which then interacts with the S/4HANA backend via OData services.

Connecting the Fiori app to the SAP S/4HANA backend

For the Fiori app to display real-time data or execute transactions, it needs to communicate with SAP S/4HANA.

➡ This happens via OData services.

📌 In our environment, an SAP BTP destination for the S/4HANA OData service has been configured.

📌 When the UI5 app runs from the BTP environment, it uses this destination to communicate with the backend.

Key steps for integration

✔ Activate OData service in S/4HANA

• Use /IWFND/MAINT_SERVICE to activate the OData service.

• If a CDS view with @OData.publish: true was created, the corresponding ZCUST_REVENUE_VIEW_CDS service needs to be activated.

✔ Define the data source in the Fiori app's manifest.json

• In SAP Web IDE on BTP, you'll often see a route like /destinations/YourDestinationName/ used in the OData service URL.

• This allows the call to be made via the SAP Cloud Connector/Destination setup to reach the on-premise system.

✔ Leverage BAS and SAP Launchpad Service

• If you're using BAS and deploying the app to SAP Launchpad Service, the destination needs to be mapped similarly.

• During development, you can test the app in a “mock” environment or with a proxy.

✔ Test the integration

• Use tools like your browser's network analysis or the SAP Gateway error logs (/IWFND/ERROR_LOG) to debug issues (e.g., missing authorizations or service errors).

• If needed, you might have to adjust OData calls or add $metadata requests.

📌 Example:

When the app loads a customer list, it sends an OData request to:

➡ .../ZCUST_REVENUE_VIEW_CDS/CustomerRevenueSet

➡ SAP Gateway receives the request, executes the CDS view, and sends the data as a JSON response to the UI5 app.

🔒 Security Aspect:

✔ The user configured in the BTP destination needs a PFCG role in S/4HANA that grants access to the OData service and entity set.

Deploying a Fiori App on SAP BTP

After development and testing, the Fiori app needs to be deployed so that end-users can access it.

There are two common deployment scenarios:

1️⃣ Deployment on SAP BTP (Cloud Foundry) as an HTML5 Application

➡ In SAP Web IDE, you'll find the option Deploy > Deploy to SAP Cloud Platform.

✔ This packages the UI5 app and deploys it as an HTML5 application in the Cloud Foundry space of your BTP subaccount.

✔ Once deployed, the app can be accessed via a URL or integrated into the SAP Launchpad Service (Portal).

📌 Deployment Steps:

1. In SAP Web IDE:

• Select Deploy to SAP Cloud Platform and log in with your BTP Access data.

2. Select Target Environment:

• Choose Subaccount and Cloud Foundry Space.

• Specify the OData destination so the app in the cloud can find the correct connection to S/4HANA.

• After deployment, the app appears in the HTML5 Applications section of the BTP Cockpit.

3. Integrate the App into the Fiori Launchpad:

• In the BTP Cockpit, navigate to Services > Launchpad (Site Manager).

• Create a new site or use an existing one.

• Add a new app in the Content Manager:

• Assign a title

• Select Cloud Foundry HTML5 App as the storage location

• Select the newly deployed application from the dropdown list

• Configure tile style and target

4. Assign the app to a group and a catalog.

5. Assign a role to users.

✅ Now, a user can log in to the Fiori Launchpad and see the tile for the app.

✅ Clicking the tile opens the live application, which is now running on BTP and communicating with S/4HANA.

2️⃣ Deployment on an On-Premise SAP Front-End Server (FES)

If you're not using a BTP frontend, the app can also be deployed on a local SAP FES (Front-End Server):

📌 Steps for FES Deployment:

✔ The UI5 app needs to be uploaded to the SAPUI5 ABAP Repository:

• Transaction /UI5/UI5_REP_UPLOAD

• Or via SAP Web IDE > Deploy to SAPUI5 ABAP Repository

✔ After that, the app can be launched via the On-Premise Fiori Launchpad.

➡ This scenario is only relevant if BTP is not being used.

➡ Our focus is on cloud deployment via BTP.

Summary: Deploying Our Custom App in SAP BTP Launchpad

1️⃣ Start Deployment → In Web IDE, click “Deploy to SAP Cloud Platform”

2️⃣ Select Subaccount & Cloud Foundry Space → The app gets deployed to BTP

3️⃣ Integrate into BTP Launchpad → Create the app as a tile in the Launchpad Service

4️⃣ Set Authorizations → Assign the app to a catalog, a group, and a role

5️⃣ Test the App → The tile appears in the Fiori Launchpad, and the app runs with S/4HANA data

Why Cloud Deployment in BTP?

✅ No UI installation needed on S/4HANA – only the OData service has to be available.

✅ Independent maintenance and updates for the UI5 app.

✅ Future-proof architecture with cloud extensions instead of on-prem modifications.

Conclusion: Modern Fiori Development with BTP

✔ We've created a Fiori app using Web IDE/BAS.

✔ The app was connected to S/4HANA via OData.

✔ The deployment happened on SAP BTP.

📌 This architecture aligns with SAP’s “Side-by-Side” approach:

✅ Custom UI5 applications run in the cloud (BTP)

✅ Backend communication happens via standard APIs (OData)

✅ S/4HANA stays upgrade-friendly and isn't directly modified

🚀 The app is now ready to go and integrated into the SAP cloud ecosystem!

5. Integration with SAP S/4HANA

The integration is a crucial aspect when developing add-ons.

➡ Custom solutions often need to communicate with SAP S/4HANA or other systems,

➡ exchange data, or

➡ trigger processes across systems.

📌 One method we've already covered is OData for Fiori apps.

📌 Let's dive into more integration options and best practices for SAP add-ons.

Integration Techniques for SAP Add-ons

✔ Leveraging OData Services (SAP Gateway)

➡ OData is the go-to protocol for SAP Fiori and all RESTful integrations with SAP.

📌 When do you need a custom OData service?

• If you've developed a custom function (like a function module or an ABAP class method),

• You can then expose it via an OData service.

• This is done using transaction SEGW (SAP Gateway Service Builder).

📌 Steps to create an OData service:

1. Create an OData project in SEGW

2. Define the data model (Entity Types/Sets manually or by RFC/BAPI import)

3. Implement CRUD methods (GET, POST, PUT, DELETE) in ABAP

4. Generate and activate the service

5. External applications can then call the service via HTTP(S)

✔ OData supports XML or JSON and you can test it with tools like SAP Gateway Client or Postman.

✔ OData/REST is often preferred for real-time communication because it's lightweight and web-based.

✔ Developing and Deploying SAP APIs

Beyond OData, SAP S/4HANA can also expose other API formats:

📌 SOAP Web Services (older, but still used for specific integrations – check out transaction SOAMANAGER)

📌 RFC/BAPI Interfaces (point-to-point integration, often for .NET or Java applications via the RFC SDK)

✔ A custom BAPI or function module can be published as a Web service.

✔ SAP lets you expose an RFC-enabled function module as a SOAP service via SICF/SOAMANAGER.

✔ However, for new APIs, SAP now recommends RESTful Services or the ABAP RESTful Application Programming Model (RAP).

➡ The SAP API Business Hub provides pre-built APIs for S/4HANA (both OData and SOAP).

➡ Best Practice: Leverage existing APIs before building a new one.

➡ Supported Formats: OData/JSON, XML/SOAP, etc., for communicating with SAP and non-SAP systems.

✔ Integrating SAP add-ons with external applications

If an SAP add-on needs to connect with non-SAP systems (e.g., a third-party CRM or cloud services):

✔ SAP BTP offers middleware like SAP Cloud Integration (CPI) or API Management.

✔ This is better than a direct HTTP call from ABAP (though possible with CL_HTTP_CLIENT).

✔ Middleware decouples systems and ensures secure communication.

📌 Example:

An SAP add-on sends data to a cloud CRM.

✅ Bad solution: A direct HTTP call from ABAP to the CRM.

✅ Better solution: Using SAP CPI as an integration layer to orchestrate those API calls.

✔ For simpler integrations, ABAP can also consume web services or REST APIs directly (using CL_HTTP_CLIENT, IF_HTTP_SERVICE).

✔ Typical integration scenarios

📌 Common integration flows in extension projects:

✔ Outbound IDocs or messages for event-driven integration (e.g., sending an IDoc when an order is created).

✔ Scheduled jobs that extract SAP data and push it to external systems (via file or HTTP).

✔ Real-time API calls, for instance, a user clicks something in SAP → an API call to a third-party system is triggered.

📌 Here's an example with SAP BTP:

Imagine a serverless app on SAP BTP that regularly queries SAP data via an OData service and then stores it in an external database.

Best practices for integration development

✔ Pick the right protocol:

• OData/REST → Real-time queries and updates.

• SOAP → If required by legacy systems.

• IDocs or Events → For asynchronous data exchange.

✔ Don't forget security:

• OAuth tokens or API keys for external APIs.

• SAP authentication for incoming API calls (via SAP Cloud Connector or Gateway with user roles).

✔ Testing is crucial:

• SAP Tools: /IWFND/GW_CLIENT for OData, SLG1 for logs.

• External Tools: Postman, SOAP UI for simulating API calls.

✔ Implement error management:

• Log failed API calls (SLG1 Application Log).

• Send automatic alerts to admins when errors occur.

Extending via APIs: Beyond just Fiori apps

📌 When an add-on is provided via services, it can be used not only in Fiori apps, but in any external application.

📌 Example:

✔ A mobile app could leverage the same OData service to fetch S/4HANA data.

✔ A partner system could trigger an action in SAP via an API.

➡ The principle: S/4HANA becomes the digital core, providing APIs to communicate with other systems.

Summary of SAP S/4HANA Add-on Integration

✅ Most common method: OData services as the integration layer for data exchange with external applications.

✅ Flexible architecture: Loose coupling between S/4HANA and external systems.

✅ SAP as the digital core: Add-ons leverage APIs to interact with Fiori, mobile apps, or third-party providers.

🚀 Modern SAP integrations are API-based, enabling a flexible, future-proof architecture!

6. Monetizing SAP Add-ons and Tools

Once an SAP add-on or tool has been developed, the question of monetization comes up.

➡ Options:

✔ Selling to SAP customers

✔ Offering as a service (Subscription, Consulting)

✔ Using it as a competitive advantage in consulting

📌 The SAP ecosystem offers various ways to monetize innovations:

✔ Publishing in the SAP Store (formerly SAP App Center)

📌 What's the SAP Store?

✔ An online marketplace by SAP where partners can offer their software products.

✔ Enables the listing of SAP S/4HANA extensions, Fiori apps, and integrations.

✔ Provides Access thousands of SAP customers worldwide.

📌 Benefits of publishing in the SAP Store:

✔ High visibility for SAP customers.

✔ Customers can discover, test, and purchase solutions.

✔ The SAP Store handles payment processing – partners can focus on product development and support.

✔ Over 3,000 applications and services are already being marketed through the Store.

📌 How to publish an add-on in the SAP Store?

1. Registration as an SAP partner is required.

2. Review process by SAP (checking for quality and integration standards).

3. Optional: SAP certification of the solution (increases customer trust).

4. Customers can either use free trial versions or purchase licenses directly.

✔ SAP PartnerEdge Program

📌 What is SAP PartnerEdge?

✔ SAP's official partner program for marketing and selling SAP extensions.

✔ Four engagement models: Build, Sell, Service, Run.

✔ For monetizing an add-on, the “Build” option is relevant.

📌 Benefits as a PartnerEdge Build Partner:

✔ SAP licenses for development & support.

✔ SAP certification for the add-on is possible.

✔ Marketing and sales support from SAP.

✔ Co-selling opportunities with SAP sales.

📌 Note:

➡ If you want to list your add-on in the SAP Store, you often need to be an SAP PartnerEdge Build member.

➡ PartnerEdge also governs sales agreements to efficiently monetize add-ons.

✔ Consulting & Freelance Services

📌 Monetizing through Consulting, not Software Sales

• Many SAP developers offer consulting services instead of selling their add-on separately.

• Specialized add-ons aren't sold directly; instead, they're custom-implemented for clients.

• SAP consultants with expertise in S/4HANA, ABAP, and Fiori are in high demand.

📌 Benefits of the Consulting Model:

✔ Monetization happens via project fees, not license sales.

✔ Each implementation can be tailored to the client's specific needs.

✔ Freelancers often use their own tools/add-ons as 'accelerators' to deliver projects faster.

✔ No hassle with software sales and license management – instead, you bill directly for development time and expertise.

📌 Who is this model suitable for?

✔ SAP consultants and developers who don't want to handle software sales & support themselves.

✔ Implementing custom solutions for clients instead of selling generic software products.

✔ Licensing and Sales Models for SAP Add-ons

📌 Possible Licensing Models:

✔ Per-user licensing (price per user).

✔ Per-server or CPU licensing (depending on system size).

✔ Subscription model (SaaS) → Monthly or annual fee for cloud-based add-ons.

✔ Usage-based monetization → Price per processed business transaction (e.g., per invoice or order).

📌 Pricing and Maintenance:

✔ Companies expect maintenance contracts → often 15-20% of license costs annually for support & updates.

✔ Offer Packages & Editions:

• Base Version (Standard Features)

• Premium Version (Advanced Features, Integrations)

✔ Pricing needs to reflect the value → Enterprise customers often demand scalability.

📌 Additional Sales Opportunities:

✔ Partnering with SAP Sales (e.g., co-selling with SAP Account Executives).

✔ Add-ons can be offered by SAP partners as part of bigger deals.

✔ SAP Store vs. Direct Sales

📌 SAP Store vs. Direct Sales: Key Differences

📌 Our Takeaway:

➡ The SAP Store is great for small to mid-sized solutions.

➡ For enterprise deals, direct sales or an SAP sales partnership is usually better.

✔ Partnering with SAP Implementation Partners

📌 Benefit: SAP implementation firms work with tons of clients who have similar needs.

• If an add-on fills a specific gap, partners might resell or recommend it.

• Teaming up with SAP integrators can be a solid revenue stream.

✔ An SAP PartnerEdge membership boosts credibility and makes partner networking easier.

Key Success Factors for Monetization

✔ Crystal-clear add-on documentation: Features, benefits, and customer ROI.

✔ Offer demos or trial versions.

✔ Gather reference customers & success stories → This builds trust for future buyers.

✔ Ensure long-term support & maintenance: Customers expect updates and compatibility with new SAP versions.

📌 Important: Keep an eye on the SAP roadmap!

• If SAP integrates a similar function into the standard, the add-on will need to be adapted or repositioned.

• Many successful SAP partner products started as add-ons → Some were acquired by SAP or evolved into specialized solutions.

• Monitor the market & continuously incorporate innovations.

📢 Conclusion: Monetization Strategies for SAP Add-ons

✅ Utilize the SAP Store for broad customer reach.

✅ Join SAP PartnerEdge to get professional marketing & certification.

✅ Consider Consulting & Project Business as an alternative to license sales.

✅ Apply flexible licensing models (User-based, Subscription, Transaction-based).

✅ Build partnerships with SAP integrators.

✅ Secure long-term maintenance & support.

🚀 With a smart monetization strategy, an SAP add-on can become a successful product or service!

7. Best Practices and Optimization

When developing enterprise systems like SAP, it's crucial to follow best practices to ensure your add-ons are efficient, secure, and maintainable.

✔ Performance Optimization

📌 Optimizing ABAP Code and Database Queries

• Avoid nested SELECTs and large loops → Utilize SQL as directly as possible to leverage HANA's performance.

• Prefer CDS Views or joins over aggregating data in ABAP.

• Create indexes on custom tables to speed up data access.

• Use SAP analysis tools:

• SQL Trace (ST05) → Identifies expensive database queries.

• ABAP Runtime Analysis (SAT) → Pinpoints slow ABAP processing.

• Performance Trace (ST12) → Measures performance and identifies bottlenecks.

📌 Performance Tips for Fiori/UI5

• Use $batch to bundle multiple OData calls into a single request.

• Leverage server-side paging ($top/$skip) to retrieve only the necessary data.

• Use the $select option to load only relevant fields.

• Enable caching for frequently used data.

• Optimize UI5 app load times by loading only necessary components and avoiding superfluous libraries.

✔ Security (Security Best Practices)

📌 Security in ABAP Code

• Implement AUTHORITY-CHECK to verify authorizations for sensitive operations.

• Create custom authorization objects if your add-on provides new transactions or services.

• Secure dynamic SQL queries and operating system commands to prevent SQL injection and code injection.

• Use random values & hashing APIs for encryption (ABAP offers secure random APIs).

📌 Security for OData Services & BTP

• Define SAP PFCG roles for OData services to control access to entity sets and CRUD operations.

• Use OAuth tokens or secure vaults instead of plain-text passwords.

• XSS protection in UI5: Leverage data binding instead of directly rendering HTML.

• Dynamically adapt the UI based on user permissions → fetch user roles and control which options are visible.

• Regularly apply SAP security patches and scan your code with the SAP Code Vulnerability Analyzer.

✔ Error Analysis and Debugging

📌 ABAP Debugging & System Analysis

• Utilize the SAP GUI Debugger and Eclipse ADT Debugger to set breakpoints.

• Analyze ABAP dumps (ST22) → when an error occurs, ST22 displays the call stack and variable contents.

• Check the System Log (SM21) for any system issues.

• Use the Application Log (SLG1) to create custom logs for error analysis.

📌 Fiori/UI5 Debugging

• Use the browser console (F12) → to analyze JavaScript and network errors.

• Check the SAP Gateway Error Log (/IWFND/ERROR_LOG) → it displays failed OData requests, including their payload.

• UI5 Debugging Tools:

• Ctrl + Alt + Shift + P → to display performance statistics.

• Ctrl + Alt + Shift + S → for technical information about the UI5 app.

📌 SAP BTP Debugging

• Check Cloud Foundry Logs (cf logs).

• Analyze SAP Cloud Connector logs if on-premise connections are failing.

✔ Maintainability and Naming Conventions

📌 Good naming conventions are crucial

• Prefix objects with Z/Y and add descriptive suffixes (e.g., ZCUST_REVENUE_VIEW).

• Ensure clear structuring of SAP objects → bundle all add-on objects within their own package or namespace.

• Add comments to ABAP code, especially for complex logic.

• Prefer standard extension points (BADIs, Enhancement-Spots) over modifying standard code directly.

• If changes to standard objects are necessary, make sure to document them, as they'll need to be considered during SAP updates.

✔ Testing: Quality Assurance and Load Testing

📌 Creating Test Data and Scenarios

• Writing ABAP Unit Tests for critical algorithms.

• Performing integration tests in Fiori to ensure data flow works correctly.

• Running tests with various user roles to validate authorizations.

• Executing performance tests, like running and optimizing a report with 100,000 data records.

📌 Conclusion: Why Best Practices Matter

🚀 By following these best practices, you'll significantly boost the quality and reliability of your SAP add-ons:

✅ Improved Performance → Faster response times & optimized database queries.

✅ Secure Applications → Protection against unauthorized access & security vulnerabilities.

✅ Easier Maintenance → Well-structured code makes future adjustments a breeze.

✅ Robustness → Fewer issues in production thanks to solid debugging strategies.

✅ Better User Experience → Fast-loading, stable, and intuitive Fiori apps.

➡ A high-performing, secure, and well-documented add-on reduces support effort and enhances your reputation as a developer or provider. 🚀

Conclusion

By following this guide, an intermediate developer should be able to:

✅ Set up the SAP development environment (SAP GUI, Eclipse ADT, SAP BTP).

✅ Develop ABAP extensions in S/4HANA.

✅ Create an SAPUI5/Fiori app on SAP BTP that interacts with these extensions.

✅ Leverage OData services for SAP integration.

✅ Understand options for deploying or monetizing the solution.

✅ Apply best practices for performance optimization and security.

🚀 Thanks to practical exercises and visual support, developing SAP add-ons becomes significantly simpler.

📌 With the fundamentals provided here, a developer can not only build their own extensions but also implement and optimize more complex SAP projects.