This blog post is an informal conversation between a student and a teacher. The student wants to understand what has sparked his teacher's drive to learn and use the SAPUI5 framework as a hobby.  In a technology landscape dominated by AI's efficiency, human stories remain one of the great tools to ignite passion for learning, creativity, and optimism. Our hope is that this conversation will help readers learn more about the SAPUI5 framework while getting to know Takvor and his journey as an enthusiast of the SAPUI5 community.

Hello Takvor, in 2025, I attended your “SAPUI5 Application Development” one-day training session and was delighted to be part of it. I understand that you organize and deliver these trainings based on your experience with SAPUI5 and a genuine passion for this technology. Could you share your background and how you got started with SAPUI5 as a hobby? What led you to begin using it?

Takvor: I initially started using SAPUI5 as part of my tasks on one of our SAP projects. However, this was in the early days of SAPUI5 when there were no mobile controls yet. After about a year and a half of working with the framework, I applied for a one-month fellowship within SAP. During this fellowship, I helped SAPUI5 colleagues develop applications using the freshly released SAP m mobile controls.

This time required me to deepen my knowledge of SAPUI5, which truly ignited my enthusiasm for the framework. I realized that using a unified framework like SAPUI5 allows the development of applications accessible from various devices and hosted on a web server. This means that SAPUI5 applications are easy to maintain and accessible to all users and devices. This discovery ignited my interest in further developing my knowledge and diving deeper into the framework.

I read all available SAPUI5 documentation, developer guides, and related topics. I was eager to put this knowledge into practice, and the following year, there was a competition to develop an application that had to be rendered on a mobile device. So, I decided to develop the UI for such an application using SAPUI5 m controls to practice the knowledge I had gained. Initially, I focused on developing the user interface and participating in the competition.

The application itself was interesting; it was about sharing information on who drives what car in the company (Carfleet). So, if you wanted to buy a car, you could find someone who owned that model and seek advice.

Next, I further developed this application by adding a back end. Eventually, this application became generally available to all colleagues within SAP. At the same time, the UI was developed in accordance with all SAPUI5 documentation standards, so I used it as a basis for the training I started. I wanted to share the SAPUI5 knowledge I had gained with other colleagues, so I launched the training program.

That's how it all came together— I developed the training using my experience developing this application, meaning the application serves as a practical example of how best practices are applied. That's my background related to SAPUI5.

What challenges did you face while learning SAPUI5 as a framework, and how did you overcome them? I find this question particularly interesting because, as I understand it, you've been learning by doing—essentially self-taught and figuring things out on your own.

So, when considering overcoming these challenges, I believe it's important for young learners to understand not just the external obstacles, but also to understand their own internal motivation. Apart from the challenges, what led to your success? Was it curiosity, persistence, or other personal traits? If you could name some qualities that helped you succeed, that would be great!

Takvor: Yeah, sure! My main job at SAP isn't related to UI technologies at all. Throughout the projects I've participated in, I've had some UI-related tasks after the initial project, but maybe 80% or 90% of my work is back-end. Right now, I'm working with Golang on the Signify service. This is a Hyperspace service used to digitally sign and verify artifacts at SAP. We don't have a graphical user interface—it's all API-based.

I'm saying this to highlight that my experience with SAPUI5 is entirely hobby-based. It's serious, yet one of my passions and interests that I want to keep alive, even as new developments emerge.

Regarding time spans, I didn't have deadlines for developing my SAPUI5 applications or expanding the training course content. I was doing it at my own pace, reading all new topics in the SAPUI5 documentation. That's probably one reason that helped me learn—there was no pressure, which usually isn't the case. However, if someone wants to learn SAPUI5, there's plenty to learn and various ways to do so.

The documentation—the Demo Kit—is filled with guidelines and examples. Another great aspect of UI technology is that you get immediate, interactive examples you can inspect and directly interact with. There are samples within the Demo Kit where you can modify the code—or copy, paste, change, and start using it immediately.

There is a wealth of information about SAPUI5, and with time and interest, you can explore and understand it. The topics are complex because the framework is comprehensive, covering everything needed for enterprise applications. The toolset and utilities are all there. The good thing about the framework is that it's very well structured. While it might be complex, the topics are logically connected and make sense. Once you learn the fundamentals, you'll be able to build your tasks or UIs as you wish.

Compared to other frameworks, can you give an example for those interested in learning SAPUI5? How can we illustrate this complexity, perhaps in relation to another technology? Is there an example we can provide to help them understand?

Takvor: Sure. One example is the sheer number of formats and languages you need to know while building an SAPUI5 application. You're primarily working with JavaScript, but you also need to understand XML for views. You should know HTML here and there—not extensively, but somewhat. CSS is also necessary. YAML is another important format, mainly for setting up your development environment, builds, and local servers. JSON is used in many areas—not directly everywhere, but still important to be familiar with. These formats contribute to the complexity.

Another aspect is the baseline artifacts required to build even a simple but standard application. You can create a basic application with just one HTML file—that's fine—but in practice, that's not how most applications are built. Most are structured as components with component descriptors, views, a root view, etc.

For example, if you want to create a standard application with simple functionality like displaying “Hello World”—just to show something on the UI—you first create the index.html. You'll then need a Component.js, which describes your component because applications are either embedded in LaunchPads or run as independent units. Next, you'll need a manifest.json to configure this component and set up routes to the application. In the manifest.json, you specify your root view, which is like a container for all other views. Then, in this root view, you start laying out different pages represented by views and controllers.

