This is a test message to test the length of the message box.
Login
|

052: 10 Minutes from Start to Launchpad

276

In this episode, we'll look at how we can create a RAP application within 10 minutes, generate and deploy it, and finally launch it in the Launchpad.

Advertising


From modeling to launchpad in 10 minutes: That's the basic goal when we want to make a Fiori Elements application available. Many believe that Fiori development takes a very long time and requires many steps before you can even see the first results. Therefore, in this episode, we want to try out what it looks like when we start with an idea and how long it actually takes until we have our application in the system and can make it available to a business user.

 

Modeling

So let's start with the basic idea: We want to provide an application that allows any developer to evaluate which objects they have in the system. For this purpose, there is a Core Data Service, provided as a public API, to retrieve all custom objects in the system. We use this as a basis for creating a new Core Data Service. It's important that we use a root entity, as we want to create a RAP application. After creating the Core Data Service, we first clean it up by removing unnecessary annotations and comments, as well as various associations. Additionally, we create a new association to read the text for the software components. We build this association by iterating over the actual software component and the current system language. We then add this association at the end so that we can use it later. Since we only want to display the objects of the current user, we extend the WHERE condition to include the currently logged-in user for filtering.

Once we're finished with that, we can test the Core Data Service. To do this, we run the Data Preview with F8 and display the first data. We select a data record and navigate to the text of the software component via the defined association and see that this is also loaded correctly. With that, the actual modeling of the data model is complete, and we can go directly to the Consumption Layer. To do this, we can use the shortcut over the Core Data Service and right-click to create a new Core Data Service based on this one. This will be given a new name; "C" stands for Consumption View. Finally, it's important that you select the correct template. We don't want a new view; instead, we want to create a projection that's important for consumption. After generating the view, we first set the `Metadata.allowExtensions` annotation to define a metadata extension file later. We also have some mandatory fields, such as the provider contract, which we must specify at this level. Since we're also inheriting from a root view, we must also use the `ROOT` keyword. Additionally, we now define the software component name that we'll use later in the model. This is possible at the consumption level to define the final fields, and we also assign a new alias. Once we're finished, we can activate the core data service.

In the next step, we want to see fields and information in our UI, as well as have some filters. To do this, we create a new metadata extension directly on our consumption view. We define the layer as "Customer" and use an IDE action to define the UI annotations for the interface. We want to create two faces: one for general information and another where we can display information about the software component. Therefore, we create a new facet, assign it a position and a qualifier so that we can later assign the fields. At the field level, for example, we don't want to display the first field. Therefore, we can hide the field using "UI.hidden". Similarly, we want to assign the software component information to the software component. At the same time, we define a new selection field on the ABAP package, which will later be offered as a selection. Furthermore, we hide the Responsible Person, since in this case we are always the current user, as well as another field that we don't need. Once we're finished with that, we can generate the annotations. The Metadata Wizard saves us a lot of work here, allowing us to create the UI quickly and easily.

 

Service

Now we need to create the actual service in the system so that we can generate a Fiori Elements application on it. To do this, you can right-click on the Consumption View, open the context menu, and create a new service definition. We give the service definition a name and generate it. We also give the entity that we expose externally a new alias so that it is used in the Fiori application. We also define the leading entity. If we have other entities in our service, these entities are marked separately, which, for example, makes it easier to access the preview. In the next step, we need a service binding. The service binding defines the protocol. Here, we use an OData V4 UI protocol and have the corresponding service binding created. Now comes the longest step, namely the activation of the service. We save and activate the service, and by clicking the "Publish" button, we ensure that the service endpoint is made available in the system. This may take a few minutes.

 

Generation

To generate our application, we now switch to the Business Application Studio. Of course, you can also use VS Code if you prefer to work locally. In the Business Application Studio, we go to the "File" menu and generate a new project from a template. Here, we select the standard Fiori generator. As a template, we use the "List Report" template; this template is very frequently used when defining Fiori Elements applications. Now we need to select the actual service in the system. This means we connect to our ABAP environment and specify a destination that leads to this system. The services from the system are then loaded. We can filter for our service there. Next, we select the entity; since we only have one entity in the service, it is already preselected. In the next step, we enter further project attributes: the application name, the namespace, and we also want to define a deployment configuration and a Fiori launchpad configuration. In the deployment configuration, we specify the artifact that will later be deployed to the system. We also specify our package in which we defined the application. Since this package does not require transport, no transport query will be made. For the launchpad configuration, we enter the semantic object and the action. These will be needed later for navigation within the launchpad. We also specify a title and a subtitle, which will later be visible on the tile in the launchpad.

