How to choose a mobile app development approach for your next project
The world of mobile app development is vast. Every day you see more articles flashing by about Flutter, React Native, Ionic, Kotlin Native, etc. You might even have heard about Progressive Web Apps, blurring the line between websites and apps. Furthermore, the languages Swift and Kotlin for native iOS and Android development keep improving and extending. With this wealth of information, it can be hard to actually make a decision on what tools to use for your next project. All while it is quite important to choose the right one.
This is not a guide to push you into a certain framework or language, but rather to help you make an informed decision. After all, all the popular tools available have their pros and cons. The approaches might even have different use cases, ever heard the phrase “you don’t need an app, you need a website”.
Step 1: determine what is important for your project
Every project is different and therefore every time you need to reconsider the toolset to use for that specific project. The first step is to determine what is actually important for your project. You should list each property and divide ten points among them, in order to rank them for importance. Below is an example of a list of properties for a big project for a big client.
- Future proof (3/10). The client intends to use this application for many years. The tools should still be available and maintained by then.
- Knowledge availability (2/10). Multiple developers will work on the project and it will be maintained for several years. It’s unavoidable that changes will occur in the team and it’s therefore important that we can find developers to replace ones we lose.
- Speed of development (2/10). We want to test a minimal version of our app as quickly as possible, to validate the business needs.
- Performance (1/10). While modern devices are fast and modern frameworks are quite performant, we still find it important that our app is responsive and the user experience seamless.
- Availability (2/10). Our app should at least be distributed to both the App Store and the Play Store, but we embrace opportunities for other distribution methods.
We now have identified the important properties and divided 10 points among them. Next, our research starts.
Step 2: research the approaches in light of the chosen properties
This is the hardest part of the process. A lot of the properties are probably subjective and/or hard to determine. Like always when committing to a framework, there are risks involved and you just have to minimize this by doing as much research as possible. Also, it is advisable to research as many approaches as possible. Time invested now is time (and headaches!) saved later. To avoid making this article too long, I will only list three approaches for the example case, namely native (Swift and Kotlin), Flutter and a Progressive Web App (PWA)
Native
Since Native development is closest to the actual operating system running on the devices and it’s best supported by the vendors of these operating systems, It has long been the absolute winner when comparing approaches. Since it’s maintained by the vendors of the devices you want to distribute on, it’s definitely future proof and performant. Also, most mobile developers available in the market will have experience with at least one of them. However, with this approach, you need to develop two separate applications, one for Android and one for iOS. If you want to support even more operating systems, you would need to make even more apps. Hence, the speed of development goes down drastically. With the native approach, you can easily distribute to both the App Store and Play Store, but not anywhere else.
Flutter
Flutter is quickly rising in popularity, and not without reason. It combines fast development with natively compiled apps, making the resulting app both performant and maintainable. The risk with these kinds of frameworks lies in its continuity and knowledge availability. However, Google is investing heavily in Flutter, which is also an open-source project. The latter means that even if Google decides to pull the plug, the community can maintain the project. Since the app will be compiled to native code, it can simply be distributed to both the App Store and the Play Store. With recent developments in web and desktop support, you get the opportunity to expand to other platforms as a bonus.
Progressive Web App
PWAs are not actually mobile apps in the classic way of speaking, rather websites that behave like apps. Since websites won’t just disappear, this approach is definitely future proof. There are also a lot of web developers available in the market, eliminating the risk of not finding developers. Getting the app to look like a native one with web languages might be more work than with Flutter, but still faster than native, since you only need one codebase. Performance is probably slightly lower, but not noticeable on modern devices. PWAs can not be published on the stores, but are to be discovered and downloaded via mobile web browsers. Also, support for iOS is limited.
Step 3: Score each property for each approach and choose the winner
Now for the last step, we score each of the approaches we researched in step 2 against the properties defined in step 1. Each property gets a score from 0–5.
Native
- Future proof (3/10): 5. Native development will be around, no need to worry about that.
- Knowledge availability (2/10): 5: There are enough native developers in the market.
- Speed of development (2/10): 2: We have to create two codebases.
- Performance (1/10): 5: Native development still has the best performance.
- Availability (2/10): 4: While we can hit both the stores, there is no room for extension beyond that.
Total Score: (3/10) * 5 + (2/10) * 5 + (2/10) * 2 + (1/10) * 5 + (2/10) * 4 = 4.2
Flutter
- Future proof (3/10): 3.5. We can be pretty sure Flutter will stay around, however, it’s not guaranteed.
- Knowledge availability (2/10): 2: Because of its novelty, not many people advertise with being a Flutter developer. However, if you have experience with mobile development, learning Flutter is easy.
- Speed of development (2/10): 5: Only one codebase and a very easy framework to develop with.
- Performance (1/10): 4.5: It compiles to native, has smart UI rendering and runs smoothly on modern devices.
- Availability (2/10): 5: It can be published in both stores and has opportunities to expand beyond that
Total score: (3/10) * 3.5 + (2/10) * 2 + (2/10) * 5 + (1/10) * 4.5 + (2/10) * 5 = 3.9
Progressive Web App
- Future proof (3/10): 3. It will stay around, but the future of support in mobile browsers is uncertain.
- Knowledge availability (2/10): 5: There are enough web developers in the market.
- Speed of development (2/10): 4: A single codebase, but some work will be needed to make it look like a mobile app.
- Performance (1/10): 3: Native apps will be faster in many tasks.
- Availability (2/10): 0: We listed that we want the app on the App Stores, we can not do that with PWAs.
Total Score: (3/10) * 3 + (2/10) * 5 + (2/10) * 4 + (1/10) * 3 + (2/10) * 0 = 3
So, based on our listed properties and weights, we can see that the native approach is the winner here.
Another case
In order to demonstrate that there is no one solution that fits all, let’s define some different properties for another use case where the app is experimental and needs to be validated and developed as fast as possible Assume that there are limited funds for the project and being future proof is less important since the app still has to prove itself. Our properties are now:
- Knowledge availability (1/10)
- Speed of development (6/10)
- Performance (1/10)
- Availability (2/10)
Then, based on our research, we get the following scores for each approach:
Native
- Knowledge availability (1/10): 5
- Speed of development (6/10): 2
- Performance (1/10): 5
- Availability (2/10): 4
Total Score: (1/10) * 5 + (6/10) * 2 + (1/10) * 5 + (2/10) * 4 = 3
Flutter
- Knowledge availability (1/10): 2
- Speed of development (6/10): 5
- Performance (1/10): 4.5
- Availability (2/10): 5
Total Score: (1/10) * 2 + (6/10) * 5 + (1/10) * 4.5 + (2/10) * 5 = 4.65
Progressive Web App
- Knowledge availability (1/10): 5
- Speed of development (6/10): 4
- Performance (1/10): 3
- Availability (2/10): 0
Total Score: (1/10) * 5 + (6/10) * 4 + (1/10) * 3 + (2/10) * 0 = 3.2
So for this project, it is clear that making the app with Flutter is actually the best choice. This demonstrates how you always have to think about what properties are important for your project.
Conclusion
In this article, I have proposed a system to help you make a decision for a mobile development approach. It leaves a lot of room to choose what properties are important for your project, but the important part is that you think about the properties that are needed and don’t just settle for the approach that some random stranger recommends. As a takeaway, remember that there is no single solution for all projects since every project demands different features from its tools.