Picking the Ideal Mobile Tech for Maximized ROI

Flutter, Kotlin Multiplatform, or Native?

David Kovacs

David Kovacs


06 September, 2023

Cut right to the chase...

native development
kotlin multiplatform for mobile

Choosing the right mobile technology setup is a decision that can significantly impact the trajectory of your business. It's a choice that holds the power to either streamline operations and boost ROI or introduce unforeseen constraints and compromises that may lead to costly maintenance and hinder the expansion of your product down the line.

In an ever-evolving landscape of mobile technologies, making the right choice isn't always straightforward. At Supercharge, we understand the complexities and challenges that come with this decision. In this article, we would like to guide you through the labyrinth of mobile tech options and empower you to make a well-informed choice. In order to simplify the decision-making process, we summarised the pros and cons of the most promising technologies available today.

But that's not all. To provide you with the most tailored guidance possible, we've gone a step further. We've developed a comprehensive survey that assesses your current product and future plans. This survey acts as a compass, helping you navigate through the intricacies of mobile technology selection. By understanding your unique needs and goals, we can assist you in pinpointing the mobile technology that not only aligns with your vision but also maximizes your ROI by cutting your costs.

Your business deserves a mobile technology solution that not only meets your immediate requirements but also sets the stage for long-term success. Join us on this journey as we explore the choices before you, analyze their strengths and weaknesses, and ultimately help you pave the way to a more cost-effective, efficient, and prosperous mobile future.


Native development

First, we will examine the default of mobile software engineering: native application development.

Going native entails creating an application that is specifically designed for a mobile platform (typically iOS or Android) using a programming language that is native to the operating system.


The most widely supported language for a given platform may change as programming languages continue to evolve, but, except for brief transitional periods, there is usually a clear choice at any given moment. iOS went from Objective-C to Swift, while Android moved on from Java to Kotlin.

The Pros of going native are plentiful and compelling:

  • Performance: The most performant applications are built with native technologies. Your code runs directly on the device without any intermediary layers, utilizing it to its fullest capacity. The result? The shortest loading times, buttery-smooth screen transitions, and high-fps, jitter-free animations. (Of course, this assumes proper coding practices.) In terms of high-end user experience, native apps still reign supreme. In certain cases, this can make or break your app; in others, it's less important as utility takes precedence.
  • Limitless hardware access: You have full access to the OS and device capabilities. Need to leverage an obscure mobile sensor that most people have never even heard about, such as a barometer? Going native is your best bet. 
  • No innovation bottlenecks: New SDK features released by Apple and Google can be leveraged instantly, allowing you to incorporate the latest technology into your app as early as possible. With cross-platform technologies, it takes some time for the freshly baked SDK functions to become supported.
  • It's not gonna get more secure than native: Native solutions are more secure because they do not have hidden dependencies, meaning there's no need to use 3rd party code to keep cross-platform code running. While the latest cross-platform technologies (such as Flutter and Kotlin Multiplatform Mobile) aim to lower the number of dependencies, React Native, for instance, is infamous for coming with over 500 dependencies. Nevertheless, every cross-platform solution requires a significant amount of extra code to make the framework run, and it's not viable to continuously monitor the exact content of this layer, which occasionally gets updated by the contributors of the framework.
  • Easy access to all the ready-made accelerators: Third-party SDKs and libraries are likely to have native versions. As native development is still the de facto standard for mobile software engineering, most companies prioritize releasing their SDKs to fit easily into a native app. The same goes for all the great libraries - pre-made software components that developers use to avoid reinventing the wheel for every new project. While it's possible to use these components with cross-platform frameworks, it usually requires significant extra work.
  • Size and gravity: Native development has the longest track record and is still the most popular with mobile software engineers. This means there is the biggest available talent pool and a huge community to find answers to questions and resolve technical impasse.

But as with most things in life, there are compromises involved. Let's see the cons of native development:

  • The 2x cost formula: We can’t list too many cons for going native, but we have to start with the elephant in the room: it's expensive. Almost twice as expensive as certain cross-platform solutions. Why is that? Native development refers to software engineered specifically for a target platform. Therefore, if you have multiple target platforms, you will need to develop a separate application for each one. This means that you will need a completely different software for each platform, with every line of code being different. Since most mobile apps intended for larger audiences need to be accessible on both Android and iOS, this usually means that two separate apps need to be developed. 
  • More coordination & more interdependencies: Delivering to multiple platforms not only doubles the cost, but also requires more coordination. To maintain feature parity across all platforms, careful planning and seamless alignment between platform teams is necessary. Additionally, continuous quality assurance (QA) is required for both platforms.
  • Building and Maintaining Two Teams: To develop for each platform, you will need two fully functioning mobile development teams.

