Are cross-platform solutions heading for the throne of mobile app development?

What are multi-platform solutions, and how do they work?

Cross-platform for mobile app development is software that allows you to create applications for various systems (e.g., iOS and Android) with the use of one language and one codebase. Thanks to this, you can avoid working on two independent applications on two different platforms.

Benefits of near-native technologies

Code reusability

Near-native technologies give you something that no native language (Java/Kotlin or Objective-C/Swift) can – up to 70% of the code can be shared between platforms. Jackpot! In effect, with frameworks like Xamarin, React Native and Flutter, you get two mobile apps for the price of one. This is probably the most important advantage of the near-native approach. The remaining 30% is platform-specific code, which is a pity – but even though we can’t share everything, it is a huge time and money saver.

If you plan to create a mobile app for all main mobile platforms, a near-native solution can cut cost almost by half.

Similarity to native apps

In contrast to hybrid applications, where the entire UI runs on WebView – the main cause of performance bottleneck and rendering issues – near-native uses native components that gives the look and feel of a native app. This literally means that they are practically identical in appearance and speed. As a user, it is unlikely that you will notice the difference between near-native and native.

Faster development

Performance is not the only thing that matters – production time is just as important.

If you work on an Android or iOS native app, you know how much time is wasted waiting. Every time you change the colour, font size or a spacing you need to wait 10 – 30 seconds to see the result. This is even more time consuming if you are working on a screen which is far from the launch screen. You’ve got to click on the same path again and again to get back to the future you work on. Not exactly efficient, right?

Most near-native technologies solve this by implementing a mechanism called hot reloading, which keeps the app running and saves the screen you’re on while only updating the actual changes in the code. This nifty solution makes a huge difference as it shortens the time between saving the file and the seeing result to 1 or 2 seconds.

Cheaper maintenance costs

In the case of native apps, you have to be prepared for double maintenance cost. It’s a very simple equation. If you have two codebases, one written in Java by one team and another written in Objective-C by a second team, you can be sure to face twice the number of bugs compared to having one codebase for two platforms.

Fewer bugs + fewer developers needed + less time used = more money in your pocket.

Greater market reach

When designing native applications, you may come across issues with limited coverage. The effects of your work will be available only to a specific group of users – using only Android or iOS. Multi-platform solutions allow developers to bring one program to the market for different systems, thus strengthening the user base and their reach. Wider audience reach translates into the easier distribution of applications and more effective marketing activities.

Platform Consistency

Cross platforms for mobile app development are extremely user-friendly. For developers, one technology will be faster to learn than several dedicated to different systems. They will have many solutions at their disposal to create comprehensive tools.

Intelligent cloud solutions

Most mobile app development multi-platforms are based on cloud technologies. Thanks to this, such software can be conveniently integrated with ready-to-use plug-ins, allowing, among other things, to improve the aesthetics of the interface or the functionality of the application, giving it additional value.

Drawbacks of multi-platform solutions

Lower performance

Still, there are some cases where native development is a better choice. I would even say that there are cases where cross-platform mobile development is not recommended. Even though near-native solutions have great performance capabilities, there are apps that demand cutting-edge performance, for example 3D games and apps that use technologies like augmented reality (AR). This is a field where cross-platform technologies can’t compete – for these kinds of apps, near-native performance is not enough. Native simply has optimal performance and gives the user a smoother experience.

Long wait time for new features

Another benefit with native development is that you get access to new features faster – when an SDK (Software Development Kit) is released, you can just add it to the codebase and it’s ready to go. With cross-platform mobile development, you have to write a so-called connector (bridge) to the native part of the app, or wait for the community to do so.

Native mobile app development is like a Ferrari. Photo by Matt Antonioli on Unsplash

Harder code design

Mobile app development multi-platforms need to be adapted not only to specific devices but also to different platforms. This generates additional work for developers who have to troubleshoot various exceptions in the applications' operation. The most complex functions require special attention. Such obstacles do not exist with native applications.

Poor UX and UI design

This is probably one of the biggest drawbacks to cross-platforms for mobile app development. Using the same codebase for iOS and Android does not allow you to reach for built-in functions provided by devices, so the user experience can be much poorer. More possibilities in this regard are provided by separate codes in native development.

Integration problems

Mobile app development multi platforms make it difficult to integrate the application with local settings, notification options or user preferences. This sometimes generates the need to use external cloud software, which lowers the security level of the program.

Coding difficulties

Contrary to appearances, the use of one codebase does not have to facilitate work on applications. It can be especially difficult for novice programmers. Namely, they have to comply with several different cross-compliance requirements. This, in turn, often contributes to delays and problems in the operation of the application.

Why cross-platform is still our preferred option

So am I saying that native development would always be the best option, if money and time were no concern? Actually no – it’s not just about how fast the technology is, but how fluently the end-product works. Would you buy a sport car like Ferrari just to cruise around the city? Sure, you can do that. It will have great speed capabilities, but you wouldn’t have the chance to use that speed and wouldn’t really need to. A Toyota will do the job just as well. There are plenty of great apps that have no need for top speed. Every app project has to be evaluated on its own terms.

And in any case, the experience and skills of the developers will always be more important than performance gaps between technologies. I have seen many great and not so great apps done in both technologies. At the end of the day, it comes down to having good people in your team. With competent developers, killing two platforms with one codebase can produce excellent results.

Cross-platform mobile development comparison: Xamarin, React Native, Flutter

That’s all good, but which framework should you use for the best result? The short answer is that it doesn’t really matter, at least for now (June 2019). Xamarin, React Native and Flutter are all fantastic technologies which can be used to produce stunning mobile apps.

Of course they are different in terms of amount of sharable code, performance, tooling, maturity, number of libraries and community size. If you want to dig deeper, you will find plenty of articles on the subject. In my opinion there is no strong leader in this race yet, but the situation is dynamic and could change in the near future.

As for now, if you have competent JavaScript developers, React Native is the most natural choice. If your developers know C#, Xamarin would be better. Flutter will probably fit both, just with a slightly steeper learning curve.

I’ve already mentioned this above, but I think it is worth to say it again: Which technology you choose is a detail. It is the experience and skills of the app developers that makes a difference. With good people, you get good results.

The future of near-native technologies

The future of near-native technologies looks bright. Big players heavily compete with themselves in this field. They invest enormous amounts of time and money to convince businesses and developers to use their products. That’s very good for the mobile world – healthy competition always ends with the best possible results for the users.

Where will the mobile race end? It’s hard to say, but one thing I know for sure. A common language makes everything easier for everyone: Businesses, developers and users alike.

More about cross-platform mobile development

Read more in part 1 of this article here: The bumpy road to cross-platform mobile app development

Co-author and editor: Anja Wedberg