One of the most important decisions in mobile application development is the framework and tools you will use to build it. The options available can be divided into four main categories—native application development, cross-platform app development, low-code app development, and no-code app development.
The right decision depends on a number of factors, including the skill set on your team, the purpose and long-term vision for the app, your timeline, and your budget. As a general rule, we strongly support native and cross-platform app development in most cases (although there certainly are some very simple use cases where a low- or no-code approach may suffice).
In an effort to help guide you down the path to success in your next mobile app development project, we have compiled a breakdown of the pros and cons of each application development method. We suggest using this as a starting point to guide you towards the best decision for your next project.
The platform-specific approach: Native application development
A native mobile application is a piece of software built in a specific programming language for a specific device platform. Both Apple and Google promote this method as the preferred approach for building mobile apps.
The two primary platforms for which to build a mobile app are:
- iOS—Previously, native mobile apps for iOS were written in Objective-C, but now Swift tends to be the preferred programming language.
- Android—Java has historically been the programming language of choice for native Android apps, but Kotlin has recently seen increased usage.
There are several advantages of native mobile application development:
- Both Apple and Google provide software development kits (SDKs) and tools that make it very easy to build apps that look and feel “at-home” on their respective platforms.
- A mobile app built using the native SDKs will typically handle OS updates gracefully. For example, native controls in a user interface (UI) that was built with Apple’s UI frameworks will simply inherit a new look and feel that has been introduced in a future version of iOS. Ideally, this will avoid any required maintenance stemming from OS UI changes.
- All features available in the specific OS you are developing for are immediately available. There is no need for intermediate frameworks to “catch up” before the new features are made available to developers.
- Mobile apps written in native code typically produce the most optimized code. This advantage becomes increasingly important for apps that are more performance-intensive.
- The native approach is the path that requires the fewest intermediate, third-party layers in the app development process.
The disadvantages of native mobile app development are:
- You have to develop for each platform separately. If you plan on deploying both an Android and iOS version of your app, your developers will have to spend extra time rewriting code in two different languages, recreating user interfaces with two different SDKs, and so on and so forth.
- The above disadvantage often results in companies using two different teams of developers. Why? Typically, an experienced iOS developer is rarely also equally experienced in Android. So, if you want both platforms to have quality apps, you need different people with expertise in developing for each platform.
- Since the use of two development teams is often necessary, it can open the end product up to potential variances between platforms as development progresses. For example, each development team may make different ad hoc decisions about the UI/UX during implementation. The two teams may also work at a different pace, with certain features and functionality becoming available on one platform before another. Additionally, certain features may be easier to implement on iOS or Android, again creating divergent versions of the app on the two platforms.
- All updates, new features, and bugs will need to be tracked separately across each platform throughout the entire lifecycle of the app. Since each app will be in a separate codebase, supporting and maintaining an app on each platform will demand separate resources. In essence, you will need resources to support two distinct apps.
When to use native mobile app development:
- You only intend to release the app on one platform. (A word of caution here: We have seen clients think they only wanted to develop for one platform and then changed their minds down the road.)
- When the desired feature set for iOS and Android significantly differ from one another. It then could make sense to develop the app natively for each platform. This is not common, but it can happen.
- When performance is extremely critical. Examples include 3D games and apps that perform heavy computations. Apps of this nature process large amounts of data, and a native app can sometimes deliver a little more in terms of performance.
- You already have developers on staff with a lot of native development experience, but little to no experience in cross-platform technologies. You may want to consider native app development in this scenario. However, it may be worth the time and effort to have your team learn cross-platform technologies (or seek out an external team that does).
Two birds with one stone: Cross-platform application development
Cross-platform technologies allow developers to build mobile applications that are compatible with more than one operating system (iOS and Android) with a shared codebase.
Popular cross-platform frameworks include:
- Xamarin
- React Native
- Flutter
- Apache Cordova
Our favorite is Xamarin. Xamarin “Native” (i.e., the original iteration of Xamarin) allows code sharing of back-end and business logic code between platforms, while still creating the UI layer separately for each platform.
Xamarin Forms adds support for a shared UI layer that abstracts out the most common types of controls, while still supporting OS-specific differences and custom implementations when needed. Xamarin Forms sits on top of Xamarin Native. We have found this framework offers the right balance of code-sharing between platforms without sacrificing near-total control of low-level native details when needed.
Cross-platform application development brings many advantages to the development process. Specifically, it:
- Opens the door for code reuse. You can write code once and use it on both platforms.
- Shares a single code base for both iOS and Android.
- Allows you to use the same development team between platforms.
- Unifies the app features across platforms, so you avoid the issue of unintended divergences between the two platforms.
- Can track bugs singularly, across both platforms. Additionally, fixing a bug on one platform will usually fix it on the other platform.
There are, of course, also some disadvantages of cross-platform application development:
- If you want the UIs to be different between iOS and Android, you may have to spend extra time to differentiate them. However, a good cross-platform framework (such as Xamarin Forms) will simplify this process.
- If performance is a priority, a cross-platform framework can sometimes add extra intermediate layers that may slow down performance. This tends to be more of an issue with the Javascript tools (React Native and Apache Cordova) rather than the compiled tools (Xamarin and Flutter).
- Cross-platform frameworks add in a “middle man,” which does open up the risk of becoming dependent on external partners. For example, you may find that certain OS features aren’t available in your chosen framework due to a lack of or delay in application programming interfaces (APIs) support to access them.
When to use cross-platform application development:
- When you want to deploy both iOS and Android versions of your app (today or any time in the future).
- When the feature set for both platforms is identical or significantly overlaps.
- Overall, based on our experience, there are actually very few scenarios where we would recommend native development over cross-platform development using Xamarin Forms.
- You really do get all of the performance and aesthetic benefits of native development with the added developer efficiency of code reuse and simplified development flow.
The citizen developer friends: Low-code and no-code application development
Low-code and no-code application development tools are meant to streamline the application development process. They also enable non-developers to get involved in the process. So, for example, the marketing team could use a low-code tool to complete the bulk of application development and only bring developers in to address issues not covered by the low-code tool’s out-of-the-box capabilities.
With a no-code tool, you wouldn’t need a developer at all. Of course, this limits what you can create.
Low-code tool examples include:
Popular no-code tools include:
Low-code and no-code application development tools typically promise:
- A faster application development process
- A lower cost
- The ability to include non-developers in the app creation process, thereby increasing the engagement of business stakeholders
But there are also a number of disadvantages of low-code application development:
- While you can add custom code to low-code apps, you will be limited to the extent to which you can customize things. Low-code tools are designed to remove the complexity of the app-building process, but the flip-side of this simplicity is sometimes unwanted constraints.
- Low-code apps may not integrate with all of the external services your app requires to function, so you need to do some homework first to make sure the low-code tool you choose supports all required integrations.
- You are now dependent on another third party vendor to continue updating your app. If the company that owns the tool disappears, what happens to your code and your app? The answer to this question varies per vendor, so be sure to find out before you make a selection.
When to use low-code or no-code application development:
- You have a tight budget.
- You’re not extremely particular about the end product or your app is extremely basic. In this case, low-code or no-code may work for you.
- You want to generate a throw-away mockup or prototype. In this use case, you would only use the low-code tool for the prototype phase and then move to a more sophisticated method for full-scale development.
- You don’t want to hire developers at all and don’t have any in-house. If you just have a designer or product team member who wants to manage the app without requiring any specialized development skills, a low-code or no-code solution are likely the only options.
The best of both worlds: A streamlined cross-platform approach
In many cases, companies are drawn to the low-code or no-code approaches simply because they are faster and cost less. But, as you can see, they limit your options and can result in a product that is less likely to meet and exceed your users’ expectations.
We strongly believe in the cross-platform approach, and have recently focused our efforts on ways to maximize the efficiencies in cross-platform development to make it even more beneficial for our clients. Our streamlined cross-platform approach substantially levels the playing field when comparing cross-platform to low-code development. Our efficient cross-platform approach allows us to give our customers the efficiency gains you would typically get with low-code without taking on its limitations.
Here are just a few examples of how we have streamlined the cross-platform app development process.
Pick the right platform
If you pick the wrong platform, you lose the benefit of the time savings you reap from code reuse. We have found Xamarin Forms to offer the best balance of SDK capabilities, code clarity, good tooling, and full control over all elements of our application, but we still keep a constant eye out for new platforms that may strike a better balance.
Learn the platform inside and out
Learning a new tech stack for each project is inefficient. When you have a team that can put previous experience to work on a new project, it yields fast wins. All members of our app development team are well-versed in our platform of choice and have deep experience we put to use on every project.
Establish a library of commonly used controls
While tools such as Xamarin Forms and Flutter provide many of the most commonly used controls and capabilities, there will always be gaps that often require rewriting on almost every project. Placing these in a reusable and shareable format adds even more efficiencies to future cross-platform projects.
Gain intimate knowledge of the most popular and capable third-party libraries
The open source community provides a large number of libraries that can fill gaps on app development projects. We stay up to date on what’s available, so we don’t waste time reinventing the wheel on every project.
Set up a “bootstrap” project to jump-start development on a new one
Almost every app development project starts with the same initial stage of setting up common dependencies. A “bootstrap” project template speeds up this initial phase (and ensures we make use of the wise decisions we made on previous successful projects).
Our years of experience and deep skill set has allowed us to streamline the cross-platform mobile application development process and pass numerous benefits on to our customers. As a result, we can deliver the advantages of cross-platform development and a more valuable and successful mobile application while staying competitive with the promised cost and speed of the low-code approach—making our unique cross-platform development approach the best path to mobile app development.