Is native development the solution for your product?

verify it with our survey


Secondly, we will examine Flutter, the current cool kid of mobile development that everyone is talking about. “Could it be the tool to slash our development costs?” The same question is being asked by startup founders noodling in converted warehouses and C-level decision makers pondering in glass-panelled boardrooms.

The driving force behind Flutter is Google, which wanted to ensure it had its own contender in the race for the dominant cross-platform solution. With the range of possible devices steadily growing (think foldables, wearables, TVs, AR/VR devices) there is more and more reason to think that the future is cross-platform, as any other options seem increasingly uneconomical.

Flutter is one of the new-gen cross-platform solutions that promise close-to-native performance while offering more secure foundations than React Native.

In this article we focus on the business benefits of using a development framework, so let’s just lightly touch on Flutter's engineering essentials. It is based on Dart, a relatively obscure Programming Language by Google, and Android Studio as its development environment. All this makes it easier for Android developers to transition into Flutter development, but even for folks with a background in iOS, it feels much more “mobile development-like” than the JavaScript-based React Native.

The Pros of Flutter Development

  • Reducing Development Costs by up to 40%: Flutter is a full-fledged cross-platform mobile development technology. This means that you only need to build one software to launch your app on both Android and iOS. In an ideal case, this can cut your development cost by 40% compared to creating two separate native applications. You may be wondering why only 40%, where has the other 10% gone? Well, it goes towards implementing unique platform-specific functions, like Apple Pay on iOS, deploying to the platforms, and performing quality assurance for both final apps. However, keep in mind that Flutter is not the ideal choice for every use case. If you need access to multiple system SDKs, various hardware capabilities or envision very resource-intensive functions, your 40% savings can easily disappear while the developers work to implement these features within the framework's limitations.
  • Close to native performance: Without getting too technical Flutter uses C++ to draw the UI on a virtual canvas. C++ is a compiled language, which means it is already translated into machine code that the CPU can run directly without any extra on-the-fly calculations. This results in a very fast and responsive user interface. Although it still can't perfectly match the performance of a fully native mobile application, it comes pretty close. On high-end mobile devices, it can even achieve the coveted 60 frames per second animation performance - that smooth and buttery feeling that human eyes enjoy so much (Some newer devices even have 120Hz screens, only native apps will take full advantage of that with 60+ FPS animation speed - but most people will never notice such a subtle difference).
  • Very secure by cross-platform standards: When working with cross-platform SDKs, additional code is required to run the framework. The developers of the app need to take over this code wholesale from the framework developer, and it often requires updates. This introduces dependencies and security risks, which significantly increase if these dependencies are scattered among multiple libraries. This is the main reason why we recommend Flutter over React Native. While RN comes with over 500 dependencies in small modules, Flutter keeps it in one single package, making it much more secure. Nothing beats native apps in terms of achievable security, but Flutter gets as close as possible.
  • Support of a big and growing community: Flutter is massively popular right now and the number of developers mastering it is steadily on the rise. This makes it easy to find talent, support, and information to resolve challenges during implementation.

The challenges and possible compromises when going Flutter:

  • The lack of pre-built components can slow down the work: Flutter is still a relatively new technology and as such there aren’t that many 3rd party libraries available for it. To avoid reinventing the wheel for every new project developers rely heavily on ready-made libraries. When there is no available Flutter-specific library developers need to spend extra effort wrapping and modifying native libraries to make them work under the framework.
  • Larger app size: It is less and less relevant, but for specific target groups it can be important - Flutter apps take up more space on devices than their native counterparts.
  • Nothing is as secure as native: While Flutter aims to minimize the number of dependencies, it's still a cross-platform technology, adding plenty of extra code to the application. This is an acceptable risk in even the most secure industries, nevertheless, native is still the king of security.
  • Nothing is as smooth as native: As we outlined above Flutter is extremely performant. Still, native apps run without any intermediary frameworks and that makes their User Interface performance unbeatable. 
  • Google could theoretically pull Flutter’s plug: Flutter is a development framework created by Google. It is theoretically possible; however, this is an extremely unlikely scenario as the platform is thriving and Google seems to be heavily invested in it. Even if this were to happen, it wouldn't necessarily mean the end for Flutter - Google created Flutter as an open-source project, and given the enthusiasm around the technology, there is a decent chance that the community would continue to support it. Still, you ought to know this.

