Do you know there are 2.89 million apps on Google Play Store and approx. 1.98 million on App Store? But only some of them could make a large impact on market.

Have you ever thought why those applications are much more successful than their other competitors though they are a lot similar?

We often forget the fact that there is a very thin line between building successful apps and unsuccessful apps.

It is that some apps are just perfect in terms of functionalities and features, while others are trapped by some common mistakes. Sometimes, developers make such silly mistakes that can make a headache to the user to use their application.

This differentiates the successful apps from the unsuccessful ones.

If you are successfully avoid these common mistakes in your android app development, then kudos to you 👏! You can make profit worth your hard work.

---

1. Try to Code Too Early

• Before you actually code the feature for your application, you must spend some time with copy-pen to brainstorm and research, what you are going to build.
• For high quality content or bug free code, should follow this flow:

Think. Research. Plan. Write. Validate. Modify. Code.

• Continue this flow till you think you have enough planned and brainstormed the feature, then you can move to IDE for actual code. By following this technique you can reduce a lot of your efforts and can write a bug minimized code.
• But take care that not to plan multiple features at once. Simply plan a feature and try to implement it.
• Improve your Googling skills to make a proper research about your feature and can find a systematic approach to tackle the problems you may face while implementing that feature. After finding solution, just not copy paste the code but try to understand the science behind the code.
• Question again and again, is your existing code works better and research about the code to the depth. Beginners usually assume their code good since it seems to be working. And they might be tempted to repeat that bad practice elsewhere.

2. Un-organized Code

One of the most common and biggest mistake that every second or third developer made while developing a project is to writing code in an un-organized manner.

Organizing code is just like tidy up your room. You can still live in your room without tidy it up everyday, regardless how messy it is as long as you tolerate it. It only haunts you when you desperately need to find something that you haven’t touched for a while.

Organization of the code becomes far more important when your team size increases. Poorly organized code wastes the time of anyone who has to read and understand it. For that reason most companies that are serious about software have coding standards which are intended to make maintenance of their code easier.

I have worked on a project 5–6 months ago and I was also among those second or third developers, now today it is nearly impossible to me to get how all of the code I had written works. This means that I have to go back and read the complete code to refresh my memory and it will be a lot easier if I have kept the code well organized.

To read about how to organize android projects, see this

3. Unaware of Android Studio’s capabilities

Well, it doesn’t matter how strong and powerful a weapon is until and unless you learn how to use it correctly and properly.

There are various useful and powerful features in android studio, such as Visual Layout Editor, Fast Emulator, handy shortcuts, coded templates for addition of new activities, predefined project structures, and code generator plug-ins.

In addition, the Android Studio also offers support for a newly popular and a very strong and powerful language for android development-Kotlin and a monitor editor to deploy effective transitions and animations in a much better way.

Android studio helps to connect with a cloud database Firebase in a easy and effective way. Studio provides gradle and maven support to help developers to use third party libraries for their applications.

Android app developers should be skilled in using android studio and other powerful tools, like Github, to build a robust android application no matter whether you are solo programmer or working with your team.

4. Making User-Interface complicated

Developers usually make their application’s user interface complicating, whereas the user interface should be simplistic and user-friendly.

Android apps having a better user interface have received immense attention and a number of installs.

Some qualities of a user friendly interface are:

• Fast loading screens

• Themes and colors matching your application’s main goal

• Ads that are non-intrusive to the consumer’s experience

• Use images and animations

• Easy registration process

5. Integrate Features in Bulk

Usually developers try to integrate a lot of features rather than focusing on a few and gaining expertise on them. However, in reality, successful apps tend to have fewer features but they do perform well with those limited features.

It is suggested that developers should focus on few top-notch features rather to integrate those ones which are not even used and not making any importance to the consumers.

It is totally understandable that you want to engage your customers with your mobile app. But this doesn’t mean you have to bombard too many features that are rarely used by the users. This mistake will confuse the user and will make the task more complicated by looking heavy.

Mobile application users take no time in uninstalling the app once they find out that it has too many features which are futile. So, to prevent this scenario, you must identify the main features that are necessary to keep the essence of the app.

6. Waiting for Network Request to complete

Well, we all know how to handle long running tasks ( like uploading and downloading files, database queries, etc.) by showing some loaders and progress bars to the users.

But still users have to wait for completion of their tasks because it is not completely sure that the network request will be successful as there may some network failures, data may not processed efficiently, or may be due to internet issues.

But successful network calls are far more likely than unsuccessful ones. So why should we wait for the server’s successful response? It is definitely a better approach to assume success of the network request before the completion of our queries and handle failures if occurs.

Let suppose you are using a social media app and think about the user experience when you have to see a progress bar every time on liking a post.

It is far better to show the user that the post is liked just after clicking the like button and if any error occurs then notify user by handling network calls in background.

