Before You Build: Technology Considerations for Creating Your Mobile App

Introduction

When you look at all the benefits of mobile apps, it’s easy to make the decision to invest in creating one. But once you have, you need to figure out the “how.” The performance of your mobile app––and your success at realizing those benefits––will depend entirely on the decisions you make before you build it. Let’s walk through the different mobile app development approaches available, various popular platforms and tools on the market, and how to decide which ones are right for you.

Which approach and framework will you take?

There are two basic approaches you can take to building your mobile app. The first option is to build it natively using the frameworks provided by the device manufacturers. Android’s software development kit (SDK) uses Kotlin, and the iOS SDK uses Swift. With this approach, you design your app twice (at least), as there’s no shared code between the two. Producing and maintaining two separate native apps may be costly, but it’s the best way to offer the full benefits of a native app experience. Of course, you may choose to build for one mobile operating system and forego others, depending on your intended audience. For instance, given iOS users spend twice as much as Android users on in-app purchases, it may make sense to create an iOS-exclusive app.

The second approach is to use a cross-platform framework that enables you to code once for both iOS and Android. The use of cross-platform frameworks has become increasingly popular because of their efficiency and low cost relative to native app development. However, the final product may not perform as seamlessly or leverage the full range of device-specific hardware functionalities.

A closer look at cross-platform frameworks

If you choose cross-platform development, there’s no shortage of frameworks available to choose from. Here are just three of the most common frameworks used today.

Developed by Facebook, React Native is the most popular cross-platform framework. With React Native, you write the code in JavaScript and the framework embeds a JavaScript interpreter in the iOS or Android application. It’s even possible to use React Native to code for the web. The drawback to that flexibility is that you potentially water down the native app experience. To mitigate this, React allows writing components for a particular platform, but doing so means you lose some of the “write one, use many” benefits. In real practice, a hybrid approach—where 80% of UI is shared code and 20% is platform-specific—is often a good compromise.

Another potential drawback to using React Native is its underlying architecture. A single JavaScript thread executes your application code and business logic and decides which components or views need to be drawn on the screen. To update the screen with the new or changed presentation, React must communicate screen updates through a bridge mechanism to the native application UI thread, which can only perform one draw task at a time. While React allows asynchronous component rendering requests on the JavaScript thread, all view updates must still be passed to the UI thread and rendered on the screen one at a time. This means that out of the box, you must take care to avoid large, long-running, or frequent UI updates. If not, queued draw tasks will create a UI rendering bottleneck which can lead to a slow and unresponsive app experience.

Single-threading is not an issue for the other two cross-platform frameworks we’re covering: Xamarin and Flutter. Xamarin is backed by Microsoft and uses C# and .NET. It produces better performance on iOS than Android because it uses transpiling for the former and a pseudo interpreter for the latter. Flutter is backed by Google and is written in Dart. What makes Flutter unique is its ability to generate native code using Ahead-of-Time compilation techniques. As a result, apps built with Flutter tend to deliver the best performance across all operating systems.

Both Flutter and Xamarin allow for multi-threading, which avoids some of the performance issues that come with React Native. However, React Native offers the lowest barrier to entry and allows you to code in JavaScript. And while Flutter produces the most performant app across platforms, it’s harder to find developers who know Dart.

Questions to ask yourself before you build

Each approach and platform come with its own pros and cons. To weigh them out, assess your vision, budget, and resources.

> What skill sets do you have on hand?

If your internal resources will be supporting your mobile app, examine the skill sets of your current developers. Are they more proficient in C#, or Java, or Kotlin? It can be difficult to vet and hire programmers skilled in a language different than that with which you’re already familiar.

> What matters most––your budget or vision?

Are you most concerned with ROI? If your mobile app is just one of many of your company’s revenue sources, then it’s better to go the cross-platform framework route. You’ll only need to hire one development team and vet them for one language. It’s the fastest path to widely distribute your mobile app, and the cross-platform frameworks still provide a high-quality experience.

On the other hand, if you have a specific vision of how your app should look, feel, and operate on each mobile device, then it’s best to write it natively. You’ll have two different development teams writing in two different languages, with two different SDKs and two different sets of best practices, but you can deliver the exact experience your users want and expect.

The challenge with this approach is synchronizing the mobile app’s feature set and functionality with business processes on the backend. For example, processing an order should look and feel the same for store employees, regardless of the buyer’s operating system. This may be costly, but for online-only businesses with which customers primarily interact via mobile apps—think DoorDash or Uber—it’s critical.

Keeping the UI simple, even when the app is complex

No matter how complex your app is, the UI needs to be as simple and “fat-finger-friendly” as possible. That means minimal typing and simple interfaces that are as close to native navigation as possible. For example, in iOS, action menus are triggered by swiping up from the bottom of the page. In Android, action menus are triggered by tapping the three-dot “kebab” menu icon.

The more complex actions your app can perform, the more important it is to provide a consistent, intuitive UI. To give users a consistent, familiar experience, it’s important to build in platform-specific features like these as much as possible. That means you must take care when selecting third-party or open-source components, as the styling and behavior might be inconsistent with native controls. (This, by the way, is one of the drawbacks of using React Native’s “write once, run many” capabilities.)

Don’t rush the decision-making process

As you can see, there’s a lot to consider when you’re creating a killer mobile app. We advise our clients to not skimp on this part of the process before they dive into designing and building their apps. Once you’ve chosen a platform and a language, it’s really hard to change it—and who wants or has time to start over again from scratch?

Want to learn how to create a high-performing mobile app? Watch our on-demand webinar, Tapping Into Mobile Apps For More Profitable Revenue, to learn how to build an engaging, competitive app that drives higher revenue. Need help creating and launching your mobile app? Contact us to see how JBS Custom Solutions can help.