Kotlin Multiplatform
for Mobile

Lastly, we will examine the Kotlin Multiplatform cross-platform framework, which is often overlooked in business decision-maker circles despite its compelling value proposition. However, we expect this to change soon, as Kotlin Multiplatform strikes a perfect balance between native development and cross-platform savings. In our recent client evaluations, it often emerged as the optimal candidate, ticking every box.

Kotlin Multiplatform is a broader initiative aimed at creating cross-platform solutions that can bridge the gap between different platforms, ranging from web to various device-specific platforms, but here, we will focus on its mobile-specific capabilities.

This platform is the brainchild of JetBrains, a Czech company that may not ring a bell for everyone, yet it's the formidable force behind essential components of the Android ecosystem. They've crafted tools like Kotlin, now the official language of Android. Not surprisingly Kotlin is at the core of this cross-platform solution, offering engineers an experience that feels refreshingly native.

Kotlin Multiplatform offers a unique proposition among cross-platform technologies: everything is cross-platform except for the User Interface.

This ingenious solution saves significant time because the business logic, data models, and integrations toward backend services don’t need to be written twice for both mobile platforms, while the UI remains in native code. The result is substantial savings and an entirely native mobile experience. Truly, it's the best of both worlds.

Of course, it is not the best choice for every product, as you will see after reading the list of pros and cons.

The Pros of Kotlin Multiplatform

  • Kotlin Multiplatform offers up to 35% savings on development costs compared to native mobile development. Although the cost savings from using Kotlin Multiplatform may be slightly lower than Flutter, they are still significant. Since all layers below the UI are identical for both platforms, developers need to write less code. The more complex the application's underlying logic, the greater the savings.
  • There is nothing that feels like native… except Kotlin Multiplatform, that does! Users will never be able to tell that there is any cross-platform technology in use here. The UI layer is written in native code, so it feels and performs identically to a fully native app. There are no compromises here; Kotlin Multiplatform is perfect even for the most polished B2C experience.
  • Streamlined development process. Android developers can seamlessly transition to writing the shared code for a Kotlin Multiplatform app.

Like any cross-platform technology, Kotlin Multiplatform Mobile comes with some compromises, but very few this time.

  • Not the right fit for every challenge. If the application heavily relies on UI with minimal code in underlying layers, there is minimal potential for saving by using Kotlin Multiplatform.
  • You need to write the UI layer separately for both platforms in Kotlin Multiplatform. While Kotlin Multiplatform's main advantage is a fully native UI experience, it also presents a disadvantage. Writing the UI separately for both Android and iOS platforms requires having both Android and iOS developers on the team. Realistically, the cost savings potential is capped at 35%, whereas Flutter could go as high as 40% due to the shared UI. This is a dilemma that requires a careful weighing of benefits and costs. It is worth noting that JetBrains is working on expanding the platform to enable sharing the UI code as well. However, this feature is still heavily in beta and is not a viable option for now.
  • Kotlin Multiplatform will get its official release soon. Kotlin Multiplatform is a mature, stable, and secure platform for mobile development. We can attest to this statement, as we have used it in multiple complex mobile products with very satisfactory outcomes. However, JetBrains has not yet released a final version, so technically it is still in beta. Not much longer though: the final release is promised to still be in 2023. According to the company, little will change until that point. Therefore, in our assessment, Kotlin Multiplatform is already capable of powering your app.
Some of the major technologies we evaluate: Flutter, Kotlin Multiplatform for Mobile, Native Mobile Development

As we wrap up this exploration of the pros and cons of Flutter, Kotlin Multiplatform, and Native development, we hope you've found this summary both informative and enlightening. Making the right choice in mobile technology is a pivotal decision, and we believe that understanding the strengths and weaknesses of each option is the first step toward success.

However, we understand that your business is unique, and your path to ROI optimization may have its own distinct twists and turns. That's where our comprehensive survey comes into play.
If you have any doubts or seek personalized guidance tailored to your specific business needs, we invite you to take our survey. With your input, we can provide you with a well-informed recommendation that aligns perfectly with your vision and goals.

Still in doubt? Get a personalized recommendation!

take the survey now