In modern app development it is not a better approach to make your user wait unnecessarily and however, people also not want to wait. This unpleasant user experience can reduce your number of installs.

7. Not Handling Errors and Network Failures

Most of the projects are large and complex enough that are maintained by multiple programmers. That’s why there are almost always possibilities that the project leads to some kind of software bugs.

If you handle your errors, your app will likely continue to function after an error, your customer can likely continue working, and you can provide a report of exactly how the bug occurred so you can fix it.

Another big reason that error handling is so important is security! Some kind of errors, can put a program and the underlying operating system in a vulnerable state if not handled properly. Handling errors must be a deliberate and well thought out process because even when handled gracefully, errors can write to log files or splash error messages to the screen that supply potential attackers with very valuable information that they can use later to take advantage of specific vulnerabilities.

That’s why error and failures handling is an important task of any project development. If you keep ignoring the failures then whenever your app caught any error then it will be almost an impossible task for you to debug that error.

Also not handling errors in a user friendly manner makes a bad impression of your app that can leads the user to uninstall your app.

So keep in mind to handle each and every possible error and failure in a user and developer friendly way.

8. Not using Kotlin-Coroutines

Kotlin has been introduced as most popular, powerful and recommended language for android app development by Google.

There is a very strong and powerful feature of kotlin, Kotlin-Coroutines.

With the help of coroutines we can handle long running and time consuming tasks in a background/worker thread which can reduce stress from the Main Thread.

The main thread has a single purpose to keep the user interface responsive. Performing too many tasks on main thread can cause blocking of the main thread due to which your android app may stop responding with a crash message. These may lead user to frustrate, which tend to give very negative feedback.

So, to keep your app responsive and work smoothly, it is suggested to keep main thread of your application free which can be achieve using Kotlin-Coroutine.

Just like threads coroutines can run in parallel and also coroutines are so cheap that you can create thousands of them without any memory issue.

9. Bad UI/UX

This is not a mistake but a bad practice in a user’s perspective. Android apps having a better user interface have received immense attention and a number of installs. So it is highly recommended to improve your app’s user interface for a better user experience.

Some points to include in improving UI/UX

• Handling Bitmaps

  An image always helps in better understanding rather than plain text. Images are extremely nice content, mainly due to their property of conveying thousands words per image. But they also consumes a lot of memory.

  Let’s assume you have a picture of 4000 X 3000 pixels to show ( consuming approx. 4 bytes * 4000 * 3000 = 45.7 MB )

  It’s to much memory (45.7 MB of RAM) for just showing a single image!

  Now if we consider screen resolution then to show an image of 4000 X 3000 image on a screen that has 1920 X 1080 pixels, we need only 4bytes * 1920 * 1080 = 7.9 MB of memory.

  To perform the above task:

• First measure the view in which the image is going to show
• Then scale / crop that large image accordingly
• Show the scaled image

Learn more about handling bitmaps here

• No use of fragments

  To launch a separate activity for each app screen may be inefficient because the system will keep them in memory as long as it can.

  To overcome this problem Android introduced Fragments a while ago in Honeycomb.

  Assume fragments as separate building blocks with their own life cycles inside an activity that can be managed by their parent activity and can be reused again.

  Fragments are also useful when you are developing an app for both phones and tablets.

• Not using motions, bitmaps and animations

  Bitmaps or images, animations play a vital role when it comes to attractive and informative UI in a user’s perspective.

  Animations can add visual cues that notify users about what’s going on in your app. They are especially useful when the UI changes state, such as when new content loads or new actions become available. Animations also add a polished look to your app, which gives it a higher quality look and feel.

  Read more about animations here

10. Not Testing the Application efficiently

This is the most common and silly mistake developers usually made during developing application though it is the most important phase of developing an application. That’s why this should be the dominant task for the developer.

Testing before delivering the application to the client is much more essential as it guarantees the quality of the software. Thoroughly tested software ensures reliable, security, and high-performance which leads to time savings, cost effectiveness, and user and client satisfaction.

Also it is easy in future to add new features if the older application is well tested and organized as removing or editing the older code is too much terrifying.

Points to keep in mind while testing

• Do not test the application with only single device, this could put you in trouble when you release your app for public. It is possible that some features work smoothly on one device and stop responding on another device. So test app on multiple devices (as many as possible).
• Test application on devices with low memory, different screen resolutions, older versions of OS. Using this practice you can capture bugs in a depth in features as well as in user interface of your application in a broader way.
• Test features, which are making network request, more carefully (like, test by making internet connection weak or turn OFF) to ensure handling of network failures efficiently.
• Test as much as possible before delivery of the product.

---

Summing up….

There are plenty of opportunities in android app development, by that you can capitalize and make your own market, provided successfully avoiding the above mistakes.

Thank you for reading 🙌🏼

Be conscious and keep coding😀