That structure alone is complex, and the multitude of layers may sound intimidating. On each level, different formats and configurations exist. For example, in manifest.json, you should learn how routes are configured. In the root view, you should know your root container. In Component.js, it's often straightforward—mostly copy-pasting—but if you initialize some models in Component.js, you place them there. Index.html might be the simplest of all these levels, but even then, you need a well-configured script to bootstrap the application.

All this contributes to the complexity, which might confuse many colleagues. Yes, it's rewarding when you connect all these details and observe the results, such as applications for the car fleet or skills transfer across the organization. A major advantage of SAPUI5 is its foundation on open standards like JavaScript, HTML, and CSS. Most of these technologies are open standards, making the framework technology-agnostic. Even if you require something specific—like an external library or UI controls—you can easily integrate these libraries into the standard framework as they're built on open standards.

You mentioned three levels of reusability. Could you describe the three levels of reusability and the standardization you mentioned in SAPUI5?

Takvor: Yeah, there are three approaches to consuming SAPUI5. At SAP, we aim for all applications to have a consistent look and feel. This is the basic goal—the minimum requirement is that your application uses standard themes and has a uniform appearance.

First Level of Reusability: This is Fiori Elements. If you want just this, you can use Fiori Elements. I think they're based on web components. I've not used them in my apps—I'm using the SAP controls directly provided by the framework. But if your team consists of developers familiar with Angular or React and insists on using them, you can still build your UI in those frameworks while achieving the standard SAP look and feel. This is the first way to consume SAPUI5, the first level of reusability.

Second Level of Reusability: This is the full SAPUI5 Framework. On the other hand, the SAPUI5 framework is a comprehensive UI framework. Using only it, you can build a full-fledged enterprise application featuring a standard look, controls standard to UI5 developers, Model-View-Controller architecture, JSON models, other data models, and internationalization—essentially all major features needed in a UI application are provided. I employ this approach in my two applications. It's intended for standard UI developers who want all features SAPUI5 provides.

Third Level of Reusability: These are the Smart Controls. The third type of reusability involves Smart Controls. This approach is for developers with little or no UI experience. For example, ABAP developers who have decades of back-end experience but have never worked on UI development can use a limited set of SAPUI5 controls called Dynamic Controls, configuring appearance, behavior, and interaction through metadata. They build their backend or data service as preferred, using instructions or annotations interpreted by Smart Controls—UI controls that deliver intended functionality. This approach is often used when building something standardized, with no deviations in look, feel, and interaction, relying mostly on back-end logic.

To summarize:

• The first approach targets UI developers experienced in popular frameworks but less familiar with the SAPUI5 complexity.
• The second level is intended for standard UI developers seeking the full power of SAPUI5.
• The third level is designed for back-end developers requiring minimal front-end development for UI creation.

Are there any controls or parts of the technology that are favorites of yours? Do you have controls that you particularly enjoy using? Are there controls you believe could be improved? What are your thoughts?

Takvor: Yeah, one of the most useful controls is the FlexBox controls in SAPUI5, based on the popular CSS Flexible Box Layout standard. They include HBox (horizontal box) and VBox (vertical box), serving as highly configurable and responsive areas or containers. When you shrink your browser or open the app on a mobile device, the controls inside automatically rearrange. With FlexBox, you can easily build your layout.

For example, if I need cards or forms—like when dealing with a dialog containing a form—I use FlexBox as it's simple and flexible.

Regarding not just controls, but also the eventing system—the Event Bus, specifically—is very useful. I aim to keep the different views and components of the app independent to avoid hard references or API ties. This is achieved when having a dialog with a view and controller, and a view showing this dialog. To keep the dialog and logic separate from the parent view, their connection is easily managed by the Event Bus.

For example, if you wish to pass data or trigger an event from the dialog to the view and then process it, you simply send it as an Event Bus event. This separates UI components, making the application cleaner and more organized.

Since you conduct SAPUI5 training sessions, what is your impression of how participants respond to the technology? Is there something you notice people particularly like, or something that challenges them? 

Takvor: I think the most challenging part for colleagues in my training courses is SAPUI5 bindings. We spend significant time explaining binding methods—the various syntax options for achieving the same or complex bindings. This topic engages them greatly, and it's where they often make mistakes.

I've observed that colleagues feel happy when they understand connections. Once they grasp what ties together and how things connect, they gain control over the technology. As mentioned earlier, the framework is complex but logical and well-structured. With enough time and attention, one can build a mental model of the application. Upon mastering this model and gaining experience—for example, knowing available controls, tools, and events—you start working with confidence.

In our preparation for this conversation, we discussed the UI5 community and support network, noting pros and cons. How does the SAPUI5 framework compete with other, likely larger communities? As an enterprise framework, what advantages does SAPUI5 and its community offer?

Takvor: If you aim to build something within the SAP environment, SAPUI5 is a great choice as it's the standard framework. Although it's more complex than React or Angular, most SAP applications are built with it. Internally at SAP, examples and support abound.

The framework is not only well-structured but also based on open standards. Suppose you encounter difficulties with an aspect—FlexBox, for instance—if documentation lacks information, you can explore open standards, like standard CSS Flexible Box controls, for online support.

Nearly all SAPUI5 controls are based on widely-used open standards, providing opportunities to understand and extend them as needed. The level of standardization in SAPUI5 technologies is very high.

How often do you offer the SAPUI5 Application Development training, and how can people join if interested?

Takvor: We plan to offer the “SAPUI5 Application Development” training twice a year, likely mid-year and in the second half. Colleagues can follow the newsletter in the section “Trainings in Focus.” 

The approach is practical and hands-on—though not wholly hands-on—but focuses on diving into real application code and learning concepts. That's the training style.