For the last 7 years, I have been very sceptical to low-code platforms in general, and Neptune Software's offering in particular. Despite (or maybe thanks to) the numerous, sometime strongly worded arguments and disagreements I had with Njål Stabell, one of the companies founders, we did grow a mutual repect and eventually became very good friends.
I am not an employee of Neptune Software, nor do I plan to be a Neptune Software employee.
Instead, I work as an independent consultant for my sole proprietorship Qualiture (https://www.qualiture.nl), focussing on front-end development, striving to achieve the best user experience for my customers, in whatever way I see fit.
This blog portrays my personal insights and findings during trying out a trial version of a low-code development platform, in particular this case from Neptune Software. In the future, I might write about other low-code / no-code platforms as well.
Some self-reflection, you may skip this
Ever since the demise of WebDynpro started somewhere in the last 7-8 years I have been building (web) applications using a variety of frameworks. Not only SAPUI5/OpenUI5, but also React, Bootstrap, Backbone, Handlebars and even iOS applications using the SAP BTP SDK for iOS. And depending on the platform it ran on, it also involved coding a middleware layer either in NodeJS (SAP BTP) or Java (SAP NetWeaver Java or Neo).
Despite the available tooling, SDK's and wizards, each approach took a considerable amount of time to set up the initial development environment, the initial application scaffolding, the actual coding/building of the app, and the subsequent maintenance (updating conflicting npm packages, anyone?). However, of all these front-end technologies, I felt that scaffolding a SAPUI5 application with XML views yielded the quickest results, and a standalone PoC could be build in a couple of hours.
Around that same time, low-code platforms started to emerge, but to me these platforms couldn't provide the same consumer-grade user-experience as a meticuliously crafted handcoded application with all its development freedom. To my horror, there were even platforms where an ABAP / backend developer could build or generate a SAPUI5 frontend, and to me that felt like the world upside-down as this somewhat heated discussion 7 years ago between one of Neptune's co-founders and myself will prove...
Over the years, my aversion to low-code platforms in general gradually declined as the platforms matured significantly and providing a solid user experience is on everyone's mind. What really pushed me towards low-code approaches was when attending the unscripted Neptune customer event in 2019 where customers showcased their applications built with Neptune and how they were delivered on time, within budget, above expectations and with surprisingly great UX.
And in current times, where companies need to adapt to changes more rapidly, a time and costs saving low-code approach makes all sense, so I started to dive in deeper into Neptune DXP in particular.
Code? Where we're going we don't need code
Neptune Software offers their DXP platform in an SAP edition (which runs embedded in an ABAP stack) as well as an Open edition (which runs on any platform or cloud provider, even SAP BTP and Raspberry Pi). Since I am not wealthy enough to run an ABAP stack myself, but do have an AWS account, I opted for the DXP Open edition which I ran off an AWS EC2 instance.
Exploring the Planet 9 cockpit and clicking around, the first thing I noticed was how fast and responsive everything works, especially when compared to the often sometimes sluggish SAP BTP cockpit. And at first sight, there is a surprisingly large amount of services and functionality available. OData services and API management, application and theme designers, user management, security and usage logs are the usual stuff. But also the creation of test plans for unit tests (!), creation of a Cordova mobile client, load-testing your API's, and even a (curated) store containing application building blocks are included.
Being a developer I was most interested in how easy it is to create a simple application, and the platform comes with three editors:
App Editor (pro-code) for hand-coding React or Vue applications. Surprisingly, no SAPUI5...
App Designer (low-code) for building UI5 apps with minimal coding
Adaptive Designer (no-code) which lets you create UI5 apps based on application templates
As I had no interest in the pro-code editor, I opened the App Designer. Within minutes, I had created a decent looking yet very simple application, with no datasource.
Going back to the Planet 9 cockpit, I added the Northwind OData service to the "OData Source" service. Going back to the App Designer, I dragged an 'ODataSource' object onto my project, added some bindings by just clicking, et voila, I had a simple app with OData connectivity:
Having a closer look at the built-in store, there are some truly wonderful building blocks to be found. There's a lot of ready to be used building blocks like a new and highly usable Launchpad, a signature pad, OCR functionality and barcode scanner, which are not standard available in the SAPUI5 framework. But what to think of a building block that provides chat functionality to be used in home automation? Or an Augmented Reality feature? Video chat? It's all there to use.
The building block that immediately grabbed my attention was the "Delivery Template Application" application template. Having worked in a development team where we created a similar app (displaying maintenance orders in a list and on a map, navigating to an order location and starting / finalizing work) which took several months to complete, I was wondering if this would have sped up development in retrospect. The template promises some really great out-of-the-box functionality, like geofencing, offline data and barcode scanning. Simply following the instructions and then running the app in the Application Designer yielded some pretty stunning results:
However, since it's just a building block, it uses no connectivity whatsoever. However, it comes with two table definition files which you can import in the cockpit's "Table Definition" tool, and by importing the JSON data using the "Table Browser" tool I now had my data in the platform's Postgres database.
In order to access the newly created tables via an API, the platform comes with a really handy "API Designer" tool. Here you can create your API's and operations by hand, but the true marvel is it can generate it from the previously used table definitions! Simply import the table definitions here, and everything is created: the endpoints, the four operations, even the Swagger documentation is generated:
Utilizing two "RestAPI" objects -- for the GET request to both headers and details -- and binding them with two "ModelArray" objects -- to store the retrieved data -- I could then think of how to invoke the API calls. Luckily, there's still no coding necessary since the "RestAPI" objects have a "setInitLoad" property. By setting this property to "online" the requests are now executed upon starting the app:
Changing the static data to the results from the executed API's does involve some coding (finally). Luckily, there's no need to dive into huge controller or component classes and manually write event handlers. Each (SAPUI5) object that is capable of emitting events has an "Events" tab in the App Designer. By clicking on the "Edit" icon next to the "ajaxSuccess" event for each "RestAPI" instance opens an editor, and by adding one line of code it will bind the results of the API call to the UI. Whoohoo, I now have an app with live data!
From here on, it is genuinely easy to adapt the app to your needs. It supports geofencing, so dragging the blue "This is you" dot onto the perimeter of an order location will have its icon bouncing, which is a nice touch. Adding a few lines of code invoking the "navigator.geolocation.watchPosition" functionality to update your current location is all it takes to make the app aware of your location.
Even more, by using the no-code editor "Adaptive Designer" you can generate a two-page app based on the table definition, for displaying the list of orders and an edit / create page to update or create a new order, as can be seen from the screenshots below. And all of that was created with literally just a handful of clicks in a couple of minutes, without coding a single line!
As can be seen from the above screnshots, I have bound the "itemPress" event of a list item of the "orderheaderlist" app to the "orderheaderedit" app.
If you then update or create an order, that changed or created order will then be visible in the deliveries app after refreshing its data. Magic!
Can't have any bugs if there is no code
By now it should be obvious I became very enthusiastic about low-code / no-code platforms in general, and Neptune's DXP platform in particular. As mentioned, I have previously worked in a development team where we developed an app just like this, but it was all handcoded with Bootstrap/Backbone/Handlebars, and it took us months before we achieved the same level of completeness as I did now in literally less than one hour! I truly believe adopting a low-code / no-code approach will be paramount for companies to be able to quickly adapt to changes and stay ahead of the competition.
To make things even better, Neptune has recently launched their own managed public-cloud offering, so you don't need to run and maintain it from your own cloud vendor. And judging from the cost calculator it is already available at a very reasonable price of EUR 252 per month (yes, that's for a productive environment!):
You don't need to write comments if you don't code
Well, actually I would love to read your comments. As I'm just a novice in the low-code realm, I would like to hear from you what I could have done better, any best practices, or ultimately, what you would like to see from platforms like Neptune's DXP.
Are you evaluating a low-code approach? Or has your company already adopted low-code / no-code development? What are your particular pro's and cons?