Apple App Store and Google Play Market were both created in 2008. In 10 years, the number of apps available on both platforms skyrocketed to 5.8 million. These numbers are difficult to comprehend, and they may sow doubts as to whether your idea of a new app is worth a try.
Spoiler alert: it is. The vast availability of smart devices will keep the demand for mobile solutions high. But to succeed, you still need to work on the strategy and remember the significance of using software testing services.
At the initial stage, you will need to decide what mobile platform to focus on — Android, iOS, or both. On the one hand, there are more Android users in the world. On the other hand, iOS users spend more in stores. While Android apps are easier to maintain, iOS promises cheaper and faster development. There is a compromise: cross-platform mobile development — a chance to create a hybrid app that is suitable for all platforms.
The choice of the platform depends more on product strategy than OS peculiarities. Nevertheless, this choice influences development and testing. Let’s figure out how native and hybrid apps are different and how this difference affects mobile app testing.
Native & Hybrid: What’s the Difference?
Let’s start with a position that isn’t in the center of attention today, namely a web-based app built on HTML5 and CSS. Most users know it as a mobile version of a website that appears in a browser. You cannot download web-based apps from stores or install them on your smartphone. They don’t have access to device resources (camera, location, sensors, etc.).
A native mobile app is a different story. It is created for a specific platform, usually Android or iOS, as these are the most popular ones. Developers use a programming language that suits a particular platform. The apps for Android are written in Java and Kotlin, and for iOS — on Swift and Objective-C. Users cannot install Android apps on iOS or vice versa.
A hybrid mobile app is a mix of native and web elements. It takes the best of both (and maybe some of the worst) and becomes a universal app that users can install on any smartphone. So how is that possible? A hybrid app is basically WebView in a native shell. It still uses HTML5 and CSS but now disguised inside a native shell. You get a universal code that can fit any device.
What Type of Apps Is Better?
Whenever asking this question, remember that there is no universal “better” solution. It always depends on the circumstances: your business goals, budget, and expectations, in particular.
Hybrid mobile app development is faster and cheaper since software engineers don’t have to write two sets of code. It is a seemingly perfect scenario for start-ups. But — there’s always a “but” when something sounds too good — hybrid mobile apps are more prone to catch bugs and malfunctions.
Meanwhile, native apps proved to be fast, responsive, and reliable. But they take more time to develop and more effort to support. There are always two sets of code to write, review, and fix. That requires more time and more people to work on the tasks.
The good news is that there are examples of successful and not-so-much solutions in each category. For instance, LinkedIn decided to shift to native versions since it couldn’t cope with memory issues and visual quality. Skype still manages to surprise as a hybrid application, but Microsoft finds it challenging to handle bugs and errors. At the same time, Instagram uses HTML5 and WebView without problems.
Multi platform app development software is becoming more and more popular. In particular, Xamarin, React Native, and Appcelerator allow developing native-like apps without giving up UI quality and affecting UX. A hybrid app can be a good idea for the product launch. Later, you can decide whether to replace it with native apps or leave as it is.
Hybrid Mobile App and User Experience
There is a reason why I’ve mentioned user experience in the previous paragraph. Hybrid apps often come with a quite controversial UX. Developers often have to choose between speed and quality, and they opt for the former. That’s when involving QA resources becomes essential than ever before.
Hybrid apps usually look like custom websites. It is difficult to code an astonishing interface for every platform since using a shared base puts some restraints on the adaptivity. The code may be universal, but the adaptivity isn’t infinite.
As graphics are less accustomed to an OS than they are in native apps, making it look natural may take effort. For example, you have to align all headings the same way, adjust all elements to look okay on both platforms. Making it perfect for one OS can be a disaster for the other one.
Differences in Test Strategy
So how does it all affect test strategy? Firstly, mobile QA specialists have to focus on UI, UX, and performance testing more than usual. Poor performance and interface are among the top reasons why users uninstall an app. And both of these issues are on the list of cons of a hybrid mobile application.
Secondly, the scope of tasks would be different for native and hybrid apps. For the former, you need to test either Android or iOS functionality. The latter requires testing an app on both. Device fragmentation gets vast, and there is a broader scope of work to handle.
How to Test a Hybrid App
QA team needs to view a hybrid app as a wholesome system, addressing both types of elements collectively. So when QA engineers have to test a hybrid app, they can later apply this same strategy to native app testing, but not vice versa. Now, the specific points of testing a hybrid app.
- You will need to differentiate native and web objects to test each category properly.
- Keep in mind that native objects interacting with HTML5 elements may behave differently than if used with native objects.
- Web objects can introduce additional issues that influence an app — from breaking layout when offline to creating severe security breaches.
- Hybrid web objects often have problems with performance.
- Test automation services may take more time to arrange as scripts cover broader functionality.
There are also some common points for both types. Native and hybrid apps are both tested in terms of functionality, compatibility, localization, and of course, performance and usability. Both require attention to the following details:
- diversity of operating systems, including OEM’s custom skins, and screen resolutions;
- consistency of UI elements (toolbar, lists, checkboxes, etc.) across target platforms;
- different network conditions, especially for lite versions;
- interaction with third-party apps used within an application (keyboards, etc.);
- addressing bugs on each platform shouldn’t interfere with platform synchronization.
Common Points for Hybrid and Native App Testing
Underlying technologies used in native and hybrid apps differ, but the functionality they provide is the same for both types. It’s like QA outsource and an in-house team: there is a difference in logistics for clients, but in no way it affects the quality of work.
Thus, cross-platform development introduces some nuances in testing, but the approach will be very much the same, just like testing types. There are universal tools for testing native and hybrid apps, too: Selendroid, Appium, Calabash, UIAutomator, and more.
I won’t go into detail describing each level of testing but briefly explain the basics about types of testing mobile apps undergo. You can read more about mobile app testing in one of our blog posts.
#1. Functional testing: all app features work as expected
The check usually starts from simple actions, like install/uninstall functionality, and then gets more precise. Some of the essential things to cover are on the list below:
- the use of built-in resources — camera, location, sensors, etc.;
- researching app behavior during interruptions — phone calls, messages, push notifications, etc.;
- testing an app on different screen orientation modes;
- smooth flow of payment transactions;
- the correctness of error messages.
The list is far from full, but you get the idea. We need to make sure the features work as supposed, and it doesn’t matter whether a native or a hybrid mobile app is in the spotlight. Hybrid apps only require more attention to click zones — CATs, buttons, links, etc.
#2. Compatibility testing: the code in different environments
Now, you are going to find out if your code is truly universal. Compatibility testing is about running an app on various devices with different OS, browsers, screens, etc. Two main areas to focus on are UI and functionality.
#3. Performance testing: facing the popularity
You expect the app to be commercially successful, right? A flawless performance is one of the main contributors here. Thus, prepare for the expected demand and emergencies.
- Load tests gather data to define the performance indicators, like response time, system capacity, etc. to make sure the system responds to the criteria stated in the documentation.
- Stress tests estimate system reliability and steadiness when the load exceeds an expected rate.
- Spike tests analyze the app behavior when the load bursts for a small amount of time.
- Soak tests determine whether a system can handle an extended load without significant deterioration in user experience.
There is more to this — recovery, failure, resilience, volume testing, etc. All these types of testing estimate different aspects of performance, including speed, response time, reliability, resource usage, and scalability.
The performance of hybrid applications is often a matter of concern, as shared web technologies inside a native shell are less responsive compared to native elements. That’s why it is significant to check the maximum number of usage conditions.
#4. Connectivity testing: going online and offline
I won’t say all applications are network-dependent today, but many of them are. Some apps behave differently in online and offline environments because they are meant for online only. Other apps activate different features for different modes. Take into account the following conditions:
- bandwidth variations;
- poor network connection;
- no network connection;
- loss of signal.
If an app doesn’t work offline, users should see corresponding notification after opening it, but not interface errors or database corruptions.
#5. GUI testing: the things on the screen
So as you remember, a WebView introduces additional risks for native apps. Due to the wide variety of target devices, the layout might look better on some of them and not so good on the rest.
But testing a native application also requires less preciseness. When it comes to Android alone, the diversity of screen resolution is already astonishing. With iOS devices on top of that, testing becomes more challenging as the scope of work extends.
My advice would be to stick to a simple design during development. Unify all the elements based on the compromise between Android and iOS design.
#6. Localization testing: diversifying the markets
Apps aren’t always developed for a single country or area. And if your application is relevant for an international audience, keep in mind that people may not know the language you set as default.
Besides, localization goes beyond translation. People use different metric systems, time and date formats, etc. Some write and read from right to left — not the way you’re reading this text. So a QA team needs to consider these aspects during testing.
To Sum Up
Functional, connectivity and localization testing for hybrid and native mobile apps don’t differ much. Compatibility and GUI testing usually require more resources for testing hybrid apps due to the variety of devices to check. Performance testing is a bit different for hybrid apps since mixing native and web elements isn’t always seamless.
You can start a project faster if you decide to go with cross-platform app development. If you aren’t 100 percent sure whether to shift to native versions later, try to find specialists who can test both types of applications. It is better if a QA team stands by your side from the beginning to the release and support stages. And if you have more questions on mobile app testing, feel free to contact QA Madness.