Development of SAP S/4HANA add-ons and SAP Fiori tools using ABAP and SAP BTP
Development of SAP S/4HANA add-ons and SAP Fiori tools using ABAP and SAP BTP
This guide provides step-by-step instructions for developing custom add-ons and tools for SAP S/4HANA and SAP Fiori. It covers the key concepts and technologies—SAP ABAP for the backend, the SAP Business Technology Platform (SAP BTP) for cloud services, and SAP Fiori/SAPUI5 for the user interface. It also explains how to set up the development environment, develop ABAP extensions and Fiori apps, integration methods, monetization strategies, and best practices. The content is structured for developers with intermediate-level knowledge and provides detailed explanations, sample code, and clear screenshots to facilitate learning.
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, which runs on the SAP HANA in-memory database. It leverages modern innovations in data processing and a simplified data model to deliver real-time analytics and optimized business processes.
SAP Fiori is SAP's modern user interface (UX) and consists of web-based applications developed using SAPUI5. Fiori offers an intuitive, role-based user experience 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 (e.g., creating a sales order or approving leave requests). These apps are accessible via the Fiori Launchpad. By consistently adhering to design guidelines and using a responsive, HTML5-based approach, Fiori significantly improves usability and productivity.
The Importance of Add-ons and Tools:
Every company has unique requirements. Add-ons (custom extensions or plugins) and tools (custom applications, reports, integrations) enable organizations to adapt the standard SAP S/4HANA to their specific needs without modifying the core SAP code. By developing add-ons, companies can close functional gaps, automate customized processes, or improve user productivity.
SAP provides official extension mechanisms so that custom code can 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 allowing for further development independent of SAP upgrades (thereby maintaining a “clean core”). Within the SAP ecosystem, a robust add-on can even become a standalone product that can be reused or purchased by others—an incentive for partners and developers to drive innovation on the platform.
Core 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 customer-specific reports, transactions, Data Dictionary objects, extensions, and business logic. In S/4HANA (on-premise and private cloud), ABAP remains central to extensions.
ABAP is also available in SAP BTP (via the ABAP Environment, also known as “Steampunk”) for developing cloud-based extensions using 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 with 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 integration with an S/4HANA system (on-premise or in the cloud). It supports the development of extension applications without affecting the on-premise system, and is thus in line with SAP’s “clean core” strategy. In summary, BTP provides the infrastructure and services needed to develop cloud applications, integrations, and innovations based on SAP solutions.
• SAP Fiori/UI5: SAP Fiori is the UX framework, and SAPUI5 is the underlying front-end 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 from the SAP backend via OData services 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 SAPUI5 application development (controllers, views, models) as well as their deployment either on an SAP front-end server (for on-premise Fiori) or on SAP BTP (for cloud deployments). In practice, developers use tools such as SAP Web IDE or SAP Business Application Studio to develop 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 the Development Environment
Before development can begin, it is essential to set up a suitable SAP development environment. This includes connecting to an SAP S/4HANA system via the " Access " for ABAP development, installing the necessary IDEs and tools, and provisioning cloud resources on SAP BTP for the development and deployment of Fiori apps.
Required Software and Tools
The following table summarizes the most important components that need to be installed or accessed:
Tool / Component
Purpose
SAP S/4HANA System (Developer Access)
An SAP S/4HANA instance that provides ABAP development access. This can be an on-premises installation or a sandbox/test system. It serves as the backend for creating user-defined tables, ABAP programs, OData services, etc.
SAP GUI for Windows (and/or SAP Business Client)
A traditional desktop client for logging into SAP systems. Required for using classic SAP development transactions (SE11, SE80, SE38, etc.) and for testing 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 more. This is required to work with advanced features such as ABAP CDS and new programming models. Eclipse (e.g., Eclipse 2023-xx) can be downloaded, and the ADT plugin can be added via the update page at https://tools.hana.ondemand.com.
SAP Business Technology Platform (BTP) Account
An SAP BTP account (either a free trial or an Enterprise account) is required to use cloud services. In BTP, you create a subaccount, enable services such as SAP Business Application Studio or SAP Web IDE, and configure destinations for connecting to the 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 applications. BAS is the newer, container-based development environment on BTP that offers a desktop-like experience in the browser (and replaces Web IDE). Web IDE Full-Stack is an older (now deprecated) tool that also runs in the cloud or locally and provides templates and wizards for Fiori development. One of these environments is used to create and deploy the Fiori/UI5 app.
SAP Cloud Connector (optional, for on-premises integration)
If the S/4HANA system is running on-premises, the SAP Cloud Connector—a small on-premises component—enables a secure connection between the SAP BTP Cloud and the local network. This is used in conjunction with BTP destination configurations to enable cloud apps to communicate securely with on-premises S/4HANA OData services.
Installing SAP GUI and ABAP Development Tools
To install SAP GUI, download the installer (SAP GUI for Windows 7.70 or 8.00) from the SAP Marketplace(requires an S-User ID) or use a test environment that includes it. Installation is guided by a wizard. After installation, configure a connection to your SAP S/4HANA system in SAP Logon(you will need the application server host, the system number, and the client). Once the connection is established, you can open SAP GUI and access transactions such as SE11 (Data Dictionary), SE38 (ABAP Editor), and so on.
To use ABAP in Eclipse (ADT), first install a supported Eclipse IDE on your computer (for example, Eclipse IDE for Java Developers). SAP recommends the latest stable version of Eclipse. After installing Eclipse, add the ABAP Development Tools plugin:
1. Open Eclipse and go to Help > Install New Software.
2. Enter the update site URL for ADT (for example, https://tools.hana.ondemand.com/latest).
3. Select " ABAP Development Tools " from the list and continue with the installation.
4. After restarting, open the ABAP Perspective in Eclipse.
5. In the ABAP Perspective, create a new ABAP project by establishing a connection to your S/4HANA system (this can be done either via an SAP logon entry or by manually entering the connection parameters ).
6. You can then browse ABAP packages and objects in Eclipse and perform development tasks using advanced features such as syntax checking, code completion, debugging, and Git integration via abapGit.
Setting Up SAP BTP
If you do not yet have an SAP BTP account, sign up for an SAP BTP trial or free-tier version. Once you have a global account on SAP BTP, open the SAP BTP Cockpit in your web browser and complete the following basic configuration:
1. Create a subaccount
• The subaccount represents an isolated environment (region + platform).
• Select a region (e.g., Europe Frankfurt) and a subaccount name.
• Select the entitlements (services) you want to use (e.g. , SAP Business Application Studio, Portal Service (Launchpad), Destination Service, Cloud Connector, etc.).
2. Space (Cloud Foundry Runtime)
• If you are using the Cloud Foundry Runtime (for example, to deploy HTML5 apps), enable Cloud Foundry and create an organization and a space within the subaccount.
• This is required to use certain services or to provide web applications.
3. Tools & Services
• Go to the Service Marketplace in the subaccount and activate the SAP Business Application Studio (BAS)or SAP Web IDE service.
• If you are using BAS, create a service instance (Dev Space) of type SAP Fiori (this is already preconfigured with SAPUI5 tools).
• If you are using Web IDE, activate the SAP Web IDE Full-Stack subscription and start it via the BTP Cockpit.
4. Set Up Destinations
• If your Fiori app needs to retrieve 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 the OData endpoint of your S/4HANA system (e.g., SAP Gateway Server URL), authentication details (OAuth or Basic Auth with a technical user), etc.
• If your S/4 system is on-premises, you must also set up the SAP Cloud Connector to map the on-premises 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 because they enable cloud applications to consume secure on-premises OData services via SAP's connectivity layer.
Configuring the Fiori/UI5 Development Environment
Once BAS or Web IDE is enabled, configure your Fiori development environment:
• In SAP Business Application Studio (BAS)
• Open your Dev Space, which already contains the SAPUI5 SDK and the necessary tools.
• If necessary, import the relevant SDKs or set up a Git repository for your project.
• BAS is usually already preconfigured for Fiori development.
• In SAP Web IDE
• Start Web IDE via the BTP Cockpit (Service > SAP Web IDE > Open Web IDE).
• No local installation is required, as it runs directly in the browser.
• Verify that the destination to the S/4HANA system is configured correctly (Web IDE uses the destinations defined in the BTP Cockpit to discover OData services).
• Verify the SAPUI5 library version
• Make sure you have access to an SAPUI5 version that matches the S/4HANA Fiori front-end version.
• In BAS/Web IDE, you can select the SAPUI5 version (for example, 1.108 or 1.96, depending on the S/4HANA version).
• Alternative on-premises development for UI5
• If you prefer on-premises 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, we recommend using the SAP Cloud IDEs, as they offer seamless integration with SAP systems.
Your development environment is now ready
With this feature, 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 following 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 extending standard functions. In this section, we cover the key ABAP development tasks:
• Creating custom tables and function modules,
• Development of reports and transactions,
• Use of extension frameworks (BADIs and user exits) to modify the standard behavior,
• Creating ABAP Core Data Services (CDS) views.
Familiarity with the SAP development environment (SE11, SE80, etc.) is required.
ABAP Development Concepts
In SAP, development objects (programs, tables, data elements, classes, etc.) are typically created in the ABAP Workbench (SE80) or in 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 aids.
• Reusable logic can be encapsulated in function modules (SE37), class methods (SE24 for classes), or BAPIs.
• Reports (executable programs) are created using SE38 or in Eclipse ADT (REPORT or PROGRAM statement). Transactions (T-codes) are created using SE93 to make these programs or function modules executable for end users.
• SAP enhancement techniques (user exits, customer exits, BADIs, enhancement spots) make it possible to insert user-defined logic into standard SAP processes without modifying the original code.
• ABAP CDS views are defined in Eclipse ADT as .ddl source files and provide a powerful way to create data models and publish them to OData.
These aspects will be discussed step by step below.
Creating a User-Defined Table and a Function Module
Create a Custom Table
Suppose we want to create a custom database table to store company-specific data such as “Customer Revenue by Region.” To do this, we use transaction SE11 (ABAP Dictionary) and proceed as follows:
1. Open SE11 and select a database table. Enter a name for the new table (e.g., ZCUST_REV —user-defined objects usually begin with “Z” or “Y”) and click Create.
2. Enter a brief description for the table, select a delivery class (e.g., “A” for application tables), and specify the table maintenance attributes (e.g., whether entries can be maintained using SM30 ).
3. Define the table fields in the “Fields” tab:
• Field Name
• Data element or predefined type
• Length
• Primary Key
• Example of fields:
• ZCUST_NO (Customer Number, NUMC(6), key field)
• ZREGION (Region, CHAR(3), key field)
• ZREVENUE (Revenue, DEC(15,2))
• If there are no predefined data elements, you can use the "Predefined Type" button to define types directly.
4.Configure the technical settings (set the data class and size category using 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 user-defined 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 a length of 6 for the customer number), and key designation for each field. Such user-defined tables enable the persistent storage of application-specific data in the S/4HANA database.
Once the table is activated, ABAP programs can write to it, or a maintenance dialogcan be created for usersto edit entries. User-defined tables are transported across systems using Workbench transports.
Function module
To create a reusable function (for example, a function for calculating a bonus or retrieving aggregated data), use SE37 (Function Builder):
1. Open SE37, select " Create Function Module," and assign a name (e.g., ZCALC_BONUS) within a user-defined function group (functions are organized into groups). Enter a brief description.
2. Define import parameters, export parameters, and exceptions in the upper section of the Function Builder. These parameters form the function's interface.
3. Implement the ABAP logic in the Source Code section. For example:
• Import an employee ID
• Query the database for sales data
• Calculate a bonus
• Return the bonus amount as the export value
4. Save and activate the function module. It can now be called from any ABAP program or made available as a remote-capable API (RFC).
Function modules can also serve as user exits (SAP sometimes provides empty function modules that are called upon during certain events and populated by customers). In addition, they can be integrated into OData or SOAP services and made available 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 that are often used for data queries, simple output, 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 sales 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 executes a SELECT query on the user-defined table to aggregate sales by customer. The results are then output in a loop. In practice, reports are often created using the ALV grid display for a better user interface and selection screens for user input (using PARAMETERS or SELECT-OPTIONS in the code).
After the report has been created, it must be activated. You can run it directly in SE38 or via SA38 by entering the program name.
If you want end users to be able to run this report easily, you can create a transaction code:
1. Open SE93 (Maintain Transactions).
2. Select Create and enter a transaction code (for example, ZCUST_REV_REP).
3. Select “Program and Selection Screen” as the transaction type, and link the transaction to the report program.
4. Save the transaction—users can then run the report using this transaction code from the SAP Easy Access menu.
Custom transactions can also be integrated into user menus or roles so that they appear in the SAP Fiori Launchpad (as GUI transactions) or in the SAP GUI Easy Access menu.
Extending SAP Standard Functionality (BADIs and User Exits)
SAP provides extension mechanisms that allow user-defined code to be executed at predefined hook points in standard programs. This ensures that standard SAP code remains unchanged (which would complicate future upgrades), while still allowing custom logic to be inserted. 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 the program. By default, these exits do nothing, but they can be implemented by customers.
📌 Example:
In the SD module, user exit MV45AFZZ allows you to insert user-defined checks during order processing.
To implement a user exit:
1. Find the relevant SMOD/CMOD extension. SAP often groups several exits into a single SMOD extensionwith a specific name.
2. Open CMOD, create a project, assign the relevant extension, and insert your code into the designated includes or function modules.
3. Once activated, the custom code is automatically executed as part of the standard process.
➡ User exits often require code in 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 execute their custom code.
BADIs are managed using transactions SE18 (definition, provided by SAP) and SE19 (implementation, by customers). SAP provides BADI definitions (for example, there is a BADI for extending invoice posting). The developer creates a BADI implementation by implementing the logic in one of the provided methods.
Main difference 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 allow parallel or filter-controlled implementations).
Implementing a BADI – Step by Step
1. Find the correct BADI definition
• Use SE18, the SAP documentation, or the “Where is it used?” search in the SAP GUI with the term “BADI.”
• In newer systems, many extensions are managed using enhancement spots, which can contain multiple BADIs.
2. Create a new implementation in SE19
• Open SE19, create a new BADI implementation, give it a name, and select the appropriate BADI definition.
Create a third class for the implementation
• The system prompts you to create a class that implements the BADI interface.
• In this class, you write the custom logic in the provided methods.
4. Enable BADI Implementation
• Once the implementation is activated, your code will run automatically when the standard program calls the BADI using CALL BADI or the Enhancement Framework.
• If there are multiple implementations, either all of them are executed in parallel or only the appropriate implementation is executed based on a filter condition —depending on the BADI configuration.
Example of a BADI Implementation
Suppose SAP's standard invoice posting uses the BADI BADI_INVOICE_POST with the CHECK_DATA method, which is called before the invoice is posted to validate the data.
➡ A developer could implement this BADI to perform additional checks, such as:
✅ Checking a user-defined table for specific rules
✅ Reconciliation with an external system before the invoice is posted
📌 Important:
The BADI mechanism ensures that the user-defined code is executed without modifying the standard SAP logic, thereby enabling 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 SAP’s standard functionality without modifying the core code. They offer a flexible and maintainable way to customize SAP applications.”
Similarly, user exits allow for extensions 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 BADIis usedto populate the value for that field.
Steps for Implementing a User Exit (Quick Overview)
1. Identify the exit —using SAP Notes or development documentation.
• Example: An SAP SD exit for sales orders could be located in program MV45AFZZ.
2. Open CMOD → Create a project → Assign the relevant extension (an extension groups related exits together).
3. For each component of the extension (e.g., an include or function module), click " Components " and navigate to the corresponding include.
• Write the custom code within the include (between FORM…ENDFORM or as intended).
4. Activate the project – The code in the includes is now executed as part of the standard SAP process.
Steps for Implementing a BADI (Quick Overview)
1. Find the BADI name
• Use SE18 or debugging/SQL trace to check whether GET_INSTANCE is being 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 class) 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 validation, set an export flag if necessary, or throw an exception.
5. Enable the implementation.
Additional BADI Options
Many BADIs have a filter option, which means that the implementation can be restricted to specific criteria (such as company code or country). These settings are defined in the BADI implementation configuration.
Extension Framework in SAP (ECC 6.0 and later, and S/4HANA)
With ECC 6.0 and S/4HANA, SAP introduced implicit and explicit extensions.
These allow you to add extensions within specific code blocks or at the beginning or end of form routines.
📌 These are managed directly in the ABAP Editor using the “Enhance” option and provide another way to extend standard or user-defined code.
📢 For medium-sized development projects, however, 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 central component of S/4HANA development and play a crucial role in SAP's strategy for in-memory-optimized programming.
📌 CDS Views make it possible to move complex logic and calculations directly to the HANA database layer. This allows them to 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 integrate with the ABAP Data Dictionary once activated.
Key Features of CDS Views
✔ CDS views are defined using the DEFINE VIEW syntax in a DDL source file.
• You can reference base tables or other views,
• Apply filters, joins, associations, and even simple calculations.
✔ CDS Views support annotations —metadata that:
• Make the view available as an OData service,
• Control the UI behavior in Fiori Elements.
✔ After activation, a CDS View generates:
• An SQL view in the HANA database,
• A runtime object in ABAP that can be used in ABAP programs like a table via a SELECT query.
Creating a CDS View (Step-by-Step)
1️⃣ In Eclipse ADT:
• Create a new ABAP DDL source document (for example, ZCUST_REVENUE_VIEW).
• A shipping order and a package must be selected based on the project.
2️⃣ Using the 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, zregionThis defines a CDS view that aggregates the user-defined table by customer and region and calculates the total revenue.
The annotations used here specify the corresponding SQL view names and enable the OData Expose function.
📌 @OData.publish: true would automatically generate an OData service for this view in SAP S/4HANA.
Steps to Follow After Defining the CDS View
1️⃣ Enable 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 that you can find in transaction /IWFND/MAINT_SERVICE and activate for use.
2️⃣ Test CDS-View
• Preview the data in Eclipse, or
• Open the generated SQL view in SE16.
CDS Views as a Multi-Layer Architecture
CDS Views can be divided into layers:
📌 Base layer → Composite layer → Consumption layer (Consumption Views).
✅ CDS views are used extensively in S/4HANA —many preconfigured S/4HANA analyses and Fiori elements are based on them.
✅ A major advantage is that a CDS view can be made available as an OData service with just a few annotations.
• This often eliminates the need to manually create an OData service for simple read operations —the platform generates it automatically.
Deployment and Transport of CDS Views
• Once created, CDS views can be transferred to other systems using standard SAP transport procedures.
• CDS Views are objects of type R3TR DDLS and can be transported from DEV to QA and production after development and testing.
Summary
ABAP development for add-ons includes:
✔ Creating custom dictionary objects (tables, data elements),
✔ Writing ABAP programs or extending existing programs,
✔ Using ABAP frameworks such as CDS and enhancement spots to extend standard functions in a way that ensures compatibility with future upgrades.
4. Developing Fiori Applications with SAP BTP
In this section, we'll move on to front-end development:
📌 SAP Fiori applications with SAPUI5.
These applications run in a web browser (or in the Fiori Launchpad) and communicate with the SAP S/4HANA backend via OData services.
➡ We use 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 (HTML5/JavaScript application) runs in the browser and manages the user interface and user 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 are used by the UI5 app 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.
📌 Launchpad is a web platform that serves as a central homepage with 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 on the backend to retrieve or send data.
🔹 Fiori apps are role-based:
• Users see only the apps they are authorized to use.
• Permissions control which actions are allowed within the app.
Architecture: Separation of the UI and Backend Using OData
Fiori uses a decoupled model in which the UI is separated from the backend via OData services:
✅ The same OData service can support multiple interfaces (web UI, mobile UI, etc.).
✅ The UI does not communicate directly with the database, but rather through defined service APIs.
Summary
➡ “SAP Fiori apps are developed using SAPUI5, launched via the SAP Fiori Launchpad, and retrieve business data from the SAP S/4HANA backend via OData services.”
✔ The architecture is stateless (each OData call is independent → better scalability).
✔ Modern concepts such as “draft handling” for long-running transactions are supported.
Now let's build a Fiori app—step by step. 🚀
Creating a Fiori App with SAP Web IDE / Business Application Studio
In this example, we use the 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 has been activated beforehand, as described in Section 2).
• The web-based development environment should now be visible.
• Select File > New > Project from Template to launch the project wizard for a new Fiori app.
• (In Business Application Studio: Open a Dev Space and use the “Fiori: Create Project” command or the Yeoman templates.)
2️⃣ Select a project template
• The SAP Web IDE offers predefined project templates, such as:
• SAP Fiori Worklist Application
• SAPUI5 Application
• Master-Detail Application
• For example, select the SAP Fiori Master-Detail Application and click Next.
3️⃣ Configure the project
• Enter a project name (e.g., CustomerRevenueApp).
• If necessary, specify a namespace.
• Select the data source for the app:
• If an OData service already exists (for example, the CDS view you created earlier or a standard SAP service), select Service Catalog.
• Then select the preconfigured destination and the OData service from S/4HANA.
• The wizard automatically retrieves the service metadata.
• Select the entity set you want to display in the app (for example, an entity for customer sales).
4️⃣ Finish the wizard
• The Web IDE now generates a complete project with all the necessary files:
• Controller (JavaScript)
• Views (XML)
• i18n texts (multilingual support)
• manifest.json (application description)
• This generated project is ready to run and can be tested immediately.
5️⃣ Run and test the app
• Right-click 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 testing 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 should now see actual data from your backend, for example:
• A list of customers
• A detail page with sales data for each customer.
6️⃣ Continue developing the app
• Now you can customize the generated code:
• Open the View XML files to change the UI layout or labels.
• Edit the controller JavaScript files to add additional logic (e.g. , input validation, dynamic navigation).
• Customize the i18n property files to localize text.
• Add new UI elements (charts, tables, filters) using SAPUI5 controls and link them to 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 such as approvals or data changes.
✅ Performance Optimization
• Use $select or $expand in OData queries to minimize the data load.
Debugging and Testing During Development
🛠 During development, it is common to:
✔ Used the browser console (Chrome DevTools) for troubleshooting.
✔ Used 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: Continue developing the Fiori app and deploy it for production use!
Figure: Example of an SAP Fiori Launchpad home screen with tiles
Each tile (square icon) represents a Fiori app or a business task (e.g., manage 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
In order for the Fiori app to display real-time data or execute transactions, it must communicate with SAP S/4HANA.
➡ This is done via OData services.
📌 An SAP BTP destination for the S/4HANA OData service has been configured in our environment.
📌 When the UI5 app runs from the BTP environment, it uses this destination to communicate with the backend.
Key Steps for Integration
✔ Enable the OData service in S/4HANA
• Use /IWFND/MAINT_SERVICE to enable the OData service.
• If a CDS view was created with @OData.publish: true, the associated ZCUST_REVENUE_VIEW_CDS service must be enabled.
✔ Define the data source in the Fiori app's manifest.json file
• In SAP Web IDE on BTP, a route such as /destinations/YourDestinationName/ is often used in the OData service URL.
• This allows the call to be made via the SAP Cloud Connector/Destination Setup to reach the on-premises system.
✔ Use BAS and SAP Launchpad Service
• If BAS is used and the app is deployed to the SAP Launchpad Service, the destination must be mapped similarly.
• During development, the app can be tested in a “mock ” environment or using a proxy.
✔ Test the integration
• Use tools such as the browser's network analyzer or the SAP Gateway error logs (/IWFND/ERROR_LOG) to troubleshoot problems (e.g., missing permissions or service errors).
• If necessary, OData calls must be modified or $metadata requests added.
📌 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 considerations:
✔ The user stored in the BTP destination requires a PFCG role in S/4HANA that grants access to the OData service and the entity set.
Deploying a Fiori App on SAP BTP
After development and testing, the Fiori app must 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, there is an option called Deploy > Deploy to SAP Cloud Platform.
✔ This packages the UI5 app and deploys it as an HTML5 application in the Cloud Foundry space of the BTP subaccount.
✔ After deployment, 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 credentials.
2. Select the target environment:
Select a subaccount and a Cloud Foundry space.
Specify the OData destination so that the app in the cloud can establish 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 BTP Cockpit, navigate to Services > Launchpad (Site Manager).
Create a new site or use an existing one.
Add a new app in Content Manager:
Award Titles
Select Cloud Foundry HTML5 App as the storage location
Select the application that has just been made available from the drop-down list
Configure Tile Style and Target
4. Assign an app to a group and a catalog.
5. Assign a role to the user.
✅ Users can now log in to the Fiori Launchpad and see the app tile.
✅ Clicking on the tile opens the live application, which is now running on BTP and communicating with S/4HANA.
2️⃣ Deployment on an on-premises SAP Front-End Server (FES)
If a BTP front end is not used, the app can also be deployed on a local SAP FES (front-end server):
📌 Steps for deployment on FES:
✔ The UI5 app must 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-premises Fiori Launchpad.
➡ This scenario is only relevant if BTP is not used.
➡ Our focus is on cloud deployment via BTP.
Summary: Deploying Our Custom App in SAP BTP Launchpad
1️⃣ Start deployment → Click “Deploy to SAP Cloud Platform” in Web IDE
2️⃣ Select a subaccount and Cloud Foundry space → The app is deployed to BTP
3️⃣ Integrate into BTP Launchpad → Create the app as a tile in the Launchpad service
4️⃣ Set Permissions → Assign the app to a catalog, a group, and a role
5️⃣ Test the app → The tile appears in the Fiori Launchpad; the app runs using S/4HANA data
Why Use Cloud Deployment in BTP?
✅ No UI installation is required on S/4HANA —only the OData service needs to be available.
✅ Independent maintenance and updates for the UI5 app.
✅ Future-proof architecture with cloud extensions instead of on-premises modifications.
Conclusion: Modern Fiori Development with BTP
✔ We created a Fiori app using Web IDE/BAS.
✔ The app was connected to S/4HANA via OData.
✔ The deployment took place on SAP BTP.
📌 This architecture is consistent with SAP's "side-by-side" approach:
✅ Custom UI5 applications run in the cloud (BTP)
✅ Backend communication takes place via standard APIs (OData)
✅ S/4HANA remains upgradeable and is not directly modified
🚀 The app is now ready to use and integrated into the SAP Cloud ecosystem!
5. Integration with SAP S/4HANA
Integration is a crucial aspect of add-on development.
➡ Custom solutions often need to communicate with SAP S/4HANA or other systems,
➡ Share data or
➡ Trigger processes across systems.
📌 One method we've already covered is OData for Fiori apps.
📌 Here, we'll explore additional integration options and best practices for SAP add-ons.
Integration Techniques for SAP Add-ons
✔ Use of OData services (SAP Gateway)
➡ OData is the primary protocol for SAP Fiori and all RESTful integrations with SAP.
📌 When is a custom OData service needed?
• If a user-defined function (such as a function module or an ABAP class method) has been developed,
• Can this be made available via an OData service?
• This is done using transaction SEGW (SAP Gateway Service Builder).
📌 Steps for creating an OData service:
1. Create an OData project in SEGW
2. Define the data model (entity types/sets manually or via RFC/BAPI import)
3. Implementing CRUD Methods (GET, POST, PUT, DELETE) in ABAP
4. Generate and Activate the Service
5. External applications can access the service via HTTP(S)
✔ OData supports XML or JSON and can be tested using tools such as SAP Gateway Client or Postman.
✔ OData/REST is often preferred for real-time communication because it is lightweight and web-based.
✔ Development and deployment of SAP APIs
In addition to OData, SAP S/4HANA can also provide other API formats:
📌 SOAP Web Services (older, but still used for certain integrations – SOAMANAGER transaction)
📌 RFC/BAPI Interfaces (point-to-point integration, e.g., for .NET or Java applications via the RFC SDK)
✔ A user-defined BAPI or function module can be published as a web service.
✔ SAP allows an RFC-enabled function module to be deployed as a SOAP service via SICF/SOAMANAGER.
✔ Today, however, SAP recommends RESTful services or the ABAP RESTful Application Programming Model (RAP)for new APIs.
➡ SAP API Business Hub offers prebuilt APIs for S/4HANA (OData and SOAP).
➡ Best Practice: Use existing APIs before developing a new one.
➡ Supported formats: OData/JSON, XML/SOAP, etc., for communicating with SAP and non-SAP systems.
✔ Integration of SAP add-ons with external applications
If an SAP add-on needs to be connected to non-SAP systems (e.g., a third-party CRM or cloud services):
✔ SAP BTP offers middleware such as SAP Cloud Integration (CPI) and API Management.
✔ Better than a direct HTTP call from ABAP (possible with CL_HTTP_CLIENT).
✔ Middleware decouples systems and ensures secure communication.
📌 Example:
An SAP add-on sends data to a cloud-based CRM.
✅ Poor solution: Direct HTTP call from ABAP to the CRM.
✅ Better solution: Use SAP CPI as an integration layer to orchestrate API calls.
✔ For simple integrations, ABAP can also consume web services or REST APIs (CL_HTTP_CLIENT, IF_HTTP_SERVICE).
✔ Typical integration scenarios
📌 Common integration flows in expansion 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 send it to external systems (via file or HTTP).
✔ Real-time API calls; for example, a user clicks in SAP → an API call to a third-party provider is triggered.
📌 Example using SAP BTP:
A serverless app on SAP BTP that regularly retrieves SAP data via an OData service and stores it in an external database.
Best Practices for Integration Development
✔ Choose the right protocol:
OData/REST → Real-time queries and updates.
SOAP → If required by legacy systems.
IDocs or Events → For asynchronous data exchange.
✔ Keep safety in mind:
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 and SOAP UI for simulating API calls.
✔ Implement error handling:
Log failed API calls (SLG1 Application Log).
Send automatic alerts to admins when errors occur.
Extension via APIs: More Than Just Fiori Apps
📌 If an add-on is deployed via Services, it can be used not only in Fiori apps but also in any external application.
📌 Example:
✔ A mobile app could use the same OData service to retrieve S/4HANA data.
✔ A partner system could trigger an action in SAP via an API.
➡ The principle: S/4HANA becomes the digital core and provides APIs to communicate with other systems.
Summary of the Integration of SAP S/4HANA Add-ons
✅ Most common method: OData services as an 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 use APIs to interact with Fiori, mobile apps, or third-party providers.
🚀 Modern SAP integrations are API-based and enable a flexible, future-proof architecture!
6. Monetization of SAP Add-ons and Tools
Once an SAP add-on or tool has been developed, the question of monetization arises.
➡ Options:
✔ Sales to SAP customers
✔ Offer as a service (subscription, consulting)
✔ Using it as a competitive advantage in consulting
📌 The SAP ecosystem offers various ways to monetize innovations:
✔ Published in the SAP Store (formerly SAP App Center)
📌 What is the SAP Store?
✔ An online marketplace from SAP where partners can offer their software products.
✔ Enables the listing of SAP S/4HANA extensions, Fiori apps, and integrations.
✔ Provides Access to thousands of SAP customers worldwide.
📌 Benefits of publishing in the SAP Store:
✔ High visibility for SAP customers.
✔ Customers can discover, test, and purchase solutions.
✔ SAP Store handles payment processing —partners can focus on product development and support.
✔ More than 3,000 apps and services are already available through the store.
📌 How do you publish an add-on in the SAP Store?
1. Registration as an SAP partner is required.
2. SAP review process (verification of quality and integration standards).
3. Optional: SAP certification of the solution (increases customer confidence).
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 the marketing and distribution of SAP extensions.
✔ Four engagement models: Build, Sell, Service, Run.
✔ The “Build” variant is relevant for monetizing an add-on.
📌 Benefits of being a PartnerEdge Build partner:
✔ SAP licenses for development and support.
✔ SAP certification is available for the add-on.
✔ 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 manages distribution agreements to efficiently monetize add-ons.
✔ Consulting & Freelance Services
📌 Monetization through consulting rather than software sales
Many SAP developers offer consulting services instead of selling their add-on separately.
Specialized add-ons are not sold directly but are implemented on a case-by-case basis for each customer.
SAP consultants with expertise in S/4HANA, ABAP, and Fiori are in high demand.
📌 Advantages of the consulting model:
✔ Monetization is achieved through project fees rather than license sales.
✔ Each implementation can be customized to meet the customer's specific needs.
✔ Freelancers often use their own tools and add-ons as “accelerators” to complete projects more quickly.
✔ No need to deal with software distribution and license management —instead, direct billing for development time and expertise.
📌 Who is this model best suited for?
✔ SAP consultants and developers who do not want to handle software sales and support themselves.
✔ Implement customized solutions for customers rather than selling off-the-shelf software products.
✔ Licensing and Sales Models for SAP Add-ons
📌 Possible licensing models:
✔ Per-user licensing (price per user).
✔ Per-server or per-CPU licensing (depending on system size).
✔ Subscription model (SaaS) → Monthly or annual fee for cloud-based add-ons.
✔ Usage-based monetization → Price per processed transaction (e.g., per invoice or order).
📌 Pricing and Maintenance:
✔ Companies expect maintenance contracts → often 15–20% of annual license costs for support and updates.
✔ Offer packages & editions:
Basic Version (Standard Features)
Premium Version (advanced features, integrations)
✔ Pricing must reflect the value → Enterprise customers often require scalability.
📌 Additional sales opportunities:
✔ Collaboration with SAP Sales (e.g., co-selling with SAP account executives).
✔ Add-ons can be offered by SAP partners as part of larger deals.
✔ SAP Store vs. Direct Sales
📌 Differences between sales through the SAP Store and direct sales:
📌 Conclusion:
➡ SAP Store is suitable for small- to medium-sized solutions.
➡ For major account deals, direct sales or an SAP sales partnership is more advantageous.
✔ Collaboration with SAP implementation partners
📌 Advantage: SAP implementation firms work with many clients who have similar requirements.
• If an add-on fills a gap, partners could resell it or recommend it.
• Partnerships with SAP integrators can be a good source of revenue.
✔ SAP PartnerEdge membership enhances credibility and facilitates partner networking.
Key Success Factors for Monetization
✔ Clear documentation of the add-on: features, benefits, and ROI for the customer.
✔ Provide demos or trial versions.
✔ Gather client testimonials and success stories → Build trust with future buyers.
✔ Ensure long-term support and maintenance: Customers expect updates and compatibility with new SAP versions.
📌 Important: Keep an eye on the SAP Roadmap!
• If SAP integrates a similar feature into the standard system, the add-on will need to be modified or repositioned.
• Many successful SAP partner products started out as add-ons → Some were acquired by SAP or have evolved into specialized solutions.
• Monitor the market and continuously incorporate innovations.
📢 Conclusion: Monetization Strategies for SAP Add-ons
✅ Use the SAP Store to reach a wide range of customers.
✅ Join SAP PartnerEdge to receive professional marketing and certification.
✅ Consulting and project work as an alternative to license sales.
✅ Use flexible licensing models (user-based, subscription-based, transaction-based).
✅ Establish partnerships with SAP integrators.
✅ Ensure long-term maintenance and 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 such as SAP, it is important to follow best practices to ensure that add-ons are efficient, secure, and maintainable.
✔ Performance Optimization
📌 Optimizing ABAP Code and Database Queries
• Avoid nested SELECT statements and large loops → Use SQL as directly as possible to maximize HANA performance.
• Prefer CDS views or joins instead of aggregating data in ABAP.
• Create indexes on user-defined tables to speed up data access.
• Use SAP analysis tools:
• SQL Trace (ST05) → Identifies expensive database queries.
• ABAP Runtime Analysis (SAT) → Identifies slow ABAP processes.
• Performance Trace (ST12) → Measures performance and identifies bottlenecks.
📌 Performance Tips for Fiori/UI5
• Use $batch to bundle multiple OData calls into a single query.
• Use server-side paging ($top/$skip) to retrieve only the data you need.
• Use the $select option to load only relevant fields.
• Enable caching for frequently used data.
• Optimize UI5 app load time by loading only the necessary components and avoiding unnecessary libraries.
✔ Security (Security Best Practices)
📌 Security in ABAP Code
• Implement AUTHORITY-CHECK to verify permissions for sensitive operations.
• Create your own authorization objects if the add-on provides new transactions or services.
• Secure dynamic SQL queries and operating system commands to prevent SQL injection and code injection.
• Use random numbers and hashing APIs for encryption (ABAP provides 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 plaintext passwords.
• XSS protection in UI5: Use data binding instead of rendering HTML directly.
• Dynamically adapt the UI to user permissions → Retrieve the user's roles and control which options are visible.
• Apply SAP security patches regularly and scan code using the SAP Code Vulnerability Analyzer.
✔ Error Analysis and Debugging
📌 ABAP Debugging & System Analysis
• Use the SAP GUI Debugger and the Eclipse ADT Debugger to set breakpoints.
• Analyze ABAP dumps (ST22) → If an error occurs, ST22 displays the call stack and variable contents.
• Check the system log (SM21) for system issues.
• Use the application log (SLG1) to create your own logs for error analysis.
📌 Fiori/UI5 Debugging
• Use the browser console (F12) → Analyze JavaScript errors and network errors.
• Check the SAP Gateway Error Log (/IWFND/ERROR_LOG) → Displays failed OData requests with their payloads.
• UI5 Debugging Tools:
• Ctrl + Alt + Shift + P → Show performance statistics.
• Ctrl + Alt + Shift + S → Technical information about the UI5 app.
📌 SAP BTP Debugging
• Check Cloud Foundry logs (cf logs).
• Analyze SAP Cloud Connector logs if on-premises connections fail.
✔ Maintainability and Naming Conventions
📌 Good naming conventions are crucial
• Assign Z/Y prefixes and descriptive suffixes to objects (e.g., ZCUST_REVENUE_VIEW).
• Clearly organize SAP objects → bundle all add-on objects into their own package or namespace.
• Include comments in ABAP code, especially when dealing with complex logic.
• Give preference to standard extension points (BADIs, enhancement spots) rather than modifying standard code.
• If changes to standard objects are necessary, document them, as they must be taken into account during SAP updates.
✔ Testing: Quality Assurance and Stress Testing
📌 Create test data and test scenarios
• Write ABAP unit tests for critical algorithms.
• Perform integration tests in Fiori to ensure that the data flow is working correctly.
• Perform tests using different user roles to validate permissions.
• Run performance tests, such as running a report with 100,000 records and optimizing it.
📌 Conclusion: Why Best Practices Are Important
🚀 By following these best practices, you can significantly improve the quality and reliability of your SAP add-ons:
✅ Better performance → Faster response times & optimized database queries.
✅ Secure applications → Protection against unauthorized access and security vulnerabilities.
✅ Easier maintenance → Well-structured code makes it easier to make changes later on.
✅ Error resilience → Fewer issues in production thanks to debugging strategies.
✅ Better user experience → Fast-loading, stable, and intuitive Fiori apps.
➡ A high-performance, secure, and well-documented add-on reduces support costs and enhances your reputation as a developer or provider. 🚀
Conclusion
By following this guide, a developer with intermediate-level knowledge 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.
✅ Use OData services for integration with SAP.
✅ Understand the options for deploying or monetizing the solution.
✅ Apply best practices for performance optimization and security.
🚀 Practical exercises and visual aids make it much easier to develop SAP add-ons.
📌 With the fundamentals covered here, a developer can not only build their own extensions but also implement and optimize more complex SAP projects.
