10 Myths about Hybrid Development (and how to correct them) Last update: 2016-05-26

“Hybrid apps are slow” was possible the first and most often heard argument I encountered when the discussion was about going hybrid instead of native. There was and sometimes still is an invisible barrier of ignorance.

Over the the years I heard or read many quite funny (but sad) arguments that most of the time came from pure ignorance.

This post aims to give you counter arguments for your next discussion.

When you hear one of these points from someone who has clearly just read one article about this topic which said native will always win, you got a chance to convince him to think twice.

1. Hybrid apps are slow

I think this is still one of the most used quotes.

Why does it exist?

Do you remember when Facebook decided that hybrid sucks and that they need to make it native? I think that was something everyone talked about.

Still you can hear the argument that Facebook switched because performance was bad. And yes, they had pretty good reasons to do this, because they are fucking Facebook. But the general app you will develop does not handle nearly the amount of data Facebook does.

Also, the beginnings of HTML webview apps were not as positive as everyone wished and hoped for. They thought “now we get 2 apps for the price of one”, but the other price they had to pay was performance. And many of these people failed some years ago and turned away from HTML5 apps for all time.

And now?

Let’s look at the true facts. Hybrid apps can be slow due to various reasons, but the main reason that influences performance is the device AND the software version which also means the browser. This is a big difference to native apps, so on old Android versions the performance can be really unusable.

But since Android 4.4 the browser is Chromium-based so you can rely on the HTML5 and CSS standards for browsers. Same counts for iOS, where every iOS version increase goes along with a massive increase of performance.

It’s true that you might not (by now) want to implement the next Vainglory using HTML, because these kind of apps rely on heave graphic rendering and should use the most bottom layer you can get to.

But for general apps, the reason of slow performance is becoming meaningless more and more, plus the webview performance will also increase all the time.

If you hear this reason again ask where the opinion comes from. You will for sure hear about the Facebook story again.

2. Hybrid apps look shitty

Another quite common phrase about hybrid apps. Often mentioned with the words “they will never feel native”.

But what really makes an app look good?

If you look around the Appstore ore Google Play Store, you will find a lot of apps that looks like your little 5 year old brother made the design. And many of them will also be native apps.

So the general design of an app lies in conception and creativity of the designer (or not if you are a one man show). And you can reproduce this design whether you use native elements or create your view completely with HTML and CSS.

And what if you can’t get as close to the design as you wish?

Well, in that case you can still use cordova plugins, which are are wrapper around some native functionality. That way you can stay inside your javascript world but still use the platforms native components.

So with more and more options on the webview, the design of a great view should be no problem at all by now. And if you want some examples of awesome looking hybrid apps, just take a look at these:

3. Hybrid apps are unsafe

This one came to me one fine day, and I really had to take a minute to think about it.

Why are hybrid apps more unsafe than regular apps?

I am still not completely sure about this, but I guess this fact came from thinking that using a webview inside an app and also using Javascript which tends to be evil sometimes would be easy to hack and unsafe.

Hybrid apps are as safe as you want them to be.

Stick to the general rules and you can reach the same security level as native apps. Don’t store passwords in clear text on a device. Make HTTP requests over an SSL connection to be sure there happens no man in the middle attack.

Javascript code should always be obfuscated in production, which again reduces the risk of somebody hacking your code somehow.

And finally, your app runs in a container like always. Whether it’s native code or an webview performing some Javascript stuff, the security aspects and concerns are always more or less the same.

4. Build once, works everywhere

A very classic one, love it. Most of the time a sentence managers and people who only just heard about hybrid apps have in mind.

Have you ever heard this?

The image and idea of this is great, but it lacks reality.

When we think about using web technologies inside an app we hope to benefit from the lessons learned of web development. But in fact we just encounter more problems along the way.

Device fragmantation, screen sizes, power of those devices and different operating systems are just a starting point. On top we have different webbrowsers that sometimes shit on the CSS we define. Or just don’t know yet about that function.

Yes you will safe time to show it everywhere. But a 80% design solution on all devices is barely a solution given the level of most apps and expectations of users.

So if you hear this one again, just encounter with a better option of saying this: ”build once, optimize everywhere“.

5. Building hybrid saves 50% of the development time

Very close related to the last one. And also quite as true as the last.

How often have you heard that one in a meeting?

Throwing up a cool number that sounds great is always effective for marketing, but when it actually comes to developing stuff, this number will change dramatically.

The general idea is pretty simple: Someone has read that you can create 2 apps (iOS + Android) with just one single codebase. The result is, that you obviously need 50% of the time you would normally need to develop 2 complete apps with 2 codebases!

Where is the problem with this?

Well, if you have ever developed a hybrid app you will most of the time test your code changes always in the same environment, for me it’s most of the time iOS because it’s faster. So you build your functionalities, views and everything looks great on my device.

Then I start it on Android and the app does by no means look or behave like it should. Why?

Those 2 systems behave different in so many ways. They use different browser engines which host our application. They use various screen sizes, densities and everything that potentially could break your layout. The cordova plugins to use the native functionalities might not work the same on both platforms. And the list goes on and on.

So yes you get a better maintainability, as far is your code is clean and structured. Future changes need to be made only once (but also with potential to be special for iOS/ Android).

But the result is definitely not 50% the time of developing 2 native apps.

You got all the specialization for iOS and Android, you got a lot of unforeseen problems by doing everything with HTML and Javascript, you might need to tweak performance issues, and finally you might even write your own cordova plugins if there is no wrapper for the functionality you need.