The project is now being generated. This may take a moment, and we will receive the Application Info as the final version. We can make further adjustments to the app in the Application Info. Since we don't need this, we will start the deployment directly. Because a deployment configuration has already been created, we only need to confirm that we want to deploy the project, and the actual deployment process will begin. This can also take a few seconds until we receive a success message that the artifact has been deployed on the system.

 

Launchpad

To deploy our application to the Fiori Launchpad, we need to make some configurations within our project. If we refresh the package, we'll see that several new artifacts have been created. One important artifact is the App Descriptor Item, which is responsible for the Launchpad configuration. Let's create a new IAM App. This represents an application for the Launchpad configuration. We define it as an External App, since it's a deployed artifact. In the IAM App, we specify the Fiori Launchpad App Descriptor Item. This was created during deployment, and we can select it using Ctrl+1. In the Services section, we see that the application's corresponding service has now been applied. We then publish the app in the Launchpad using "Publish Locally." Once that's done, we want to create a new business catalog. We can later assign this business catalog to a business role and group various apps under it. We create a new business catalog using the shortcut in the IAM app, which automatically assigns our application to the business catalog. Once we're finished, we can close the assignment and then trigger the announcement in the Launchpad via the "Publish Locally" button in the Business Catalog. These steps can also take a few seconds to a few minutes.

Now we would switch to the actual Launchpad and then to the "Maintain Business Roles" app. Here we create a new Business Role and give it a description to generate it in the system. We can now assign the generated Business Catalog to the Business Role. You can search for and add the Business Catalog in the system using the Add function. To ensure the new role is also directly assigned to our user, we can go to the "Business Users" tab. We can also directly search for our user in the system and assign them to the role. As a final step, we go to the General Details and set this role to "Unrestricted" so that we have full permissions, and then save. This creates the role in the system and assigns it directly to our user.

We can now search for the application. Currently, we can't find the application here. This is because the permissions haven't been applied correctly yet and are not available to our user in the current context. Pressing Ctrl + F5 refreshes the browser, and after a short loading time, we see our application and can run it.

 

Test

We load the application and already see that certain selections are available. We can view all our development objects via "Go". For example, the filter for packages allows us to filter for objects within packages. Navigating to the Object Page shows that our information is present, distributed across the various facets. We also have the option to search by object type if, for example, we want to see all classes in this package.

 

Conclusion

With that, the entire process is now complete. We have modeled a new application, deployed it to the system, and configured it so that we can use it directly. From this point on, another user, to whom we assign the role, could work with the application. The actual process was very quick, and the application is available. This helps you remember: The entire development process for deploying a new application doesn't actually take very long, at least if you know where you need to work and the requirements are clear. Since we have provided a Fiori Elements application, we can later equip this application with behaviors that change facets or add further information without having to redeploy the actual Fiori artifact.

We hope you were able to take away some new information and can tell your colleagues that actual Fiori development doesn't take that long and prototyping is very feasible. Thank you for watching and see you next time!

 

YouTube
Video


Included topics:
YouTubeScriptRAPFiori ElementsQuick RAP
Comments (0)



And further ...

Are you satisfied with the content of the article? We post new content in the ABAP area every Tuesday and Friday and irregularly in all other areas. Take a look at our tools and apps, we provide them free of charge.


056: Fiori Elements for ABAP Developers

Category - YouTube

What are the key elements for an ABAP developer to become a full-stack developer? Let's look at some of the building blocks from the ABAP developer's perspective and define a goal for the journey.

11/02/2026

055: Clean Core Measurement

Category - YouTube

Are you on the path to Clean Core? But how do you ensure you actually get there? This open-source project is about moving from feeling to knowing. It offers insights into Clean Core and measurement for greater transparency.

10/19/2026

054: Recycling-Heroes - Data Generation (Document)

Category - YouTube

In this episode, we generate test data off-stack with Claude and have the method written for us, before we then perform the review in the real ABAP system and load the sample data for our documents.

10/05/2026

053: Recycling-Heroes - Multi-Input Field (Document)

Category - YouTube

In this episode, we'll introduce additional convenience features to the Recycling Heroes document app, address the various value helps and activate multi-input for the tags on the Object Page.

09/28/2026

051: ABAP Cleaner in VS Code - Installation and Guide

Category - YouTube

The ABAP Cleaner has been available for VS Code for some time now. Let's take a look at how to install it and use it in the ABAP Development Tools to save time and effort during development.

08/17/2026