SAP Community - SAP Business Application Studio

CREATING CAPM APPLICATION WITH NODE.JS BY USING S/4 HANA DATABASE - Part 2

2025-10-13T08:11:54.622000+02:00

Hello Buddies!!

Have you Subscribed to all our pre-requisites for the development?

No 😐!!!

Don't worry let's set it up. Follow the link below!!

https://community.sap.com/t5/technology-blog-posts-by-members/creating-capm-application-with-node-js-by-using-s-4-hana-database/ba-p/14208638

Welcome to next episode of CREATING CAPM APPLICATION WITH NODE.JS BY USING S/4 HANA DATABASE.

In this Episode Lets Create an Capm Application by Using a Template, So that deployment configurations will be added automatically without manual errors.

Step1: Click on the light = icon and select Project from Template > Cap Project.

Step2: Click on next and Fill the details like Project name, Runtime environment. I named my project as zcapm_hanadb.

Click on Finish. Hurray our app gets generated in few seconds.

Note: Check whether you are subscribed to Hana cloud, which is already there in prerequisites blog, We have also created a instance for that.

Now make sure your Hana db instance is running.

It would take around 10 to 15 minutes to get to running status.

Now let move to SAP BAS where our application got created.

Step3: Run the application as Right click on app> Open in integrated Terminal > Enter command CDS Watch, check whether all the node modules installed or not. Enter Command

npm install

Step4: Next enter the command npm install -g hana-cli. In this we are installing hana cloud Command line interface where we need to push our data into.

Now lets work on our Project before we connect with Data Base.

Step5: In folder structure under db >data-model.cds(I have re-named it on my own interest).Name should be filename.cds

Lets create our Structure, In this there should be one Unique key for every entity you have created.

Code:

namespace zcapm_hanadb;

entity Products {

      @title : 'Sales

Order Number'

    key id: Integer;

      @title : 'Product Name'

    name: String;

      @title : 'Price'

    price: Decimal;

      @title : 'Description'

    description: String;

      @title : 'Stock left'

    stock: Integer;
}

Step 6: In folder structure under srv >cat-service.cds(I have re-named it on my own interest).Name should be filename.cds

In this case lets declare our function calls for get and Post. Just function names are declared in this section where we are about to call them in another file.

Important Note: In defining the cds function please remember two main things,

a) function(Get Call)
b) action (Post Call)

Code:

using zcapm_hanadb from '../db/data-model';
service CatalogService{
  entity Products as projection on zcapm_hanadb.Products;
  // get service call
 function fnCatalogGetService(name: String) returns String;
 // Post service call
action fnCreateRecord(id: Integer, name: String, price: Decimal, description:String, stock: Integer) returns String;
}

Step 7: In this let's create one more file under srv>cds-service.js (filename.js).

In this file we will write our node js logic for functions we have declared in cat-service.cds.

Code:

const cds = require('@sap/cds');
const {Products} = cds.entities('zcapm_hanadb');
module.exports = cds.service.impl(async function() {
   //Get call
this.on('fnCatalogGetService', async (req) => {
    const { name } = req.data;
 console.log(name, "Hello World");
// Post call
this.on('fnCreateRecord', async (req) => {
 const { id, name, price, description, stock } = req.data;
console.log("Hello World is working fine");
})
});

Now we have created our very basic structure of entity and has given a service name under it. In order to utilize our service lets deploy our app to S/4 Hana DB and call data from it.

Command: cds build (Find there any errors in the terminal)

command: cds watch (Run the app).

Note: If you found error message like in above image, then follow below steps.

First enter Ctrl + C (To End the process)
Click = > View > Command Palette.

Enter Stop port and select below one.

Once it is done, now again enter the cds watch. You will find the screen like below where you you can find your service.

Step 8: Lets connect to our app to S/4 Hana DB.

On the top-left most corner where our project we have opened, there when you minimize it you will find SAP HANA PROJECTS. Open them.

Step 9: Expand our project.

Step 10: Under Database Connections we can find the same project name.

Click on the Green socket symbol to bind our project to HDI container (i.e., Hana DB container).

Bind to an HDI container

Click on new service instance, it will suggest you a name(you can rename it or use it as it is)

Note: Make sure your Hana Cloud is running

On clicking on top of Database Connections click on bind all.

Next Click on Hana HD Container symbol which is on the top of project.

Mean while if you want to know what are all services got generated. Enter the command

cf services

We can see our instance got reflected in sap BTP as well.

Application gets open here you can find your container with in built database with the instance we have created.

Step 11: Our service got binded in the HDI Container and let's deploy our app.

Click on the deploy icon(Rocket icon) under hana projects > your project.

Our deployment looks like below screen.

Under project > db you can observe all our hana database files got created.

Navigate to Hana db explorer, we see our app got deployed. Refresh the page.

As our structure is ready let’s add some data in it.

Step 12: Right click on your entity and select import data. Filename should be same as entity name which we have maintained in db>data-model.cds

File Data I Have Uploaded Here..

Id	name	price	Description	stock
1	Widget A	19.99	A useful widget for various tasks	100
2	Widget B	29.99	An advanced widget with additional features	50
3	Widget C	39.99	A premium widget designed for expert users	25

In Step3 it automatically reads the table from the data imported.

Once you click on Review, this looks like below

Click on import to database

Hurray! we don’t have any errors and it's successfully imported.

Now import it to our database table Review > Import data.

Now right click and click on Open Data.

As our database is having the data now, we need to have scope to access it in our application.

Lets run the application command: cds watch --profile hybrid.

Here after we will be using this command as will compile the runtime dependencies.

Error: Data is not loaded let's fix it up!!!

We need to add the shared key access for the cloud foundry

Step 13: Go to btp cockpit and the service instance that we have created during deployment process, Copy it.

Copy the Bold letters as an Instance name and type in with the command in your app

Command: cds bind -2 <instanceName>:SharedDevKey

Instance key also gets appeared on top of hana DB explorer.

Step 14: Next run cds watch --profile hybrid

Click on Products and Check your metadata is loaded or not.

Hurray!!! My data got loaded successfully.

In next session lets perform CRUD Operations on S/4 Hana data from SAP Fiori app as Front end...Stay Tuned😉

References:

https://fioriappslibrary.hana.ondemand.com/sap/fix/externalViewer/

https://community.sap.com/t5/technology-q-a/creating-capm-application-with-node-js-by-using-s-4-hana...

https://help.sap.com/fiori_bs2013/helpdata/en/a7/1564526ba1f25fe10000000a423f68/content.htm?no_cache...

Hope it’s helpful 😊

Thanks,
Divya MANDAVA.

SAP UI5 application to Export Data to spreadsheet from SAP UI5 tree table (sap.ui.table.TreeTable)

2025-10-23T06:28:28.730000+02:00

Introduction :
In this article, we are going to understand how to implement export functionality the sap.ui.table.TreeTable table data to the excel(Spreadsheet) using sap.ui.export.Spreadsheet library. In this application, we are going to create an SAP UI5 free style application which has sample JSON data that has employees and their family details for the expense share percentage of the medical insurance (taken as an example) and that has been binded to the UI table and a toggle button has been added to trigger the export or downloading the excel data.

Procedure:
This is step by step guide to create a fiori application with SAP UI5 UI table and Export Button
Step 1: Create a Fiori Project

To begin, create a new SAP Fiori project using the Fiori Generator Freestyle - Basic template. This will serve as the foundation for our application.

Application Folder Structure:

Step 2 : Create a Dynamic Page , add UI Table Details and Add the sample JSON Data in controller

In TreeTableView.view.xml, Add this code and add the Sample JSON data model object in the onInit() in TreeTableView.Controller.js .

TreeTableView.view.xml

<mvc:View
    controllerName="com.example.treeexporttoexcel.controller.TreeTableView"
    xmlns:mvc="sap.ui.core.mvc"
    xmlns="sap.m"
    xmlns:table="sap.ui.table"
>
    <Page
        id="page"
        title="{i18n>title}"
    >
        <content>
            <table:TreeTable
                id="employeeTreeTable"
                selectionMode="None"
                enableColumnReordering="false"
                rows="{ 
       path : '/Employees',
       parameters :{
       arrayNames:['Employees','FamilyMembers']
       }
        }"
            >
               <table:extension>
                 <OverflowToolbar>
                        <Title text="{i18n>title}" />
                        <ToolbarSpacer />
                        <ToggleButton id="export_btn" text="{i18n>export_btn}" icon="sap-icon://excel-attachment" press="onExcelExport"/>
                    </OverflowToolbar>
               </table:extension>     
                <table:columns>
                    <table:Column>
                        <table:label>
                            <Text text="{i18n>employeeID}" />
                        </table:label>
                        <table:template>
                            <Text text="{EmployeeID}" />
                        </table:template>
                    </table:Column>
                    <table:Column>
                        <table:label>
                            <Text text="{i18n>employeeName}" />
                        </table:label>
                        <table:template>
                            <Text text="{EmployeeName}" />
                        </table:template>
                    </table:Column>
                    <table:Column>
                        <table:label>
                            <Text text="{i18n>designation}" />
                        </table:label>
                        <table:template>
                            <Text text="{Designation} " />
                        </table:template>
                    </table:Column>
                    <table:Column>
                        <table:label>
                            <Text text="{i18n>familyMemberName}" />
                        </table:label>
                        <table:template>
                            <Text text="{MemberName}" />
                        </table:template>
                    </table:Column>
                    <table:Column>
                        <table:label>
                            <Text text="{i18n>relation}" />
                        </table:label>
                        <table:template>
                            <Text text="{Relationship}" />
                        </table:template>
                    </table:Column>
                    <table:Column>
                        <table:label>
                            <Text text="{i18n>age}" />
                        </table:label>
                        <table:template>
                            <Text text="{Age}" />
                        </table:template>
                    </table:Column>
                    <table:Column>
                        <table:label>
                            <Text text="{i18n>expense}" />
                        </table:label>
                        <table:template>
                            <Text text="{ExpenseShare}" />
                        </table:template>
                    </table:Column>
                </table:columns>
            </table:TreeTable>
        </content>
    </Page>
</mvc:View>

TreeTable.controller.js

sap.ui.define([
    "sap/ui/core/mvc/Controller",
    "sap/ui/model/json/JSONModel",
    "sap/m/MessageToast",
    "sap/ui/export/Spreadsheet"
], (Controller, JSONModel, MessageToast, Spreadsheet) => {
    "use strict";

    return Controller.extend("com.example.treeexporttoexcel.controller.TreeTableView", {
        onInit() {
            var oView = this.getOwnerComponent();
            var oDataModel = new JSONModel();
            var aData = {
                "Employees": [
                    {
                        "EmployeeID": "E001",
                        "EmployeeName": "Ramesh",
                        "Designation": "Manager",
                        "FamilyMembers": [
                            {
                                "MemberName": "Anitha",
                                "Age": 35,
                                "Relationship": "Wife",
                                "ExpenseShare": 40
                            },
                            {
                                "MemberName": "Rohith",
                                "Age": 10,
                                "Relationship": "Son",
                                "ExpenseShare": 20
                            },
                            {
                                "MemberName": "Ramanaiah",
                                "Age": 65,
                                "Relationship": "Father",
                                "ExpenseShare": 20
                            },
                            {
                                "MemberName": "Kamala",
                                "Age": 60,
                                "Relationship": "Mother",
                                "ExpenseShare": 20
                            }
                        ]
                    },
                    {
                        "EmployeeID": "E002",
                        "EmployeeName": "Sumana",
                        "Designation": "Developer",
                        "FamilyMembers": [
                            {
                                "MemberName": "Bhargav",
                                "Age": 35,
                                "Relationship": "Husband",
                                "ExpenseShare": 20
                            },
                            {
                                "MemberName": "Prasanna",
                                "Age": 9,
                                "Relationship": "Daughter",
                                "ExpenseShare": 20
                            },
                            {
                                "MemberName": "Ananda",
                                "Age": 58,
                                "Relationship": "Father",
                                "ExpenseShare": 40
                            },
                            {
                                "MemberName": "Srinidhi",
                                "Age": 55,
                                "Relationship": "Mother",
                                "ExpenseShare": 20
                            }
                        ]
                    },
                    {
                        "EmployeeID": "E003",
                        "EmployeeName": "Manish",
                        "Designation": "Auditor",
                        "FamilyMembers": [
                            {
                                "MemberName": "Bhumesh",
                                "Age": 58,
                                "Relationship": "Father",
                                "ExpenseShare": 60
                            },
                            {
                                "MemberName": "Rajeswari",
                                "Age": 50,
                                "Relationship": "Mother",
                                "ExpenseShare": 40
                            }
                        ]
                    }

                ]
            }

            oDataModel.setData(aData);
            oView.setModel(oDataModel);
        },
}); 
});

Step 3 : Implement the press event trigger of the Export To excel Button
Add this logic in controller.js . "sap/ui/export/Spreadsheet" is the library should be used for excel export.
_convertTreeForExport() is a recursive function to fetch the child records converts to flat structure and pushes to the export data where this export data is passed to the settings of the excel sheet data.
TableView.controller.js

 onExcelExport() {
            var oBundle = this.getOwnerComponent().getModel("i18n").getResourceBundle();
            var oTable = this.byId("employeeTreeTable");
            var oBinding = oTable.getBinding("rows");
            var aData = oBinding.getModel().getProperty("/Employees");
            var aExportData = this._convertTreeForExport(aData);
            var aCols = [
                {
                    label : oBundle.getText("employeeID"),
                    property :"EmployeeID"
                },
                {
                     label : oBundle.getText("employeeName"),
                    property :"EmployeeName"

                },
                {
                      label : oBundle.getText("designation"),
                    property :"Designation"
                },
                {
                       label :oBundle.getText("familyMemberName"),
                    property :"MemberName"

                },
                {

                       label : oBundle.getText("relation"),
                    property :"Relationship"
                },
                  {

                       label : oBundle.getText("age"),
                    property :"Age"
                }, {

                       label :  oBundle.getText("expense"),
                    property :"ExpenseShare"
                }
            ]
            var oSettings = {
                workbook: {
                    columns: aCols,
                    context: {
                        sheetName: oBundle.getText("sheetName")
                    }
                },
                dataSource: aExportData,
                fileName: oBundle.getText("fileName"),
                worker: false
            };
            var oSpreadsheet = new Spreadsheet(oSettings);
            oSpreadsheet.build().then(function () {
                MessageToast.show(oBundle.getText("successMessage"));
            }).finally(function () {
                oSpreadsheet.destroy();
            })
        },
          
        _convertTreeForExport(aNodes, iLevel =0, aResult =[]){
// aNodes will have the tree table  data 
// iLevel -> current hierarchy depth initializes with 0
// aResult -> collector array of the flattened data 
            aNodes.forEach(oNode => {
                // taking shallow copy of each node to perform manipulations on the copy node without  // disturbing the actual data node
                   var oCopy = { ...oNode };
// deleting FamilyMembers nested structure to avoid recursion loops if not deleted it will throw  // the maximum call stack exceeded error
                delete oCopy.FamilyMembers;
                oCopy.level = iLevel + 1;
// creates a new field for visualize indentation  parent, child, grandchild etc., 
                oCopy.IndentedName = `${"".repeat(iLevel*4)}${oNode.name}`
                aResult.push(oCopy);
                if(oNode.FamilyMembers && oNode.FamilyMembers.length > 0){
                    this._convertTreeForExport(oNode.FamilyMembers, iLevel + 1, aResult);
                }
            });
               return aResult
        }

Application Screen:

ExportData.xlsx

Git Link for reference
https://github.com/RangarajasreeSV/tree-table-export-to-excel-ui5

Conclusion:
By following these steps, We can achieve the export functionality of the The SAP UI tree table data to the Excel spreadsheet.

Thanks and Regards,
Sree Vedavyasa Rangarajasree

UX and application development with AI at ASUG Tech Connect 2025 a companion event to SAP TechEd

2025-10-24T18:39:30.067000+02:00

Read the post-event summary: https://community.sap.com/t5/enterprise-resource-planning-blog-posts-by-sap/asug-tech-connect-2025-summary-vibe-coding-ux-innovation-and-ai-everywhere/ba-p/14264755

*****

This year, SAP TechEd has several options to allow you to learn about the latest SAP technologies and how to apply them to your organization. In addition to TechEd in Berlin and the virtual option, there are “SAP TechEd On Tour” events in Louisville, Sydney, and Bangalore. In this post, I’ll share the sessions on application development and user experience that we are presenting at ASUG Tech Connect in Louisville, Kentucky. As you would expect many have AI -assisted capabilities to make both business users and developers more productive.

At ASUG Tech Connect, we have both lectures and hands-on workshops.

Lectures are a chance to hear from SAP experts and have your questions answered in the room.

Extensibility with ABAP Cloud and AI in SAP Cloud ERP (Jens Weiler)
Explore on-stack key user and developer tools in the ABAP Cloud development model, now enhanced with generative AI. Extend standard apps and manage custom ones in SAP Cloud ERP and explore transactional, analytical, and integration use cases like the extensibility AI assistant, queries for analytical SAP Fiori apps, and SQL services.
Tuesday, November 4, 2025, 11:15 AM-12:05 PM

What’s Next: AI-First Innovations in SAP Cloud ERP and SAP Business Suite (Ullas Holla, Peter Spielvogel)
Get a fast-paced look at how SAP is embedding AI and delivering cross-suite innovations that break down silos and speed up decision-making. We’ll cover the latest highlights from releases of SAP Cloud ERP and SAP Business Suite—plus give you a sneak peek at what’s coming in 2026 and beyond.
Tuesday, November 4, 2025, 3:30 PM-4:20 PM

Customer Show and Tell: From CDS View to Fiori Launchpad: Full-Stack Development with Eclipse ADT with Naturipe (Brian Galloway, Dario Cruz)
This session covers the end-to-end development workflow in the RISE with SAP S/4HANA Cloud, Private Edition environment using Eclipse ABAP Development Tools (ADT). It demonstrates how to define a data source and expose it via a CDS view, enabling consumption through SAP Fiori elements, Eclipse ADT, and Postman. A live demo illustrates the creation of a simple SAPUI5 application that consumes the same OData service and is deployed to the SAP Fiori Launchpad, showcasing full-stack integration from backend data modeling to frontend delivery.
Wednesday, November 5, 2025, 8:00 AM-9:30 AM

Using Generative AI to Accelerate SAP Fiori App Development (Ullas Holla)
AI changes everything, especially for developing business applications. See how SAP’s latest coding agents let you build SAP Fiori elements apps using a conversational interface. Create apps using Joule, including a CAP service, sample data, and SAPUI5 customizations.
Wednesday, November 5, 2025, 4:10 PM-5:00 PM

Creating Better User Experiences with AI-Powered SAP Fiori Apps (Peter Spielvogel)
Discover how the latest AI features in SAP Fiori apps enhance user productivity and streamline onboarding. Starting with My Home and diving into commonly used SAP Fiori apps, see how AI simplifies information access, supports informed business decisions, and fosters seamless collaboration. Explore how conversational interactions are making SAP more intuitive than ever.
Thursday, November 6, 2025, 4:15 PM-5:05 PM

Hands-on workshops give you the opportunity to test the latest SAP innovations and gain access to the same tools and technologies we use to build apps for SAP S/4HANA.

Hands-on Lab: Get Started with ABAP Cloud for Classic ABAP Developers
Familiar with classic ABAP development? Explore how similar development works with ABAP Cloud using the ABAP RESTful application programming model. Use ABAP Cloud to build cloud-ready business apps, services, and extensions that follow clean core principles by default—on SAP Business Technology Platform and in any edition of SAP S/4HANA.
Tuesday, November 4, 2025, 1:10 PM-3:10 PM

Hands-on Lab: Explore Joule for Developers, ABAP AI Capabilities
Learn how to develop transactional applications using the ABAP RESTful application model in ABAP Cloud while leveraging Joule capabilities for ABAP developers.
Wednesday, November 5, 2025, 8:00 AM-10:00 AM

Hands-on Lab: Build On-Stack Extensions with ABAP Cloud in SAP Cloud ERP
Discover how to build extensions, applications, and services with the ABAP Cloud development model, using the ABAP RESTful application programming model and generative AI. You can explore how to extend standard SAP applications, consume public SAP APIs, and build new apps and services from scratch while getting practical insights through exercises
Wednesday, November 5, 2025, 1:00 PM-3:00 PM

Hands-on Lab: Modernize Classic Extensions for Clean Core in SAP Cloud ERP Private
Practice clean core extensibility in SAP Cloud ERP Private. Learn how to govern clean core development using the ABAP test cockpit, and how to use the ABAP Cloud development model and clean core extensibility principles to modernize your custom on-stack extensions.
Thursday, November 6, 2025, 1:00 PM-3:00 PM

Discovery Workshop: Start Your AI Agent Journey by Exploring AI Agent Use Cases
In this discovery workshop, you will learn how AI Agents function and what makes a strong use case. You will identify and prioritize strategic AI Agent use cases for your business. For your selected use case, you will explore how AI Agent capabilities can address your specific business challenges and learn the next steps for designing and building an AI Agent using the SAP Agent Builder.
Thursday November 6, 2025, 1:00 PM-3:00 PM

I hope you can join us.

Preparing for SAP C_CPE? Here’s How I’m Studying Each Section Without Feeling Overwhelmed

2025-11-04T15:23:22.635000+01:00

Whenever I start learning something new, I like to have everything in order.
Before I even open the first tutorial, I plan what I’ll study first, what comes next, and how I’ll track it.

Recently, I started preparing for the SAP C_CPE (SAP Certified Associate - Backend Developer - SAP Cloud Application Programming Model) certification. Since this exam covers a mix of BTP architecture, SAP BAS, CAP, Side by side extensions, Cloud Foundry & Kyma Runtime it can easily feel like too much at once. So I created a simple structure to move step by step without feeling lost.

I began with the learning about BTP, and doing hands on by following SAP Learning Journeys, creating subaccount and adding entitlements and services (It gave me a very clear understanding of BTP architecture) and then Developing appliaction using high productivity tools of SAP BAS, Cloud Application Programming Model (CAP) because it’s the foundation of most topics in this certification. I’m spending around two weeks learning about CDS models, service layers and how everything connects in a CAP project. I’m following the official SAP Learning Journey https://learning.sap.com/certifications/sap-certified-associate-backend-developer-sap-cloud-program…...

My next focus is Cloud Foundry. I’ll spend about a week learning how to efficiently develop, run, and manage cloud-native applications on SAP BTP, Cloud Foundry Runtime.

After that, I’ll move to Side by side extention on BTP. This will cover deploying extension and integrating the app into SAP Build Work Zone.

The next stage is Developing Appliactions in Kyma Environment. I’ll take about two weeks to explore a comprehensive understanding of Kubernetes and to orchestrate the deployment of the applications in the cloud.

Finally, I’ll study Advanced Extensions with SAP Cloud SDK for about two more weeks. These are slightly advanced topics but very useful for understanding to develop and integrate Java, JavaScript, and TypeScript extension applications for SAP solutions like SAP S/4HANA Cloud Public Edition.

So in short, this will be my roadmap-

Recommended Study Sequence

Here’s the order I suggest, from foundational to more advanced :

1.Exploring SAP Business Technology Platform 5hrs (link : https://learning.sap.com/courses/exploring-sap-business-technology-platform)

This gives you a broad overview of the entire platform (services, architecture, what BTP is). Good for building your base understanding.
So start here.

2.Develop Full‑Stack Applications Using Productivity Tools in SAP Business Application Studio 8hrs (https://learning.sap.com/learning-journeys/develop-full-stack-applications-using-productivity-tools-in-sap-business-application-studio)

3.Develop Applications on SAP BTP, Cloud Foundry Runtime 4hrs(https://learning.sap.com/learning-journeys/developing-applications-on-sap-btp-cloud-foundry-runtime)

The Cloud Foundry runtime is a major runtime environment in BTP. Understanding how to build and deploy there is critical.

4.Build Side‑by‑Side Extensions on SAP BTP 8hrs (https://learning.sap.com/learning-journeys/build-side-by-side-extensions-on-sap-btp)

After tooling and platform basics, you dive into extension scenarios (for example side-by-side extensions of S/4HANA using CAP). This aligns closely with CAP certification topics.

5.Developing Applications in SAP BTP, Kyma Runtime 8hrs(https://learning.sap.com/learning-journeys/developing-applications-in-sap-btp-kyma-runtime)

Kyma Runtime is more advanced (Kubernetes, microservices, event-mesh) and often sits on top of foundational knowledge.

6.Develop Advanced Extensions with SAP Cloud SDK 11hrs (https://learning.sap.com/learning-journeys/develop-advanced-extensions-with-sap-cloud-sdk)

This is relatively specialized/advanced (SAP Cloud SDK, perhaps custom libraries, integrations). Once you’ve mastered the fundamentals above, you go here.

By the end of this plan, I’ll go through a short revision period with mock questions and quick notes from my learning.

This structured approach keeps my study plan clear and prevents me from feeling overwhelmed.
I study for two to four hours a day which feels realistic, and the small milestones make it easier to stay consistent.

If you’re also preparing for C_CPE, it really helps to make your own sequence instead of jumping randomly between topics. The Learning Journeys are excellent resources, but having a personal roadmap makes a big difference.

I’d love to hear how others are preparing for this certification too.
What topics are you finding most challenging so far and how are you managing the learning

Develop Full-Stack ABAP Applications in SAP Business Application Studio

2025-11-11T09:36:43.801000+01:00

The SAP Business Application Studio provides several extensions designed to streamline the development of business applications for the SAP Intelligent Enterprise.

Among these extensions is the CDS Graphical Modeler, which enables SAP business developers to visually design Core Data Service (CDS) models. Previously, this extension was available for SAP Cloud Application Programming (CAP) development projects.

However, with the release of SAP BTP ABAP environment 2508 and SAP S/4HANA Cloud Public Edition 2508, corresponding to ABAP release 9.16, we have integrated the CDS Graphical Modeler with ABAP. This integration allows developers to create ABAP projects using the CDS Graphical Modeler to conveniently design ABAP-compliant CDS models for various scenarios in a remote ABAP system.

Ultimately, you can now build full-stack ABAP applications in SAP Business Application Studio. Once you've created an ABAP project, you can model business objects, generate ABAP CDS artifacts, integrate a user interface, and deploy your application to the appropriate environments, such as SAP BTP ABAP environment or SAP S/4HANA Cloud Public Edition.

Curious how this works? Check out our documentation on SAP Help Portal for detailed instructions: Develop Full-Stack ABAP Applications in SAP Business Application Studio.

But you’re short on time or just looking for a quick peek? Keep reading! 😉

1. Set Up Your Full-Stack ABAP Project:

In the SAP Build Lobby, choose Create right above the project list and select Create from the drop-down menu. This opens the Create Project dialog.

Project creation screen with options for Application, Automated Process, and Business Site, highlighting Application with a "Next" button.

In the Create Project dialog, select Application, click Next, select Full-Stack, advance with Next, and finally select Full-Stack ABAP (SAP Business Application Studio).

"Full-Stack ABAP (SAP Business Application Studio)" option is selected for creating a project with a "Next" button available.

Advance with Next and specify the target ABAP system and configure the project details.
Once the project is created, a Core Schema Notation Model is created in the remote ABAP system, and the remote ABAP package path is added to the workspace. The project then opens in the Storyboard.

2. Model Your Application:

From the Storyboard, you can model your ABAP application using the CDS Graphical Modeler to define and visualize your ABAP RESTful Application Programming Model (RAP) business objects, projections, and services relevant to your application development.

Storyboard offers options to create a business object, projection, service, or UI application with corresponding plus buttons.

Choose + in the Create an entity field to add the business object entities and define their relationship for the business service.

Note: Next to the Business Object modeler, you see your CSN file. This file resides on your ABAP system in the package you created previously. This file is used by the modeler to store your model. You should not edit this file manually since this can damage the integrity of the model.

Proceed with adding projections to specify which elements of a business object are exposed in the business service.

Add a business service and select which entities to expose in the service.

Storyboard shows the relation of business objects, projections, and services and an option to create a new UI application.

You are now all set to generate the ABAP backend artefacts from the modeled business objects, projections, and services. Close the Business Services modeler and return to the Storyboard.

3. Generate ABAP CDS Artifacts:

Once you have modeled your ABAP application, you need to generate the ABAP development objects based on the data model created with the CDS Graphical Modeler, including DDIC tables, CDS views, metadata extensions, and service definitions.

From the Storyboard, choose Generate and follow the steps in the wizard to perform validation checks and complete the generation process.
As a result, a RAP OData UI service is generated and available in the service catalog. On the ABAP side, the development objects are activated, and the service binding is published.

4. Add a User Interface and Deploy Your Application:

As a last step, you need to create a user interface for your RAP service by generating a SAP Fiori UI application that you can then deploy to an appropriate environment, such as SAP BTP ABAP Environment or SAP S/4HANA Cloud Public Edition.

From the Storyboard, choose + in the UI Applications field to open the SAP Fiori Generator wizard and provide the required inputs for your UI development. To deploy the application, choose Deploy from the Application Information tab.

And that's it! You've successfully developed a full-stack ABAP application in SAP Business Application Studio—quickly and effortlessly in just a few steps.

What do you think of it? We would love to hear your thoughts! Share your feedback in the comments below.

Send Email in SAP CAP After Deprecation of @sap-cloud-sdk/mail-client

2025-11-13T05:30:34.813000+01:00

🚀 Introduction

If you’ve recently upgraded your SAP CAP project, you might have noticed that the @Pa_Vi-cloud-sdk/mail-client package is now deprecated. This package was previously used to trigger emails from CAP applications via destinations on SAP BTP.

In this post, we’ll walk through a simple yet powerful alternative using Nodemailer, a Node.js-based email library, to send formatted HTML emails directly from CAP services — ideal for workflows such as failure notifications, approvals, or report generation alerts.

🧱 Prerequisites

SAP CAP Project (Node.js-based)
Access to a Mail Server (Destination screenshot attached)
Basic knowledge of Node.js modules
Installed dependency:

npm install nodemailer axios @sap-cloud-sdk/connectivity

⚙️ Step 1: Set Up Nodemailer in CAP

Create a utility file srv/utils/mailService.js and configure your mail transporter using the destination defined in SAP BTP.

Authentication: OAuth2ClientCredentials

This means your mail destination uses a client ID and client secret to fetch an access token before sending mail — (Basic Authentication case we use username and password ).

const axios = require("axios");
const nodemailer = require("nodemailer");
const { getDestination } = require("@sap-cloud-sdk/connectivity");

async function sendEmail(mailService, to, subject, body) {
  try {
    // 1️⃣ Fetch destination details from BTP
    const destination = await getDestination({
      destinationName: mailService.destination,
    });

    if (!destination) {
      throw new Error("Destination not found.");
    }

    // 2️⃣ Extract required properties
    const host = destination.originalProperties.destinationConfiguration["mail.smtp.host"];
    const port = destination.originalProperties.destinationConfiguration["mail.smtp.port"];
    const user = destination.originalProperties.destinationConfiguration["mail.smtp.from"];
    const tokenUrl = destination.tokenServiceUrl;
    const clientId = destination.clientId;
    const clientSecret = destination.clientSecret;
    const scope = destination.originalProperties.destinationConfiguration["scope"];

    // 3️⃣ Get OAuth2 access token
    const tokenResponse = await axios.post(
      tokenUrl,
      new URLSearchParams({
        client_id: clientId,
        client_secret: clientSecret,
        scope,
        grant_type: "client_credentials",
      }),
      {
        headers: { "Content-Type": "application/x-www-form-urlencoded" },
      }
    );

    const accessToken = tokenResponse.data.access_token;

    // 4️⃣ Create transporter for SMTP with OAuth2
    const transporter = nodemailer.createTransport({
      host,
      port: Number(port),
      secure: false,
      auth: {
        type: "OAuth2",
        user,
        accessToken,
      },
      tls: {
        rejectUnauthorized: false,
      },
    });

    // 5️⃣ Mail details
    const mailOptions = {
      from: user,
      to,
      subject,
      // text: "text message" use this when you want to send only text message
      html: body,
    };

    // 6️⃣ Send mail
    await transporter.sendMail(mailOptions);

    console.log("✅ Mail sent successfully");
    return "Mail sent successfully";
  } catch (err) {
    console.error("❌ Mail send failed:", err.response?.data || err);
    throw new Error("Mail send failed: " + err.message);
  }
}

module.exports = { sendEmail };

📩 Step 2: Create a Formatted HTML Template

Here’s an HTML mail template for a simple Hello Message:

export const simpleHelloMailTemplate = (recipientName) => `
  <p>Dear ${recipientName},</p>

  <p>
    This is a <b>test email</b> sent from the <b>SAP CAP Application</b> using Nodemailer.
  </p>

  <p>
    Best Regards,<br>
    Shahrukh
  </p>
`;

🧠 Step 3: Trigger Email in CAP Event or Error Handler

Now call this mail utility in your CAP event handler whenever a workflow or process fails or requires a notification:

import { sendEmail } from "./utils/mailService.js";
import { simpleHelloMailTemplate } from "./utils/mailTemplate.js";

this.on("sendEmail", async (req) => {
  try {
    const html = simpleHelloMailTemplate("SRK");

    await sendEmail(
      { destination: "mail-service-destination" }, // your destination name
      "yourEmail@sap.com",
      "Hello Mail",
      html
    );

    return "✅ Mail sent successfully!";
  } catch (err) {
    console.error("❌ Mail sending failed:", err);
    req.error(500, "Mail Not Sent");
  }
});

🔐 Step 4: Secure OAuth2 Credentials

Since this setup already uses OAuth2 Client Credentials from the BTP destination, you don’t need to store or manage usernames/passwords. The client ID and client secret are securely stored within your destination configuration on BTP, and tokens are fetched dynamically at runtime.

Attached Destination screenshot for reference

✅ No manual secret management required! Just make sure your CAP application is bound to the destination service instance so it can fetch credentials using the SAP Connectivity service.

🌟 Result

Once implemented, you’ll receive a well-formatted email notification like this:

Subject: Hello Mail

Dear SRK,
This is a test email sent from the SAP CAP Application using Nodemailer.
Best Regards,
Shahrukh

If you’ve received this message, your mail configuration is working perfectly! 🎉

🧩 Key Takeaways

@Pa_Vi-cloud-sdk/mail-client is deprecated — use Nodemailer with OAuth2 for modern email handling.
No need to manage passwords manually; BTP destinations handle tokens securely.
Integrate HTML mail templates for clear and professional messages.
Ideal for CAP event-driven notifications and failure alerts.

💡 Conclusion

This approach gives you full control and flexibility over how emails are formatted, triggered, and secured within SAP CAP projects — without relying on deprecated packages. It’s lightweight, production-ready, and works seamlessly on SAP BTP Cloud Foundry environments using OAuth2-based authentication.

🏷️ Suggested Tags

SAP CAP, SAP BTP, Email Integration, Workflow Automation, Nodemailer, CAPM, Cloud Application Programming Model, SAP Developers

Joule in SAP Build Code can now create freestyle UI5 apps

2025-11-13T15:58:38.496000+01:00

Last year, we introduced the SAPUI5 extension for the Joule coding assistant in SAP Build Code and wrote about how to use it. Over time, it has received more features, like the AI-supported conversion of UI5 apps to TypeScript and setting up new pages and the respective navigation.

The latest improvement, available from November 2025, lets you create new freestyle UI5 apps according to your requirements. The feature is not absolutely groundbreaking, as there are other tools doing a similar job like the Easy-UI5 templates and the recently published UI5 MCP Server. But:

It brings the functionality right to the fingertips of developers using SAP Build Code—no other tools needed.
It extends the template capabilities beyond what the Easy-UI5 templates provide.
Implementing it within the Build Code Joule environment yielded interesting insights and further improvements. More on this in my other article.

The feature

Joule makes specific features available using "slash commands". The new one is /ui5-create-app. When you open the Joule panel in SAP Build Code and start typing /ui5, you might see it suggested, as well as other UI5 features. But which commands appear depends on the context. While some are only available within UI5 apps, this new feature is only available when you are not in a UI5 app. It won't be available e.g. in a workspace which has a ui5.yaml at top-level, or when you have a UI5 controller open in the code editor!

Try it in a workspace with a CAP project at root level, so you see some of its magic immediately: as soon as you finish typing the slash command or select it from the suggestion list, another suggestion list with sample prompts comes up. These are based on the actual data structures of the CAP project.

This means you can simply select the desired entity and service, then the actual full prompt will automatically be entered into the field(but of course you can also write your own prompt!). This full prompt includes even more details than the short prompt in the suggestion list did.

Note that the prompt includes a concrete list of properties and the service URL. This information has been extracted from CAP using good old deterministic code—no Large Language Model (LLM) used. In fact, this is an area where AI would likely make up ("hallucinate") property names which do not actually exist. Acquiring all this information in advance in a deterministic way not only gives you the chance to review and adjust the prompt with little effort, but also leads to a more reliable functionality overall.

The paradigm: use LLMs (Large Language Models) where they excel—processing and "understanding" language—and use deterministic code for hard facts and well-defined operations, where possible.

The AI part starts soon enough, when you submit this prompt. It proposes a specific app setup, highlighting the key choices for you to review. For example, it will suggest a sensible name (if you didn't provide one) or suggest the best location inside the project structure (which it knows from its context).

But you can do more than just review those parameters. A suggested version of the app has already been created behind the scenes, so you can scroll through the 30+ files listed in the box at the bottom and click those you want to preview. If the result already looks fine to you—perfect. Just press the "Accept Application" button and the app will be set up in your workspace.

Refining the app

But of course you are free to continue the conversation and tweak the result. The LLM in Joule will put its true strength at work, mapping its understanding of your request to what the underlying template can do. No need to type "change parameter x to value y": LLMs also understand you when you are less formal and direct. Look at the below screenshot for an example: it responds almost too compassionately to the developer who is "hesitant about new technologies" and recreates the app with changed parameters—using JavaScript instead of TypeScript. The user did not even mention the programming language specifically, but still the LLM decided that changing it would be the best way to accommodate the app code to the user's preferences.

At this stage, you can refine the setup of the initial app—within the limits imposed by the application template used behind the scenes, which only has limited degrees of freedom. We want this initial app to be robust and follow best-practice code. We also want those 30+ files to be created in one fast step. Hence the code is not written by AI, but by using predefined template files we are back in the world of traditional deterministic coding here. You have plenty of opportunity for using AI later on to extend the app from this solid starting point.

Joule is aware of its limits in this step, so it will not say "yes" to every request you throw at it. Asking for "a trillion tables" or other features beyond the template scope will be politely rejected.

Accepting the app

When the preview looks good and you have pressed the button, the job of this /ui5-create-app assistant is done. After app setup has finished (which may take a while because the dependencies need to be installed), it concludes with hints how to continue, including instructions on how to start the app in your respective workspace setup.

The created application looks roughly like this, with a table and a detail form below. Note: only OData V4 services are supported at this time.

You get this kind of UI when you specify an OData V4 service and entity. If you don't, then there is just a generic "Hello World" success page instead.

Of course this UI structure might not be exactly what is desired in the app or even requested in the prompt, but this is what the template can do. When an OData service and entity but no properties are requested, then the tool tries to detect existing properties. If this fails, the table will be empty (no columns at all)—but Joule's success message should then mention this.

After creation

As the assistant suggests, please move to the other Joule assistants /ui5 and /ui5-create-page for developing the app further. In order to create more apps, reset the conversation with the button at the top of the Joule pane.

Because /ui5-create-app knows that it cannot modify the app or re-create it, it will politely guide you to the options you have, no matter what your request is. It may even give instructions on how to achieve the given goal within a UI5 app, but it will not be able to modify the code and it will make this clear when needed.

AI Learnings

While there is not much more to say about this feature—simply try it!—there are some facts and learnings about its implementation! If you are curious, head over to the second part of this blog post: Inside Joule: Lessons from building an AI coding assistant for SAP Build.

Inside Joule: Lessons from building an AI coding assistant for SAP Build

2025-11-13T16:00:38.750000+01:00

Flashback: the feature

This is a "making of" article about the implementation of the new /ui5-create-app slash command available within Joule in SAP Build Code. In short, this new feature enables a conversation between AI assistant and application developer about a new freestyle UI5 application to build, with a full-fledged best-practice application starting point as result.

To see screenshots of this feature in action and understand it better, feel invited to read my previous blog post. If you are just here for the background and AI-related learnings—go ahead!

General considerations

With open‑ended prompting, users aren’t restricted to predefined interactions. The user could ask for anything. In contrast to traditional programming, a prompt input field can’t be handled with a sprawling web of if/else logic trying to cover all possible use-cases. Attempting this will lead to a frustrating user experience where the user often gets an "I do not understand your request".

Some developers try to mimic this traditional programming pattern when crafting prompts and contexts for LLMs, telling an LLM "if the user asks for x, then answer y". Instead, as demonstrated below, tell the LLM what it can and cannot do and give it a goal to achieve. It's "smart" enough to figure out a suitable response to whatever the user will throw at it.

A fundamental choice

Looking at this specific feature in the specific environment, the implementation options on the table were (for a variety of reasons) these two:

Either just provide a system prompt (a prompt that is added behind the scenes in addition to what the user typed) without interfering with the specific prompts and replies entered during the conversation.
Or adopt a new way of creating an "agentic" multi-step execution plan. Similar to a guided activity, this would allow phases of data collection, possibly in different steps for different data, then an app creation step and so forth.

Surely "agentic" and "well-defined steps" sound good for app creation from a template, no? In fact, the initial implementation started like this, but it was soon apparent that this would neither provide the expected flexibility nor allow for a truly intelligent app creation experience. Defining phases in which to acquire specific information and having the application code created at a specific stage in this process did not feel right. The user would still feel like clicking through a traditional template creation process, as something specific was expected from the user at every stage, instead of giving the user the freedom to tweak every aspect at every stage. The true power of AI, on the other hand, would be totally underused.

But then again... just a system prompt and that's it? No file read access to explore the environment, no dynamically updated instructions? Is this enough for an intelligent coding assistant?

Creating an "AI agent" out of nothing

Consider the now common definition of an "AI agent" which has settled over the course of this year: it's nothing more than "an LLM with tools, called in a loop to achieve a goal". The chat conversation provided by Joule can be our loop, an application template with its parameters is the tool and the goal of assisting the developer to create an app can be stated in the system prompt. Of course a real autonomous agent would require the loop to run without user interaction, but for this feature a loop involving the user is just right.

The system prompt used for this feature literally includes: "You help users create new UI5 applications by analyzing their requirements and filling the project template parameters. [...] Your goal is to gather all necessary information to create a new UI5 application. The application will be generated from a template which has only one page and a hardcoded UI, but can optionally display data from an OData V4 service. [...] You cannot create the application yourself, but the user will see a preview...". There you have it: the goal and the tool!

It then goes on with some behavioral hints and of course a detailed description of what exactly the template parameters do. Finally, it requests each reply to contain a JSON object with the best choice of template parameters according to the current understanding of the user request. The JSON object could look like this example:

{

   "appNamespace": "com.myorg.myapp",

   "basePath": "/path/to/workspace",

   "createAppDirectory": true,

   "framework": "SAPUI5",

   "frameworkVersion": "1.136.0",

   "author": "John Doe",

   "oDataV4Url": "https://services.odata.org/TripPinRESTierService/(S(s5xrj1t51r41s3ooztsynysq))/",

   "oDataEntitySet": "Airports",

   "entityProperties": ["Name", "Address"],

   "runNpmInstall": true,

   "initializeGitRepository": true,

   "typescript": true

}

This JSON object is removed from the LLM response before displaying it, then the application is generated with these parameters, so the user can accept it or request changes. In an environment where tools with a well-defined interface like MCP servers are not enabled, this JSON object as part of the conversation is how the integration with the templating tool is achieved. It's basically a use-case-tailored alternative to MCP. A note to make this very clear: this environment is not the official SAP Joule assistant running inside end-user applications, as it is now also being enabled for development by customers. Instead, it is a sort of predecessor implementation specifically available in SAP Build Code since spring 2024 and about to be replaced by advanced solutions. So do not draw conclusions about SAP Joule based on this article.

Some of these parameters in the JSON object are more important than others with regards to the user explicitly influencing them or having to accept them. Whether the app code is generated as TypeScript or JavaScript is something the user should not be surprised with after accepting the app! On the other hand, the author name, which is only written into package.json, can be reliably defaulted to the logged-in user name and also very easily changed later on if needed. Hence, the parameter descriptions explain not only what they do, but also how much the user should be bothered with them. As result, Joule usually does not even mention half of the parameters, thus keeping the conversation focused.

How to stop the agent

Regarding the state after the app was accepted, the prompt explains "AFTER the user has generated the application, you **MUST NOT** continue discussing parameters for generation, but rather [...] in particular by referring the user to the '/ui5' command for most requests or '/ui5-create-page' for adding pages to the app, because they are much better than you in developing features, as they have the capability to automatically select a suitable context of files.".

This means the transition in the overall process between refining parameters and "no more changes possible" is not a hardcoded step or denoted by changing the system prompt, but rather explained up-front. That's enough. Can you talk Joule into proposing another set of parameters after the app was accepted? Maybe. But its normal behavior is just right: it will explain that the app can not be created again without restarting the conversation. Nevertheless, there are also non-AI guardrails in place to prevent the app from being generated again, thus causing trouble.

All in all, we shape Joule’s behavior by explaining the templating tool and its limits, by stating the goal and desired behavior towards this goal, and by explaining the general flow, in particular the state after app acceptance. This is enough to guide it to a suitable reaction for whatever the user requests.

Even if the user insists like this:

Context, context, context!

To make the entire feature really user-friendly, however, it is not sufficient to write a good prompt, but the context must also provide enough information to the LLM to allow for informed decisions. Hence, information like the list of project root files and folders, whether a Git repository is present, plus CAP service/entity/property info, and more, are gathered (e.g. using the @sap-ux/project-access package). This knowledge is provided as prompt context behind the scenes or used in another way (like as content of the suggested prompts). This makes Joule aware of the environment it acts in, leading to better responses, like automatically avoiding app names that would conflict with existing folder names.

Agentic coding assistants like Cline, GitHub Copilot, Cursor etc. usually have the ability to read files and execute shell commands as needed to understand their environment. In this pure user request + LLM response environment this might have been a bit harder to build. Basically, more tools could have been defined, e.g. by describing other JSON object structures for invoking them. But control would not so easily return to the LLM until after the user has entered another prompt. Or, there could have been one "preprocessor" LLM request asking for needed files, like it is done for the other /ui5* commands.

But for a narrow scenario like app creation this wasn't necessary. Collecting the most relevant information up front not only provides sufficient context, but also improves performance and reliability by avoiding repeated tool calls and unpredictable LLM loops.

In-response prompting

The real-world context, however, changes over time. Specifically, once the app is created and accepted, there are new additional files present.

When developing the UI5 MCP server, we observed that the agentic AI tool (e.g. Cline) using the MCP server often decided to inspect the new app directory tree after creation, causing several LLM roundtrips which cost time and tokens. Or it would run "npm install" again, even though it had already been executed. Or it would make specific coding errors very often in subsequent modifications.

To avoid this, we extended the response of the MCP server after creating the app. Normally, it contains just the success message. But now it includes a full list of generated files, it states that "npm install" was already executed and it instructs how to prevent those coding errors. Basically, the MCP server response added further updated instructions to the conversation context.

Exactly the same principle was applied in this new Joule feature. While there is no autonomous agent loop in this case which would inspect the new files, the knowledge which files were created can be valuable for the conversation with the user. And while the/ui5-create-app command doesn't modify any code after app creation (thus avoiding the coding issues), facts like whether "npm install" was already executed, or whether the created UI5 Table in the MainView is lacking any columns, are useful for giving the user hints how to continue. Therefore, the context is extended by adding a hidden message to the conversation history.

Traditional coding has its place(s)

In addition to the process of context collection, deterministic coding is also used after the app has been accepted by the user for making the app consumption as smooth as possible. When inside a CAP project, it for example ensures that the cds-plugin-ui5 is added as dependency. This allows the UI5 tooling, including TypeScript transpilation of the UI5 app when needed, to run as part of the "cds watch" or "npm start" script of the CAP project itself.

Also, this dependency and all the UI5 app dependencies need to be installed. Unfortunately, there is a wide range of options and specific setups which might be used for dependency management in the already existing app. Probably npm? With or without workspaces? yarn? pnpm? Others? The code detects what is used and tries to cover the 95% case. The initial setup might not be complete in every scenario, but for most users it will “just work,” providing a good developer experience.

AI is fine and all, but sometimes one has to go the extra mile and do some coding.

Key takeaways

Use deterministic code where reasonable (because the space of possibilities is bounded and a deterministic and quick result is beneficial) .
Use LLMs for language understanding or dealing with an unpredictable range of possible requests.
Don't try to "program" the LLM with an if/else prompt, but treat it like an intelligent human: state the goal, options and boundaries—and let it decide on its own.
Provide solid pre-collected context so the LLM can make good decisions reliably.

P.S.:

For those who prefer graphics over text to gain an understanding of something, here is a depiction of the overall information flow inside this feature.

Quickly Deploy a Sample CAP Application to BTP

2025-11-15T08:50:59.556000+01:00

Prerequisites

Before you deploy your sample SAP Cloud Application Programming Model (CAP) app to SAP Business Technology Platform (BTP), ensure you have the following in place:

BTP Account (Trial or Paid)
You’ll need a BTP global account with a sub-account in the Cloud Foundry environment.
- You can register for a free trial at the SAP website. BTP Trial
Development Environment: SAP Business Application Studio or VS Code alternative + CLI tools & MBT
- If using Business Application Studio, follow SAP’s onboarding tutorial: “Set Up SAP Business Application Studio for Development”. Setup Business Application Studio
- Otherwise you may use VS Code (or another IDE) with the following command-line tools:
  - Cloud Foundry CLI (cf CLI) – Install instructions here: CF CLI
  - Cloud MTA Build Tool (mbt) – Install and usage information here: MBT
- Make sure you’ve configured your CLI to target your BTP subaccount/space (cf api, cf login, cf target). CLI API & Login
HANA DB Instance (or Trial) for your DB
Your CAP app will typically require a database backend.
- Get started with the HANA Cloud trial using this tutorial: HANA Trial

After completing all the prerequisites we can start build the application

Start a Terminal in you IDE of choice

generate the project

cds init bookshop --add sample

Add hana, mta, xsuaa and workzone

cds add hana,mta,xsuaa,workzone --for production

run npm install in all the applications, the sample bookshop has 2 Fiori Elements applications that we'll need to run npm i in their folder as well as in the project folder

cd app/admin-books
npm i
cd ../browse
npm i
cd ../..
npm i

now we can build the project

mbt build

if all goes well then we'll get an mtar file inside the mta_archive folder

before deploying we'll need to make sure that we're logged into cloud foundry

cf login

now we deploy

cf deploy mta_archives/*.mtar

and that is it you should now have a CAP service and 2 fiori elements applications deployed on BTP.

You can then create an instance of Work Zone and surface the application through it or build applications that use the cap application as its backend (This is what I intend to do in upcoming blogs)

The Art and Science of SAPUI5 in SAP Build: Insights from SAP TechEd 2025

2025-11-17T05:35:29.369000+01:00

At SAP TechEd Berlin 2025, we had the opportunity to present “The Art and Science of SAPUI5 in SAP Build.” The deep dive session explores how SAPUI5, SAP’s strategic UI framework, is transforming user experiences and developer efficiency across SAP. This blog post shares key takeaways from the session and questions from the audience.
If you’ve missed it, watch the session recording in AD106v | The art and science of SAPUI5 in SAP Build.

The Art of SAPUI5 in SAP Fiori User Experience

SAP’s approach to user experience (UX) centers on making applications easier and more enjoyable to use, helping users accomplish their tasks with greater efficiency and satisfaction. The framework enables the SAP Fiori design system to evolve seamlessly across SAP solutions, providing flexible tools for developers to efficiently build apps using SAP Build Code.

SAP Web Components: Bridging Frameworks and Enhancing Extensibility

SAP Web Components extend the capabilities of SAPUI5, to other programming model, such as Angular, React, or Vue. This interoperability supports a consistent and streamlined UX throughout the SAP portfolio. SAP Web Components can now also be easily consumed in SAPUI5 apps just like regular controls. Going forward, SAP plans to provide new UI elements as SAP Web Components, minimizing the effort required for adopting new standards and ensuring compliance with SAP guidelines and modern Web standards.

SAPUI5 is leading is the Way in Accessibility

SAPUI5 is at the forefront of accessibility, with recent implementations (SAPUI5 1.136 and UI5 Web Components 2.9.0) aligned to the latest Web Content Accessibility Guidelines (WCAG) 2.2. This commitment ensures that applications built with SAPUI5 are inclusive and accessible to users worldwide, meeting diverse needs and regulatory requirements.

The Science of SAPUI5 in SAP Build

SAP Build is SAP’s unified solution to build apps and extensions, automations, agents and digital workspaces. SAP Build helps to increase developer productivity and to future-proof IT investments by leveraging proven technologies like SAPUI5, SAP Fiori elements, CAP and ABAP Cloud.

Extending SAP standard apps with SAPUI5 flexibility and Clean Core

SAPUI5 flexibility enables upgrade-safe, clean core extensions with intuitive low-code/no-code tools for different personas: end users, key users, and developers. New capabilities include consistent text changes for field labels and a “What's New” / “UI Adaptation Tour” for key users. Developers creating adaptation projects benefit from a "Replace original tile option and coding efficiency with TypeScript and Joule.

The new SAPUI5 runtime repository accelerates patch updates, improves startup performance, and supports zero-downtime deployments.

Future-Proofing apps with UI5 best practices and UI5 linter

Technical debt and legacy code can slow down innovation within SAP Fiori projects. Here the UI5 linter helps finding and fixing the usage of deprecated APIs and making your code is ready for upcoming SAPUI5 versions. The new SAPUI5 / OpenUI5 legacy-free version helps validating how compliant your code is to UI5 best practices, i.e. ensuring your code is state of the art and future-proof.

AI-Powered Development: Joule Copilot and MCP server

AI is revolutionizing SAPUI5 development. The Joule copilot accelerates app creation, view and control addition, code formatting, migration to TypeScript and much more. The UI5 MCP server enables agentic AI app development in SAP Build, combining generative AI with algorithmic logic if the UI5 linter.

Key Takeaways

SAPUI5 delivers a streamlined, consistent UX across SAP Business Suite, driving both user satisfaction and business outcomes.
SAP Build and SAPUI5 flexibility empower organizations to extend SAP standard apps efficiently, future-proofing their investments.
AI-powered tools accelerate development and let you future-proof your apps with UI5 best practices.

Selected questions from the audience

Q: Is Using VS code still recommended or the SAP Build for development

A: In addition to the turnkey solution of SAP Build running on SAP BTP, SAP plans to focus on releasing development tools on the VS Code marketplace. VS Code is the number-one IDE worldwide, especially among web, cloud, and full-stack developers. Investing more in VS Code helps SAP meet developers where they are, making it easier for new developers to adopt SAP technologies (such as CAP, SAP BTP, SAPUI5, ABAP Cloud).

Q: New controls will be components from now on?

A: Exactly, SAP plans to deliver most new UI components as Web Components, which can be use across any Web framework, including SAPUI5.

Q: How AI compatibilities work in more complex application

A: Beyond Generative AI capabilities, agentic development tool (e.g. with the UI5 MCP server) offer impressive results for developing complex (fullstack) apps, from design up to deployment. You might want to check out Inside Joule: Lessons from building an AI coding assistant for SAP Build for an inside view.

Q: What is the benefit of using the Web Components from the example compared to sap.m.Input?

A: Please continue using SAPUI5 controls if they fulfil your needs. There is no change to that. Most upcoming, new UI elements will be provided as Web Component, serving *all* technology stacks, including SAPUI5.

Q: What are Components bringing when compared to Classic controls if we are using UI5 only approach

A: see above

Q: how will be the future scope of Fiori elements applications over ui5, do both will have same scope

A: SAP Fiori elements is an option to develop SAPUI5 app more efficiently. SAP recommends using as much SAP Fiori elements as possible and as much freestyle SAPUI5 as needed. This is what we do in SAP as well. Check out the SAP Fiori Development Portal on more details.

Q: What would be best approach to extend freestyle standard Fiori apps? Also, will adaptation projects have more extension powers?

A: SAPUI5 flexibility to the strategic way to extend/adapt SAPUI5 apps. The UI5 team continues to invest a lot in this area, as it is top priority for many partners/customers. SAPUI5 flexibility covers freestyle SAPUI5 as well as apps built with SAP Fiori elements. Adaptation projects offer best capabilities to create future-proof app extensions.

Q: Will the Build Code Joule CoPilot also support the Vibe Coding with MCP in the future?

A: Yes, SAP plans for vibe coding tools (incl. MCP servers) in SAP Build to empower business users to create application prototypes and start new SAP solutions without heavy coding knowledge.

Q: SAP develops SAPUI5 while promoting low-code tools like RAP, CAP, and key user adaptations. Isn’t it inconsistent to advance the core framework while encouraging less direct UI5 development?

A: Key user adaptation as well as metadata- / annotation-driven apps on RAP/CAP (using SAP Fiori elements) all use SAPUI5 as their UI technology. Innovations ‘in the UI’ are built in SAPUI5, benefitting all these models. Also, there remains a strong use case for a freestyle SAPUI5 implementation approach for apps which cannot follow the patterns of SAP Fiori elements.

Q: As a partner, if we build an SAPUI5 application and deploy it to customer systems, can SAPUI5 flexibility be used to create customer specific adaption projects for it?

A: This is planned for Q4/2025: Developer adaptation: enabling customer and partner applications for adaptation projects (As always with forward-looking statements, this is subject to change.)

Q: The build errors just prove you are really building live and not faking it. 🙂

A: Right. Not sure though whether Tommy enjoyed the moment 😉

Q: Now that CDS support UI annotations will UI5 become obsolete?

A: Definitely not. SAPUI5 remains SAP’s strategic UI framework. SAP Fiori elements with its annotations is built on SAPUI5. The annotations control what SAPUI5 is showing.

Create a CAP Application with SAP HANA Cloud from Scratch and Deploy to Cloud Foundry in SAP BTP

2025-11-19T12:24:37.057000+01:00

Create a CAP Application with SAP HANA Cloud from Scratch and Deploy to Cloud Foundry

This guide walks you through the complete lifecycle of building a CAP (Cloud Application Programming) application, connecting it to SAP HANA Cloud, and deploying it to SAP BTP Cloud Foundry.

1.Create SAP BTP Trial Account

You need a trial account to access Cloud Foundry, SAP HANA Cloud, and all BAS development tools.

2. Subscribe to SAP Business Application Studio (BAS)

If not subscribed:

Go to SAP BTP Cockpit → Instances and Subscriptions
Subscribe to Business Application Studio

3. Create CAP Project Skeleton (Using Template Wizard)

Open BAS and press:

Ctrl + Shift + P → Template Wizard

Then follow these steps:

3.1 Select Template

Select: CAP Project Generator
Click Next

3.2 Provide Project Details

Project Name → Any name of your choice
Choose Database → SQLite (default)
Choose Deployment Target → Cloud Foundry

Note:
Do not select SAP HANA Cloud here.
We first deploy the application with SQLite, then add HANA later from terminal.

3.3 Choose Runtime Capabilities

Select these productive services:

XSUAA
SAP BTP Connectivity Service
SAP BTP Destination Service
SAP BTP Application Router

Click Finish.

This creates the complete folder structure including:

/db
/srv
/app
mta.yaml
Security and deployment artifacts

4. Modify MTA Configuration

Cloud Foundry sometimes fails when resource names contain dynamic interpolation (org/space).

Removing them ensures deployment simplicity.

Open mta.yaml and remove:

-${org}-${space}

from all resource names.

5. Create a Sample CAP Model

5.1 Define Database Schema

Open /db/schema.cds:

5.2 Create Service Definition

Open /srv/service.cds:

Now, you have a simple end-to-end data + service model to validate local and cloud deployment.

6. Test the CAP Application Locally

cds w

Now, CAP runs using SQLite, allowing quick testing without any external services.

7. Deploy the CAP Application (SQLite Mode)

Right-click mta.yaml → Build MTA Project

Or use:

mbt build

2. Login to Cloud Foundry
Ctrl + Shift + P → CF Login

3. Deploy the generated .mtar

Right-click .mtar → Deploy MTA Archive
Or use:
cf deploy yourfile.mtar

Your CAP app runs in Cloud Foundry with SQLite.

Next, we will connect it to real SAP HANA Cloud

8. Create SAP HANA Cloud Instance

Go to:

SAP BTP Cockpit → Instances & Subscriptions → Create

Choose:

Service: SAP HANA Cloud
Plan: hana
Environment: Cloud Foundry
Instance Name: hanaDB

Set the DB administrator password → required for Data Explorer.

And press on Create instance.

It will take estimated 10-15min

It creates the actual HANA database where CAP HDI containers will be deployed.

9. Subscribe to SAP HANA Cloud Tools

Without this subscription, you cannot access the DB instance UI.

Go to:
Instances & Subscriptions → Subscribe → SAP HANA Cloud Tools

Assign Roles

Under Users, assign all required HANA Cloud roles.

Sign out → Sign in again.

10. Open SAP HANA Data Explorer

Click the HANA instance → Open SAP HANA Database Explorer

First login:

Username: DBADMIN (or the username shown under "Administrator")
Password: the one you entered during instance creation

If you forgot your DB username

Open:
SAP HANA Cloud Administration → Overview
Your administrator username will be displayed there.

Now, You have direct access to schemas, HDI containers, and database objects.

11. Open HDI Container Section in SAP HANA Database Explorer

Inside SAP HANA Database Explorer:

Click the “+” icon
Choose Cloud Foundry
Log in to your CF environment

From the list → choose Instance Type: HDI Container

At this stage, your CAP HDI container will NOT appear yet, because we have not created it.

12. Add HANA Support to CAP Application

Run the following commands in BAS terminal:

cds add hana
npm i

What these commands do

cds add hana

Generates HANA-specific configuration
Creates HDI deployment artifacts
Prepares the project to run on SAP HANA instead of SQLite

npm i

Installs additional dependencies required for HANA runtime

Now, your project is ready to connect and deploy models to an HDI container.

13. Update package.json for HANA Deployment

Open package.json → under "cds.requires" add:

"db": {
  "kind": "hana"
}

This tells CAP to use SAP HANA as the primary database in production.

14. Bind the CAP Project to Your HANA Instance

In BAS → Cloud Foundry view:

Select your CAP app
Choose Bind to Service
Pick your HANA DB instance hanaDB

This automatically creates a .env file containing:

HDI container name
Credentials
Database URLs
Service keys

Why we are doing this

CAP needs this information to connect to SAP HANA for:

Local “cds watch”
Production deployment

Your project is now fully connected to SAP HANA Cloud.

15. Build Your CAP Project for Production

Run:

cds build –production

HANA Cloud can now deploy your database schema properly.

16. Deploy to SAP HANA Cloud

Run:

cds deploy --production

This:

Creates HDI container
Deploys CDS schema into HANA tables
Activates views, indexes, constraints

Your CAP application now uses SAP HANA Cloud as its primary DB.

17. Rebuild and Deploy the Entire CAP Application

Again perform:

mbt build

Then deploy:

cf deploy <yourfile>.mtar

Our complete application (service + database) is deployed on Cloud Foundry using HANA.

18. Verify Schema Deployment in SAP HANA Cloud

Open SAP HANA Data Explorer
Click +
Select Instance Type = HDI
Choose your CAP application HDI container

5. Expand Tables and Views

You can verify that:

Tables are created
Data model is deployed correctly

19. Running CAP Application Locally Using HANA Cloud

If you want to run locally via HANA:

Ensure .env exists
Rebind HDI container if needed

Run:

cds w

Successful connection check

If logs show:

Connected to SAP HANA Cloud (hanaDB) . Then your HDI container is successfully connected.

20. Validate Deployment Using Postman

This confirms:

Service is running
HANA DB is connected
Deployment is successful end-to-end

Conclusion

In this blog, we have completed the following activities:

Created a new CAP application using the BAS template wizard.
Performed an initial deployment using SQLite to verify application behavior.
Provisioned a SAP HANA Cloud instance and assigned all required role collections.
Enabled HANA support in the CAP project and generated HDI-related artifacts.
Bound the project to the HANA instance to establish secure database connectivity.
Built CDS artifacts for production and deployed them into the HDI container.
Rebuilt and deployed the full MTA application to SAP BTP Cloud Foundry using HANA as the primary database.
Verified successful deployment through SAP HANA Database Explorer and API testing.

Don't Wait for SAP: Unlocking MCP Servers in BAS Right Now

2025-11-27T21:09:21+01:00

The Model Context Protocol (MCP) is currently one of the hottest topics in development, promising to accelerate workflows, especially in the SAP ecosystem. Many IDEs already support MCP servers, offering developers enhanced context and capabilities.

Unfortunately, in SAP Business Application Studio (a.k.a. SAP Build Code), you are currently limited to Joule. This is particularly frustrating given that MCP servers were heavily promoted at SAP TechEd, yet the native environment doesn't fully support them yet. This limitation is especially challenging if you are restricted to using BAS because local development with tools like VS Code is not allowed or possible in your corporate environment

In this blog post, I want to show you how to not only use MCP servers directly within BAS but also explore ways to develop with BAS from the "outside" using hybrid approaches.

What are MCP Servers?

MCP servers provide the LLM client (like Claude, Cursor, or Copilot) with more context about your project and system, helping the developer work more effectively. Fortunately, there are already numerous MCP servers available for SAP.

You can learn more about the available SAP MCP servers in this blog post: SAP Build introduces new MCP Servers to enable age... - SAP Community

What Can You Do Directly in BAS?

SAP Business Application Studio is based on the Open VS Code stack (Code-OSS), which allows us to install extensions from the Open VSX Registry. Even if an extension isn't available there, you can often install the VSIX file directly. Since BAS runs in a small virtual machine, we also have the ability to install CLI tools.

Cline Extension

The first option is using the open-source extension Cline. This is also explained in the SAP Architecture Center on how to use Cline with SAP AI Core and in a TechEd Hands-on Exercise.

This extension gives you a coding agent directly within BAS that can not only answer questions but also modify code. Crucially, Cline supports MCP servers. You can install it easily via the Extensions Marketplace in BAS:

Once the SAP MCP servers are installed globally (e.g., via npm install -g sap-ux/fiori-mcp-server), we can configure them in Cline. Below is my configuration example. The command points to the local node installation. You can find the exact path using the command node -p "process.execPath". To find the location of the MCP server, you can run:

echo "$(npm root -g)/@sap-ux/fiori-mcp-server"

This configuration is saved in the cline_mcp_settings.json file, which you can access via "Configure MCP Server" in Cline's settings.

Here is my MCP config file:

{
  "mcpServers": {
    "ui5-mcp": {
      "disabled": false,
      "timeout": 60,
      "type": "stdio",
      "command": "/home/user/.asdf-inst/installs/nodejs/22.13.1/bin/node",
      "args": [
        "/home/user/.node_modules_global/lib/node_modules/@ui5/mcp-server/bin/ui5mcp.js"
      ]
    },
    "fiori-mcp": {
      "disabled": false,
      "timeout": 60,
      "type": "stdio",
      "command": "/home/user/.asdf-inst/installs/nodejs/22.13.1/bin/node",
      "args": [
        "/home/user/.node_modules_global/lib/node_modules/@sap-ux/fiori-mcp-server/dist/index.js"
      ],
      "autoApprove": [
        "execute_functionality"
      ]
    },
    "cap-mcp": {
      "disabled": false,
      "timeout": 60,
      "type": "stdio",
      "command": "/home/user/.asdf-inst/installs/nodejs/22.13.1/bin/node",
      "args": [
        "/home/user/.node_modules_global/lib/node_modules/@cap-js/mcp-server/index.js"
      ]
    }
  }
}

Cline allows you to flexibly use different models, including OpenAI, Anthropic, and SAP AI Core.

In this example, I want to disable the "Initial Load" of a Fiori Elements app. The Fiori Tools MCP Server supports this functionality. Even without explicitly telling the LLM client to use the MCP server, it automatically calls the appropriate tool to perform the action.

This is a great option to get started quickly and use various models and providers. However, in my experience, it can be quite slow compared to other LLM clients, and the overall experience is somewhat limited by being "just" an extension.

Claude Code

Many model providers and LLM clients now offer CLI alternatives. Two notable examples are Claude Code, Cursor CLI, or Gemini CLI. We can install these directly in BAS.

I'll use Claude Code as an example. The installation is straightforward:

curl -fsSL https://claude.ai/install.sh | bash

After installation, you need to authenticate. Once done, you can configure MCP servers. You can activate the tool simply by running claude. Once configured, you can use these MCP servers directly within your BAS terminal.

The configuration can be identical to the one used in Cline:

Here is an example using Claude Code to reactivate the Initial Load. Claude correctly utilizes the Fiori MCP Server to find the right tool and execute the change.

Outside of BAS (Hybrid/Remote)

Fortunately, we have the possibility to "break out" of the browser-based BAS and use a hybrid approach with a local IDE. SAP provides a way to do this via extensions. The documentation for this setup can be found here: Working Remotely with SAP Business Application Studio</a >.

VS Code and GitHub Copilot Chat

This approach enables us to connect a local VS Code instance via SSH to our running BAS instance.

This gives us the best of both worlds: all BAS-exclusive extensions and capabilities, plus everything VS Code offers, including GitHub Copilot Chat and MCP servers.

If you follow the documentation, you will have GitHub Copilot available in your local VS Code, capable of using the integrated MCP servers and the model of your choice. This provides not only direct code editing capabilities but also very smart autocompletion.

Here is an example with GitHub Copilot Chat and MCP Server. In this case, although I explicitly mentioned the MCP server, it seems the tools were not automatically recognized, so the model used the parameter in the manifest.json directly.

Cursor

Cursor is a very powerful tool with excellent integration of MCP servers. You can configure and use MCP servers directly in Cursor and use with any model together with BAS.

In theory, any Code-OSS based IDE that supports the necessary extensions can establish this connection. For those not bound to BAS, MCP servers can be configured and used directly in your own IDE, as almost every major IDE supports MCP servers by now.

Conclusion

While SAP Business Application Studio currently has some limitations regarding native MCP integration, there are several powerful workarounds.

It will be exciting to see what support will be available in BAS in the future.
Will it be Cline, as shown in the TechEd demos, will Joule be upgraded, or will GitHub Copilot be included in BAS as announced in a TechEd session?
After the announcement at the TechEd keynote, I had actually expected a quick solution.

Fortunately, I am not currently tied to BAS, and even if I were, I could fall back on the workarounds.

Bridging Data Quality Gaps in SAP SuccessFactors TIH with CSVValidationApp and Vibe Coding

2025-12-03T16:06:10.964000+01:00

Introduction

Data quality challenges in SAP SuccessFactors Talent Intelligence Hub (TIH) often go unnoticed until they impact user experience. When thousands of attributes are imported without proper validation, issues like HTML tags, broken formatting, and unescaped characters can disrupt Growth Portfolios and compromise analytics/employee experience. This blog introduces CSVValidationApp, a solution designed to bridge this gap using functional expertise and modern development practices like Vibe Coding—and opens the door for community collaboration on similar innovations.

Why This Matters

SAP Talent Intelligence Hub is a strategic enabler for skills-based workforce planning. It helps organizations create dynamic career paths, leverage AI-driven skill recommendations, and empower employees through Growth Portfolios. These capabilities unlock smarter talent decisions and a more agile workforce.

To fully realize these benefits, data integrity during imports is critical. According to SAP Help Portal, importing entities like attributes, tags, and behaviors into TIH requires strict adherence to structure and format. Common issues include:

Incorrect headers or missing mandatory fields in CSV files
Improper encoding (non-UTF-8) causing character display errors
Unescaped quotes or HTML tags in descriptions, which can truncate or break content
Large file sizes impacting performance (recommended limit: 25,000 records per file)
Incorrect date formats for proficiencyAssignedDate when updating Growth Portfolio attributes

These challenges can lead to incomplete or inaccurate data in the Attributes Library and Growth Portfolio, affecting AI-driven recommendations and user experience. Adding a validation step before import ensures clean, consistent data—reducing manual troubleshooting and enabling HR teams to focus on strategic initiatives.

My Perspective and Approach

Having worked extensively across implementations, integrations, and functional solution design in SuccessFactors, I’ve seen how small data issues can create big challenges downstream. This experience shaped my approach: build a tool that doesn’t just validate data but actively improves it before it enters TIH.

I chose Vibe Coding as the development approach because it accelerates delivery through real-time collaboration, instant previews, and iterative design—all within SAP Business Application Studio. This allowed me to focus on business logic and user experience rather than boilerplate coding, ensuring the solution was delivered quickly without compromising quality.

How CSVValidationApp Fits into the TIH Workflow

CSVValidationApp acts as a data quality gatekeeper in the integration process. In the following example workflow after data is exported from Integration Center, the file passes through CSVValidationApp for cleansing and validation. Once clean, the data is transformed and mapped to TIH-compatible attributes before being imported back into the system.

This workflow ensures that what enters TIH is not just valid but optimized for rendering and usability. The result? A clean, enriched skills library that supports AI-driven recommendations and future enhancements.

What Makes CSVValidationApp Powerful

CSVValidationApp performs comprehensive checks tailored for SuccessFactors Integration Center requirements. It detects encoding issues, validates structure, identifies problematic characters, and removes HTML tags and entities. Beyond validation, it offers auto-correction, generating clean content with proper quoting and escaping. A preview feature and detailed statistics give administrators confidence before import.

By automating these steps, CSVValidationApp transforms a tedious, error-prone process into a seamless experience—empowering HR teams to focus on strategic tasks rather than data cleanup.

Looking Ahead: Unlocking the Full Potential of TIH

SAP Talent Intelligence Hub is continuously evolving to help organizations stay ahead in a skills-based economy. Upcoming innovations include AI-driven skill inference, integration with external taxonomies, expanded APIs, and advanced analytics for workforce agility. These capabilities will empower HR teams to make smarter decisions and deliver personalized employee experiences.

Clean, validated data is the foundation for these advancements. By ensuring data integrity from the start, organizations can confidently leverage AI recommendations, predictive insights, and future integrations without disruption.

CSVValidationApp supports this vision by acting as a proactive data quality gatekeeper. Future enhancements will include AI-powered attribute correction suggestions, direct SAP API integration for one-click imports, and support for additional modules like Learning and Recruiting—making the process even more seamless and intelligent.

Getting Started

CSVValidationApp is built as an SAP Fiori application using SAP Business Application Studio. To run it locally, simply clone the ***REMOVED BY MODERATION***, install dependencies, and start the app.

Here is an example screen shot from the application. The Attribute text file I validate below had many data rows with competency description such as:
"1000009","de_DE","BUSINESS & TRANSFORMATION..","Sie planen Ihre Vorhaben, definieren herausfordernde Ziele und entscheiden mutig.Herausforderungen im &bdquo;VUCA“-Umfeld (Volatilität – Unsicherheit – Komplexität – Ambiguität) begegnen Sie aktiv und entwickeln eine klare Vision für Ihren Verantwortungsbereich.<a href= xyzurl target=_blank>Kriterien und Verhaltensanker</a> anzeigen.","COMPETENCY"

This description gets corrected to:

"1000009","de_DE","BUSINESS & TRANSFORMATION..","Sie planen Ihre Vorhaben, definieren herausfordernde Ziele und entscheiden mutig. Bei der Umsetzung agieren Sie lösungsorientiert, bewerten Ergebnisse und Prozesse und nehmen notwendige Anpassungen vor. Herausforderungen im „VUCA\"-Umfeld (Volatilität - Unsicherheit - Komplexität - Ambiguität) begegnen Sie aktiv und entwickeln eine klare Vision für Ihren Verantwortungsbereich. ","COMPETENCY"

Final Thoughts & Community Ask

Data quality may seem like a technical detail, but in reality, it’s a strategic enabler. By combining functional expertise with modern development practices, CSVValidationApp delivers a solution that not only solves today’s challenges but positions organizations for tomorrow’s opportunities.

I’d love to hear from the SAP Community:

Have you built similar tools using Vibe Coding or other rapid development approaches?
What other gaps do you see in data validation for SuccessFactors integrations, and how can we bridge them together?

Share your thoughts, examples, and ideas in the comments. Let’s collaborate to make data quality a strength, not a challenge.

SAP Business Application Studio: Get started with Hands-on & Expert Guided Videos

2025-12-11T14:55:01.257000+01:00

Starting something new can sometimes feel intimidating, yet exciting, a little uncertain, but full of possibility. That’s exactly why we created our Sandbox System for Business Application Studio: a safe, playful space where beginners can explore freely and get a first feel for what SAP Business Application Studio is all about.

How to?

Accessible with a valid SAP Learning Hub subscription, you can access the SAP Business Application Studio Sandbox on the Learning Site.

What Makes This Sandbox Perfect for Beginners?

A Zero-Risk Environment

No breaking things. No messing anything up.

Everything in the sandbox is designed to be reset, replayed, and retried. It’s learning freedom at its best.

Get started in a Minute with our Expert Guided Videos

Instead of reading long explanations or memorizing theory, you jump straight into our easy-to-consume Expert-Guided Videos!

You get to do hands-on on SAP Business Application Studio, not just read about it.

Why This Matters

Getting started with a new topic shouldn’t be stressful—it should feel like an invitation.

Our sandbox lets you:

build confidence,
get a true feel for the topic,
and decide if you want to dive deeper

SAP Learning Services Topic Page
Ask questions about Training and follow
Read other Training blog posts and follow

Happy Learning!

Prompt-Driven Development: Building Full-Stack SAP CAP Apps from User Stories

2025-12-11T15:10:42.876000+01:00

Introduction

What if you could translate a business requirement into a functional, full-stack application with a single prompt?
How much faster could you deliver value if the foundational code and project scaffolding were generated for you in seconds?

This is the new reality powered by SAP Build Code and its integrated AI copilot, Joule.

As a turn-key environment on the SAP Business Technology Platform, it unifies the entire development lifecycle, from coding to deployment.

This post demonstrates how to build a full-stack SAP CAP application directly from a user story, showcasing how

generative AI is fundamentally reshaping the developer experience.

Business Requirement

Build an SAP CAP application based on the requirements in the user story below:

User Story

As a contract administrator, I want to create and manage contracts and ‘parties involved’ information in the system,

so that I can effectively track and handle legal agreements and ‘parties involved’ interactions.

Contracts can cover a vast range of agreements, such as sales contracts, service agreements and employment contracts.

Party involved: A ‘party involved’ is an individual, organization, or entity that purchases goods, products, or services from another party,

typically a business or seller.

Common attributes of a contract might include:

Contract ID: A unique identifier for the contract.
Party involved Identification Number: A unique identification number for the party involved.
Contract Type: The type of contract (e.g. sales, service, employment).
Start Date: The date on which the contract becomes valid.
End Date: The date on which the contract expires (if applicable).
Status: The current status of the contract (draft, active, expired, terminated, etc.)

A typical ‘party involved’ has the following attributes:

Party involved Identification Number
Party involved Name: It refers to the given name of a person or entity, or a label by which they are addressed or identified.
Party involved Address: It refers to a physical location where an individual, business, or entity is situated or can be reached.
Party involved Contact Information

Acceptance Criteria

Scenario 1: List All Contracts

Given I am logged into the contract management system, when I launch the SAP Fiori application to maintain contracts,

then I should be able to view the list of all the contracts in a list without pressing the GO button.

The list of all the contracts should have : Contract ID, Party involved Identification Number, Contract Type and Start Date.

The list of filters should include Contract Type, Contract Status and Start Date.

Scenario 2: View Contract Details

Given I am logged into the contract management system, when I select a specific contract from the list of SAP Fiori application,

then I should be able to view the contract details and parties involved information.

Joule's Generative AI-based SAP CAP App Development

Prerequisites

1. Create a New Project using SAP Build Lobby

Create a Project

Click the Application Tile

Full-Stack

Full-Stack Node.JS

Contract Management

Project Created

2. Build a Full-Stack CAP Application via Prompt

Click the created project to open it in SAP Business Application Studio

Open Joule From the Activity Bar and select the ’/cap-gen-app` slash command

Generate a CAP Application

Prompt the user story description(refer to Business Requirement section above) to Joule and click send.

Joule tackles complex tasks by breaking them into steps, each with a suggested prompt.

Diffrerent Steps

To simplify the process and provide full context, replace the content of each step with the complete user story prompt.

Then, save and run to generate each step's artifacts.

Accept the Code.

Accept the Code

Generated Artifacts

3. Add UI to the Application

Create a new Fiori elements Application.

Fiori Elements Application

3. Preview the Application

Click run to preview the Application.

Run the Application

The application’s preview is displayed.

Application Preview

Launch the contract management app.

Contract Management

Select a contract from the list to view its details.

Select Contract

Contract details

Conclusion

The journey from user story to a functional, full-stack application—once a multi-day endeavor—is now accomplished in minutes.

With SAP Build Code and its AI copilot, Joule, this dramatic acceleration signals a fundamental paradigm shift.

The developer's role is being elevated from the meticulous craft of writing code to the strategic art of guiding its creation.

Joule operates as the quintessential collaborator, executing the foundational groundwork to liberate developers to focus

on high-value business logic and innovation.

SAP Build Code is therefore more than a tool; it's the dawn of an era where the speed of technology finally

matches the ambition of business.

Further Information

SAP Build Code

#SAPBuildCode #Joule #SAPBTP

______________________________________________________________________________________________

Best Regards,
Anuradha Dhingan

SAP Fiori tools 2601 update – Mobile Device Preview, Building Blocks, and AI-Driven Productivity

2025-12-17T17:29:22.331000+01:00

With the latest SAP Fiori tools update 2601, we continue our focus on improving developer productivity, openness, and real-world usability. This release brings meaningful enhancements across previewing applications, managing system connections, building SAP Fiori elements–based UIs, and accelerating development with AI-powered tooling. At the same time, we’ve continued to refine the fundamentals in security, modelling, and extensibility.

Preview SAP Fiori Apps on Real Mobile Devices

When developing SAP Fiori applications, simulating a mobile experience in a desktop browser often isn’t enough to fully validate real-world behavior. Touch interactions, performance characteristics, and device-specific rendering can differ noticeably on physical phones and tablets.

To address this, SAP Fiori tools now supports previewing applications directly on real mobile devices when using @sap/ux-ui5-tooling version 1.19.1 or higher. By creating a new run configuration and enabling Remote Access, developers can expose the local preview. When the run configuration is started, the terminal provides connection details, including a URL and a QR code, which can be opened directly on a phone or tablet to access the running app.

This makes it significantly easier to validate layouts, navigation, and interactions exactly as end users will experience them without leaving the development environment.

Showcase for previewing a SAP Fiori elements app on iPhone

A New Connection Manager for SAP Systems in VS Code

Managing connections to remote SAP systems is a foundational task when working with SAP Fiori tools. With this release, we introduce the Connection Manager for SAP Systems as a dedicated Visual Studio Code extension. This new extension succeeds the previously integrated saved systems panel from the Application Modeler and provides a focused, extensible solution for handling system connections in Visual Studio Code.

The Connection Manager allows developers to create, store, test, and edit connection information that can be reused by the SAP Fiori generator as well as by preview features in SAP Fiori tools. Storing passwords is optional, and if stored, they are protected by the security policies of your operating system's credential manager.

By making this capability standalone and open source, it is now accessible to other extensions such as the Service Catalog extension, and open for community contributions.

Connection Manager

Expanded Support for SAP Fiori Elements Building Blocks

SAP Fiori tools continues to enhance the support for the building blocks which shape the framework of SAP Fiori elements for OData V4 and its flexibility you can use. It makes it easier to create and adapt applications using a structured, metadata-driven approach while keeping flexibility in design. In this update, the Page Editor gains additional capabilities that improve developer convenience when working with custom pages and sections.

Developers can now add more building block types to their apps with the Page Editor, including rich text editors within custom sections, custom columns for table building blocks, and the page building block itself. Managing custom pages is also more intuitive, as building blocks can now be deleted directly from the editor. To support experimentation and iteration, undo and redo actions are now available when working on custom pages.

Together, these enhancements reduce friction when adapting applications and allow developers to work more confidently and efficiently with SAP Fiori elements–based UIs.

Rich Text Editor building block support in Page Editor

Enhancements Across the AI-Toolchain

AI capabilities continue to evolve across SAP Fiori tools, with a strong focus on usability and enabling deeper end-to-end changes from within the tooling.

The Project Accelerator can now be launched directly from the SAP Fiori generator, streamlining the initial project creation flow. The previously required staging step has been removed, allowing new projects to be created directly in the selected workspace folder. For projects created using the Project Accelerator, the Application Modeler now offers advanced editing capabilities, such as creating new fields and properties end-to-end, updating the data model, exposing the service, and consuming the changes in the UI in one coherent flow.

AI support has also been extended to mock data generation. Developers can generate realistic mock data using AI directly in the Application Modeler, and this capability is available for all applications whenever the Project Accelerator is enabled.

In parallel, the MCP server for SAP Fiori continues to expand. The server now exposes @sap-ux/create commands as CLI functionality, enabling reliable execution in MCP-supported workflows. App generation has been extended to support CAP Java projects, and a new “search_docs” tool allows the LLM (Large Language Model) to query SAP Fiori elements documentation, annotations, SAP Fiori tools documentation, and SAP Fiori Development Portal resources to quickly find relevant guidance and code snippets.

Continuous Improvements and Refinements

Beyond the headline features, this release includes a range of continuous improvements that strengthen the overall development experience. Newly created CAP applications now use NPM workspaces by default, establishing best practices out of the box and enabling the use of @sap/ux-ui5-tooling middlewares when previewing CAP-based applications.

The Application Modeler has been enhanced with additional SAP Fiori elements for OData V4 features, including support for hidden draft mode, improved configuration options for table create dialogs, and create support for custom fields in form sections. These additions give developers more control over application behavior without leaving the modeling environment.

Security and user management have also been strengthened. The ABAP Cloud connection type in the Connection Manager has been consolidated around re-entrance ticket authentication, moving away from service key–based authentication. This eliminates long-lived shared credentials and ties system access directly to the signed-in user, improving both security and maintainability.

Looking Ahead

We are already working on the next set of enhancements for SAP Fiori tools. Planned improvements include a rework and enhancement of OPA5 test generation, with added support for value help services and mock data generation. Project validation will be extended with new domain-specific ESLint rule sets, visualized directly in the Application Modeler, alongside support for ESLint 9.

Support for additional SAP Fiori elements building blocks, such as form and field, is also on the roadmap. On the AI side, we continue to improve the robustness and usefulness of responses from the MCP server, while the Project Accelerator will be extended to support RAP service creation.

As always, we look forward to your feedback and contributions as we continue to evolve SAP Fiori tools together with the community.

How to use the new Google IDE Antigravity with SAP (and CAP)

2025-12-26T22:11:07.435000+01:00

We hear that with the new SAP ABAP Cloud on Visual Studio Code, more and more developers will move to the “new” IDE.
We already know that Business Application Studio is a cousin of Visual Studio Code.
Do you know who another cousin is?

Spoiler

Google Antigravity!

In this brief blog post, I will present what it is, why you should use it, how to install all components, how to use it with SAP, and my final thoughts after an intensive weekend of use.

This guide focuses on Windows and Node.js installation (no Java). ⚠️
My personal impressions are from an Apple user perspective. 🤙

What is Google Antigravity?

Google Antigravity is a new IDE forked from Visual Studio Code.
I started using it based on a colleague’s suggestion, mainly because:

Advanced agent-based development model
Google as a strong and reliable engineering brand
Support for running multiple agents in parallel
Unique planning and “vibe coding” experience
Temporary free access to Gemini Pro and Opus models (only for this you should try it!)

Why not give it a try?

Download Antigravity

Google Antigravity Download

If you have never used Visual Studio Code before

The following steps help you get started if you are completely new to Visual Studio Code and Antigravity.

1. Install Node.js

Download the latest Node.js version and complete the installation:

Node.js — Download Node.js®

2. Install CDS Tools for CAP Development

Install the CAP development kit globally:

npm i -g @sap/cds-dk

Note: the -g parameter installs the tool globally and only needs to be executed once.

3. Install Cloud Foundry CLI

The CF CLI is required for Cloud Foundry operations such as application deployment and service management.

You can download it from the SAP Development Tools page (Cloud tab):

SAP Development Tools

Verify the installation:

cf -v

If Antigravity was already open during installation, restart it.

Install the Multi-Target Application plugin:

cf install-plugin multiapps

5. Install Chocolatey and MTA Build Tool (MBT)

Chocolatey is optional. I use it to install GNU Make, which is required by the MTA Build Tool during the build process.

Chocolatey installation guide:

Installing Chocolatey

Install the MTA Build Tool:

npm install -g mbt

Verify the installation:

mbt -v

Configure Plugins and Marketplace for SAP in Antigravity

Antigravity is based on an open-source ecosystem and does not have direct access to all official VS Code plugins. This requires a small configuration change.

From my perspective, the most important plugins are:

SAP Fiori Tools
CDS Tools
CAP Tools
SAPUI5 Extension
UI5 XML Support
Remote Access for SAP Business Application Studio

Go to File > Preferences > Antigravity Settings

Set the following values:

Marketplace Item URL:
https://marketplace.visualstudio.com/items

Marketplace Gallery URL:
https://marketplace.visualstudio.com/_apis/public/gallery

Please restart Antigravity after this change ⚠️

Install all your favorite plugins:

Configure MCP Server

At this point, I recommend configuring the MCP server with the Antigravity AI chat. Here I only describe the CAP MCP configuration, but if you want more info, this is the original post with the most important MCP servers: SAP Build introduces new MCP Servers to enable age... - SAP Community.

In the agent view, select the three dots (…) and choose MCP Servers

, then Manage MCP Servers,

and finally View raw configuration.

Paste the following configuration:

{
  "servers": {
    "cds-mcp": {
      "command": "npx",
      "args": ["-y", "@cap-js/mcp-server"],
      "env": {},
      "type": "stdio"
    }
  },
  "inputs": []
}

Restart Antigravity to complete the setup. ⚠️

To learn more about MCP servers, refer to: MCP – A Comprehensive Guide

Final Conclusion after Intensive Use

Antigravity is still a young product. I had to restart it multiple times during my work, and I consumed the Gemini Pro and Opus credits fairly quickly.

Visual Studio Code still feels more stable, and SAP’s tooling is clearly more mature there. However, switching between the two is extremely easy, which makes experimentation low risk.

I did not fully experience the benefits of multi-model usage yet—this may be due to configuration or limited testing time. Still, I recommend exploring it and trying it out during your vibe coding sessions.

Let me know how your experience goes and what your impression is of this new IDE.
Pro or Cons?

Using Cline with SAP AI Core in VS Code: A Complete Setup Guide

2026-01-05T16:50:16.644000+01:00

As SAP developers, we spend our days juggling multiple tools such as code editors, documentation pages, AI Launchpad, and API testing platforms. With information scattered across different places, a significant amount of time is lost switching between tabs instead of focusing on actual development. Now imagine if SAP’s GenAI capabilities were available right where you work, ready to support you the moment you need them.

That is exactly what Cline integrated with SAP AI Core delivers. Cline works like an AI coding partner inside your development environment, and when connected to SAP AI Core, it brings SAP’s GenAI Hub models directly into your workflow. There are no API calls to write and no dashboards to open. You simply type a prompt and receive instant, SAP-aware assistance for CAP, UI5, CDS, integrations, and more.

Setting it up is simple. Install two extensions and connect your SAP AI Core service key. In just a few minutes, your development environment transforms into an AI-enhanced workspace where you can generate code, debug faster, understand complex logic, and boost productivity without breaking your flow.

This blog walks you through that setup and helps you experience how seamless and powerful SAP development becomes when GenAI is built directly into your everyday tools.

Before you start using Cline with SAP AI Core, please ensure that your SAP GenAI Hub environment is already set up.
If you have not completed the setup, please follow the links below:

SAP AI Core provisioning
https://developers.sap.com/tutorials/ai-core-genaihub-provisioning..html
SAP AI Launchpad provisioning
https://developers.sap.com/tutorials/ai-launchpad-provisioning..html

Step 1: Install Cline Extensions in VS Code

Open Visual Studio Code
Go to the Extensions tab

Search for "Cline"
You will see two extensions in the results

Install both: Cline & Cline for SAP AI Core

After installation, close and reopen VS Code.

Step 2: Create or Use an SAP AI Core Instance

Open your SAP BTP Subaccount.
If you do not already have an SAP AI Core instance, create one by following the provisioning guide: https://developers.sap.com/tutorials/ai-core-genaihub-provisioning..html

Once the instance is created:

Navigate to Instances and Subscriptions
Locate your AI Core instance
Create a Service Key
You will use the details from this service key to configure Cline

Example service key:

Step 3: Configure Cline With SAP AI Core Credentials

In Cline,
API Provider: SAP AI Core
AI Core Client Id: <take the info from key : clientid>
AI Core Client Secret: < take the info from key : clientsecret>
AI Core Base URL: <take the info from key : AI_API_URL>
AI Core Auth URL: <take the info from key : url>
AI Core Resource Group: <by default, group will be default. If you have any specific group please specify the name>
Orchestration Mode: If you have an extended service plan, the “Orchestration Mode” checkbox will automatically appear
Note: If Orchestration Mode is checked, you instantly get access to all models via the Harmonized API with no deployments, else you must deploy and manage each model separately.
Model: Choose desired model from the “dropdown”

Step 4: Verify That Cline Is Working

Click the Cline icon in the VS Code sidebar
Type a test prompt, such as: “Write a 1-line JavaScript function.”
Press Enter

You should now see the response.
🎉 Cline is successfully connected to SAP AI Core!

By integrating Cline with SAP AI Core, you now have a practical and efficient way to use SAP’s GenAI capabilities directly within your development workflow. This setup allows you to generate CAP service logic, refine CDS models, create UI5 components, validate integration flows, and troubleshoot code without jumping between multiple tools.

Using your AI Core service key, endpoints, and resource group, Cline securely connects to SAP’s GenAI Hub and gives you quick access to both Harmonized and model-specific APIs. This ensures that your prompts return consistent, SAP-relevant outputs that fit naturally into your existing project structure.

With everything configured and your first prompt tested, you can now explore different models, try more advanced scenarios, and make AI a reliable part of your daily SAP development routine. This simple addition can make your workflow faster, cleaner, and much more enjoyable.

E2E information available in the attached blog - https://docs.cline.bot/provider-config/sap-aicore

Accelerating SAPUI5 Migration to BAS: A Practical Framework

2026-02-12T08:43:37.222000+01:00

Introduction:

SAP has transitioned its development paradigm from SAP Web IDE to SAP Business Application Studio (BAS), pushing developers to migrate from legacy UI5 to Fiori applications to the new environment. This paper outlines a structured and scalable methodology to migrate SAP UI5 applications from WEB IDE to BAS, focusing on connectivity, tooling and configuration challenges.

Methodology:

Log in to your BTP Account. Go into your space. Go to the Service Marketplace. Search for Business Application Studio. Open Business Application Studio Application.

Note: Pre-Requisite - Cloud Connector and Destination should be set up for connectivity with the S4.

2. Click on Create Dev Space. Give some Dev Space Name—select the SAP Fiori on the left. On the right side, under Additional SAP Extensions select HTML5 Application Template, Launchpad Module, Basic UI5 Template. Click on Create Dev Space.

3. Dev Space is created as shown below. It will take a few minutes to start. Once it's started, click on the Dev space. Here, I have named it “DemoMigration”. It will open the Development workspace. Bookmark this URL for future use and easy navigation to Workspace.

4. For the first time, click on the menu on the top left and select the open folder. Search for Projects Folder. Click on OK.

5. Click on Import on your Get Started page. It will prompt to start the migration. Select migration option. Below screen will appear.

6. Select Destination and Hostname and Client Details.

Conclusion:

Migrating SAP UI5 applications from SAP Web IDE to SAP Business Application Studio is more than a technical upgrade. It represents a strategic change towards a cloud-native and future ready development environment aligned with that of SAP’s roadmap. This blog outlined a well-structured migration methodology, which includes prerequisite connectivity set up, dev space configuration, project import and environment preparation within BAS. By following these steps, organizations can ensure a smooth transition while minimizing disruption to existing Fiori applications. This structured approach simplifies migration from WEB IDE to BAS. It supports scalable and cloud-aligned SAPUI5 development for public institutions and enterprises.

Part 1: Creating and Deploying a SAP CAP Application with SAP HANA on SAP BTP (Cloud Foundry)

2026-02-25T07:35:57.804000+01:00

Note: This blog is the First Part of series - Building and Deploying SAP CAP Applications on BTP: From Database to Work Zone

Introduction

SAP Cloud Application Programming Model (CAP) is often demonstrated through local examples, but its real value becomes clear when the application is deployed to SAP Business Technology Platform (BTP) and backed by a managed database.

In this blog, we will go through creating a basic SAP CAP application using the SAP Business Application Studio (BAS) CAP template, binding it to SAP HANA Cloud, and deploying it to SAP BTP using the Cloud Foundry runtime.

The goal here is not to build a complex application, but to establish a clean, working reference point. I start with a minimal CAP project to keep the focus on deployment rather than domain complexity.

This blog serves as a baseline for a series where the same CAP application will later be deployed using different databases and runtimes. The focus here is not application complexity, but establishing a clean, working reference point.

Pre-requisites:

Please make sure that you have these before starting the development:

SAP BTP Account
Cloud Foundry instance
Active Hana Cloud Instance
SAP BAS / VSCode for development
If using BAS, have a dev space running
If using VSCode then make sure that you have installed Node.js and CLI installed

Now, let’s start with the development.

Create a CAP Project from Template given in the BAS:

SAP Business Application Studio provides a template for creating a CAP project with the required structure. The positives of using the template is that it automatically builds your Multi-Tenant Application file (mta.yaml) with the required deployment modules.

Follow the following steps:

Open BAS
Click on the Side Menu on the top-left corner
Click on File
Click on New Project From Template
Select CAP Project
Configure the project as follows:
- Project Name: cap-hana-app
- Runtime: Node.js
- Database: SAP HANA Cloud
- Deployment Environment: Cloud Foundry
- Runtime Capabilities: XSUAA
Click on Finish

CAP Project creation wizard with SAP HANA selected

This will create a CAP project for you with mta.yaml automatically updated. The generated project follows standard CAP structure:

app – UI
db – Schema and data files
srv – Service Definition

Now that the project is created, let’s get into development.

Development:

Follow the following steps:

Define a Simple Data Model:

If you have schema.cds under db/ folder, then update it with the following code snippet. If you do not have schema.cds, then create one.

namespace com.mycompany.capapp;
entity Products {
    key ID          : UUID;
        name        : String(100);
        description : String(500);
        price       : Decimal(10, 2);
        stock       : Integer;
        category    : String(50);
        createdAt   : Timestamp;
        modifiedAt  : Timestamp;
}

Expose the Model via CAP Service:

If you have service.cds under srv/ folder, then update it with the following code snippet. If you do not have service.cds, then create one.

using com.mycompany.capapp from '../db/schema';

service CatalogService {
    entity Products as projection on capapp.Products;
    }

CAP automatically exposes this service as an OData endpoint without requiring manual REST configuration.

Add Data:

Run the following in the project terminal:

cds add data --records 5

Run the Application locally:

Run the following command:

cds watch

You should be able to see the data in the Products

You can also use the SQLite as a database while running locally. Execute these before starting the application:

cds build
cds deploy

Add a Managed Approuter:

Right click on mta.yaml
Click on Create MTA Module from Template
Select Approuter Configuration
Fill in the required details
Click Finish

This is important to view the data once deployed.

Prepare the Project for Deployment:

Since we have created the project from the BAS Template, we already have the mta.yaml updated and deployment ready. This file already includes:

CAP Service Modules
SAP HANA HDI Container
Required Service Bindings

Build the CAP Project:

First things first, install node modules. Run the following in the Terminal:

npm i

To build the project, you can either run the following in the terminal:

mbt build

or can do it manually:

Right click on mta.yaml
Select Build MTA Project

This will build your project for deployment. Watch-out at the project structure. You might see a new addition to the structure mta_archives which consists the mtar file of the project.

Deploy the Application:

To deploy the application to your BTP using Cloud Foundry, you will have to login to Cloud Foundry. Run the following in Terminal:

cf login

This will ask for your subaccount credentials. Provide them and you will be logged in successfully. Remember to map the correct space and org.

Once you are logged in successfully, you are ready to deploy the application. Remember the file generated while building the CAP project, this is the same file that will be deployed.

Run the following command:

cf deploy mta_archives/cap-hana-app_1.0.0.mtar

or, you can just right click on cap-hana-app_1.0.0.mtar under mta_archives folder, and click on Deploy MTA Archive.

Successful Cloud Foundry deployment

During deployment:

HDI Container is created
Database schema is deployed
CAP Service is bound to the database automatically

Confirm the Deployed Instances

Verify the Deployed Application:

When the deployment is successful, you will get a application route. Copy the same and open it in the new tab of your browser and access the service endpoint: /catalog/Products

If the deployment is successful, you can see the data displayed in a JSON format.

Browser showing the OData service response

Conclusion

With that, we have successfully created a minimal SAP CAP application, connected it to SAP HANA Cloud, and deployed it to SAP BTP using the Cloud Foundry runtime. While the application itself is intentionally simple, the deployment pipeline we established here — from schema definition to MTA build to Cloud Foundry deployment — reflects a production-ready workflow that scales well as complexity grows.

The key takeaways from this exercise are that the BAS CAP template significantly reduces boilerplate by auto-generating the mta.yaml with the necessary modules and bindings, the HDI container handles schema deployment seamlessly, and CAP's convention-over-configuration approach means your OData service is ready without any manual REST wiring.

This baseline will serve as the foundation for the rest of this series, where we will explore deploying the same application with different databases, runtimes, and configurations — making it easier to understand the trade-offs of each approach. Stay tuned for the next part!

Next Steps

In the upcoming blogs, we will focus on creating the same application using a PostgreSQL, Hyperscaler Option.