Ensure trust in your app through native mobile development. Find out how you can use NativeScript to develop more responsive and trust-building apps.
In recent years, we’ve seen an explosion of mobile. From 2008-2015, mobile usage time increased exponentially while desktop usage has remained generally the same. This has amplified connectivity time overall: mobile usage hasn’t replaced desktop, but rather has formed an additional channel on top of it.
Recent studies have shown that for a large proportion of the population, the first and last thing they touch in their day is their mobile device. This indicates a large amount of dependence and incorporation of mobile devices into our lives. Therefore, when considering mobile as another way to reach customers, it’s crucial to remember that mobile usage is about trust. Developers should be asking the following questions: how much do your users trust your app? Where does the formation of this trust begin for your app and the ensuing experience?
For Netcentric, this trust must be formed from the moment a user opens an app and starts to use it: users begin to judge and gauge their level of trust towards an application straight away.
To dive deeper into this, it’s necessary to take a look at how a hybrid app works internally. In a hybrid app, the Javascript that drives the app and what the user sees both run on a single processing thread. This can result in a slow experience where any Javascript activity means the user interface will be slower to respond.
For example, on an HTML page running inside a mobile web view, requests made to the native side get passed over via a bridge, and then interact with the native view controllers. These controllers might adjust the container, GPS or camera or other aspects that are native to the device. Once that has occurred, it passes data back over via the bridge, and the Javascript then responds to update the UI. This can be laggy and produce an unpleasant experience for the user, in particular when the app is trying to carry out complicated processes.
This is in contrast to how the native technology we now use at Netcentric runs. With native, both the Javascript and the native display widgets have their own thread, so the user interface runs independently. This means that when users scroll through a page and the Javascript loads in the background, the scrolling and gestures aren’t interrupted.
For instance, it’s possible to carry out native client-side requests at the same time as server calls are being made, and background items are being rendered on the Javascript thread. This results in a much better experience for users. It is for this reason that, for this project, Netcentric decided to use native as much as possible.
Contrast that to using NativeScript, an open source solution with no licensing restrictions, that allows us to write code in Angular, and transform that code into native apps. Given that, for instance, an iOS button and an Android button would use very different codes, NativeScript allows you to write an XML format so that, when building your app, individual iOS and Android apps can be produced. For each platform, the code is documented and standardised, and the apps are ready to submit to the stores.
This means we can write our logic in the Javascript we know, and write the UI in simple terms that we can understand, and trust that it will still be running natively on devices.
Raiffeisen’s goal was to guide users smoothly through their app to locate relevant content for them. Besides this content, there was data being pulled in from a number of different sources, creating additional requirements. Raiffeisen has subsites that don’t necessarily run on AEM sites, so Netcentric’s role was to ingest that content and present it in a standardised way, so the user could subscribe to different categories.
The central data here originated from five different sources, a number that might increase in the future. Therefore, we had to pull that data into AEM, convert it all into the same format, then hand it back out into small bits to the app. This means the small JSON file are pre-rendered on the server so that when the app client makes a request, it receives back only the necessary data. This results in a faster experience when navigating the app.
There were also additional non-content requirements that benefitted from a native-approach combined with the speed of development with Angular.
The project presented a challenging 6 months of work but was fascinating to carry out and the response was very positive once it went into production. For Netcentric, we consider it a success story that shows what we can do in mobile development.
When preparing for a mobile app, it’s important to enter the mindset of asking how easy and useful your app can be, think through this process and be sure to measure results afterwards to create a successful app.
Read about how Netcentric leveraged native mobile technologies to build a cross-platform app for Raiffeisen Bank, linking customers to their local branches like never before.