All of these tasks take time, and for some it’s hard to predict how long it will take so you can have a huge risk factor in your calculation. This might even end up in doing 100%+ in time if you get stuck on some showstopper.

So if anyone again pulls up this number, decide whether you simply laugh and leave the room or maybe better) tell them the true facts about this myth.

6. If you want a five-star app, build natively

I think this one was from a forum, and the underlying assumption is: You can’t create a hybrid app that truly looks & feels native.

Is this true?

Well, some years ago I would have probably agreed with this. But technology evolves and most of the reasons for un-native behaviour can be eliminated using the right technology stack and coding guidelines.

Today, there are in fact so many apps that you won’t even recognise as hybrid, and many of them have great reviews. Just take a look at the Ionic Showcases to see some of them.

The thing is, this fact can become true if developers don’t know what they do and create the reason for bad performance or UI.

You can create bad hybrid apps today, yes. But you are responsible for that, not the technology!

Also, if you think of a game like Vainglory, I have a really hard time imagining how this would look and feel using a hybrid technology. So as already said sometimes, if you rely on realtime 3D engines or stuff like that, I think it’s still better to do it native.

So in the end again, this myth is coming from a true case some years ago where you could clearly see if something was native or not. But today is different and you can blur the lines almost completely to produce an app that looks, acts and feels native although it’s a webview.

7. Just make our HTML5 website responsive and you got an app

The thoughts around this one seem to slightly shift today, but it’s still there some times.

This came up some years ago when everyone said they needed an app.

Why not simply make our website responsive and your ready?

Well… A responsive website on a mobile device and a hybrid app will most of the time be different pair of shoes.

It is true that a responsive website might look ok or even good if you throw it into an app container. But it’s still just a website, and people will feel it.

A website has a very different UI concept then a mobile app, and there are slight differences that make an app look and feel great that you just don’t have on a website.

This comes from the fact that mobile devices have a lot smaller screens, so information and the flow of action has to be aligned to the size, the position of someones hand, what’s really important on the screen and so on.

It’s definitely recommend to have a responsive website, and this can also be the starting point for a hybrid app. But please, let some UX designer take a look at your app and ask them about comments.

In the end, and app is not always an app. If you don’t care about what the user thinks ok, but if you want a good feedback let the transition between OS and app be as smooth as possible, use the device functions and style guidelines for a platform.

This is the only way to transform a existing website into an app.

But most of the time I recommend it’s better to draw out the most important features of a website, reduce them, and focus on what the user really needs. Then craft a great app around that use-case and you are far better of.

8. “You won’t be able to implement this feature”

When it comes to talking about risk, this is an often brought up opinion.

Is it really impossible to implement some features or functions?

Yes and no. As said before, I would totally agree with this if you plan some graphic intense game with a lot of CPU usage. In that case, just go native.

But in all the other cases where you want to create a app even with native functions, there is a way to solve it using hybrid technologies.

There are already tons of great cordova plugins, and you can always feel free to create your own plugin if you need to! It’s not that hard.

So in fact, there is no real showstopper most of the time - but first of all experiencing problems with the way you could do it hybrid and then finding a solution using a cordova wrapper for some native code can take time.

This is a risk as well, and you should always estimate these points prior to the development of your app.

9. “performance was abysmal on older devices”

Let’s be honest, we all heard that one before, right?

It makes me kinda mad to counter this argument. But I try to keep calm.

First of all, there are 2 sides of the medallion: iOS and Android.

So for iOS, this problem does almost not exist. The performance even of older the devices is fair enough, and the fragmentation of the OS is so small that most of the time >90% will have the newest iOS version and therefore also a very good browser engine (where our hybrid app relies on).

You will barely experience any problems on iOS devices ever, so let’s keep those out of the discussion for now.

But as the image already indicates, for Android the landscape looks differently: A lot of different devices using any kind of OS version and often old stuff.

Why is that a problem?

Well, before Android 4.4 the browser engine was kinda bad and won’t get you good results. But everything newer will be better, and so do the capabilities of the devices increase. Like with iOS, you won’t experience problems with newer Android devices and versions.

Now another catch: You can bundle your own browser (Crosswalk) with Ionic Framework apps!

By doing this your app get’s a lot bigger, but you can be sure your app runs on a solid and stable base, which is enough to fix the problems we had some years ago.

So while many people have experienced this myth, the truth is that it’s slowly disappearing. Browser, devices and also our languages and options get better to easily overcome these issues and make it a pure phrase in the future.

10. “hybrid still sucks. webview apps should all die.”

This last one is meant to be a bit funny. I read this response in a Reddit thread about my Airpair article Switching from native iOS to Android: Why Hybrid doesn’t suck (anymore).

Still, this case displays another group of people: Those that just hate everything besides native.

What is the problem of these people?

It’s hard to say, but the biggest reasons might be a) they have had really bad experiences with hybrid apps in the past or b) they just don’t want more people (all the web developers) to come into mobile development which was their own field for years now.

Either way, it will be very hard to convince this group and to have a serious discussion about facts. If you meet them in real live, just try to show them positive examples. And not all web developers will be mobile developers in the next years, the web is still important.

If this doesn’t work, just try toignore them.

That’s the reasons I did not answer that comment on Reddit.

Final Words

Time’s have changed, so has technology. While hybrid is in some parts not on the level of native development, it already is in more then a lot areas. I am sure the battle native vs. hybrid and also vs. web will continue in the next years, but on whatever side you are just do your job good.

And stop flaming the other side, they are developers too.

If you want to try out something new, give hybrid a chance starting with the Ionic Framework.

Cheers, Simon