Top 15 Mistakes Even Experienced Android Developers Make

Android has been a rapidly-growing OS lately. It’s leading by the market share, is backed up by tech giants like Google, and offers developers an extensive range of tools do make everything possible on mobile. 
Naturally, when building something as complex and segmented as an Android app, developers tend to make mistakes. Here are the 15 most popular Android development errors even professionals are not immune from.

Top 15 Mistakes Android Developers Make

Mistake #1. Not taking segmentation into account

Creating apps that look good on a developer’s device is a common issue that results in countless UX and UI issues. There’s little uniformity when it comes to Android screen dimensions and color densities – developers need to keep that in mind. 

Here are a couple of useful tips to ensure your next project will look amazing on every device out there:

  • Treat density-independent and regular pixels differently. On a 160-dpi screen, the px-to-dp ratio does not change. However, as screen density changes, so will the ratio. Before working on-screen designs, find out what the dp-px relationship is for most common device types. 
  • Use 9-patch drawables to create stretchable screens. This way, the display of the screen will not change along with the screen dimension. 
  • Use emulators to replicate as many Android devices as possible. Although developers prefer testing responsivity on physical devices, emulation is a cheap and efficient way to see how the screens are displayed on tablets and smartphones of different dimensions.

Mistake #2. Ignoring Intents

Intents are one of the best components Android has integrated. It allows developers to transfer data between different parts of an app or separate projects. 
Creating an Intent takes considerably less time than using permissions and write custom code anytime there’s an action that requires data exchange. Also, as soon as you learn to take advantage of Intents, your AndroidManifest.xml file will be much easier to read and edit.

Mistake #3. Not following the industry practices

In an attempt to create an innovative app, Android software engineers often start dismissing set-in-stone development practices. Before you start coming up with unconventional ways of designing interfaces and back-ends, make sure you’re not missing out on whatever the system has to offer. 

In most cases, no matter how complex the end product is, the blocks it comprises of are quite basic: 

  • Gradle for building most app components;
  • Picasso to enable image loading;
  • Jackson or Gson to parse JSON;
  • Retrofit for network call handling;
  • Common implementation for signing up via social media.
Not following the industry practices

These components empower most Android apps and can empower any innovation – there’s no need to give them up.

Mistake #4. Missing out on asynchronous threads

Although asynchronous threads are not easy to manage (that’s especially the case for Java-based apps), there’s no way for developers to miss out on them. A successful project should be able to perform multiple tasks simultaneously – send API calls, load content, etc. 
Asynchronous threads improve the overall performance of the application and help users switch between actions efficiently.

Mistake #5. Using PC-based interface elements

Desktop and mobile interactions are extremely different since smartphone users have no go-to keyboard and the clicking precision is lower as there’s no mouse to rely on. However, when working on cross-platform apps, teams often fail to customize the Android interface. 

Here are the standard optimization practices Android developers should follow:

  • Avoiding drop-down menu tabs;
  • Designing large elements that are well-separated from each other and easy to click on;
  • Avoiding extensive typing since smartphone users have a lower typing precision.

Mistake #6. Displaying wrong bitmaps

Most apps use visual content – product images, the company logo, or other elements. Major concern developers have lies in reducing the amount of RAM used to load images. Sometimes, the amount of disk space needed to accommodate a single visual file can skyrocket to 50 MB. 

Such high values typically stem from the fact that an Android developer failed to set bitmaps efficiently. Here are the most common mistakes:

  • Not specifying the right size of the image. It’s common for developers to use PC dimensions (4000×3000 px) instead of the smartphone ones (1440×2560 and fewer pixels). Naturally, the larger the image is, the more resources it will consume – by stating the right dimensions, you will reduce the memory consumption exponentially.
  • Not cropping the image efficiently. Finally, when specifying bitmaps, make sure you’re not adding irrelevant details of the image to the frame. If it’s possible to crop the content without making the message it transmits harder to understand, use it.

Mistake #7. Not making the most out of fragments

If you still create separate activities for every screen of your app, it’s time to make the process easier and more efficient by using fragments.

Not making the most out of fragments

The concept was introduced to Android a while ago – essentially, fragments are sets of screens, connected by the same life cycle and located within the same Activity. Here are the main benefits of incorporating them into the development process:

  • Facilitating the optimization process. Fragments offer a built-in resizing toolset and make it easier to adapt the interface to different screen dimensions. 
  • You can manage several fragments at once by modifying their parent activity, cutting the developing time by numbers. 
  • Fragments are reusable, sparing developers the need to write code from scratch and allowing them to establish uniform development practices. 

Mistake #8. Developing with iOS devices in mind

The differences between Android and iOS development don’t only lie in the fact that the operating systems are different. The devices look differently and vary by interfaces. Chances are, the app you are working on right now has an iPhone look and feel and will lack the nativeness on Android devices. 

Here are the go-to signs of an Android app that was developed with an iPhone in mind:

  • Static tabs in the bottom part of the screen;
  • Rectangle app icons (unless they are not the company’s logo);
  • The abundance of splash screens;
  • Lists with carets.

Mistake #9. Skip beta-testing

Letting people try out your app might seem risky – not every developer is ready for negative feedback. However, a software engineer should keep in mind that attracting users is the end-goal – if the app is too convoluted, it will not gain as much following and traction. 

Beta-testing is a source of valuable insights – you can try using the app on different devices and operating systems. Most teams use assistive tools for beta-testing – such as the following ones:

  • Google Analytics;
  • Flurry
  • Firebase Analytics.

Mistake #10. Not updating the app after the release

When the app is released, some developers treat it like a complete project. As a result, they don’t work on harnessing feedback from users, adjust the interface based on current trends, and don’t add features to the tool. 

Assessing every successful app out there, you will notice it’s regularly updated. Releasing new builds helps maintain a steady connection with users, increase the interest in the app. If there are any bugs or security exploits, make sure to resolve these issues when releasing an update.

Mistake #11. Not managing the codebase with Source Control

Backing the code on a flash drive or a local repository is not the safest and most comfortable practice since there’s no way to access the codebase from a different device or without a USB.

Not managing the codebase with Source Control

Using repositories like BitBucket or GitHub is a common practice that improves teamwork and allows to never lose track of code. To use GitHub, you will have to pay monthly membership fees. Bitbucket is free for small teams – up to 5 members.

Mistake #12. Writing strings in code

Hardcoding strings in XML or Java Code is another common mistake in Android development. Although the approach does not lead to functional damage, having to modify the shared text or adding a different language to the app will become increasingly more challenging. 

As a developer starts working on the project, he needs to develop a habit of placing all strings into a strings.xml directory.

Mistake #13. Failing to address memory leaks

Memory usage is highly important when it comes to retaining daily active users. If an app starts gobbling up too much device memory, people will be more likely to delete it. That’s why leaving memory leaks unaddressed is a no-go for developers.

When looking for a root cause of a memory leak, keep in mind that the most common one lies in linking static references to an entire Activity or a Fragment.

Detecting memory leaks on your own is not easy. That’s why most developers rely on tools and libraries, such as LeakCanary, to detect memory leaks. 

Mistake #14. Not customizing the integrated development environment

Failing to familiarize yourself with the IDE is another common mistake novice developers make. Other than knowing how to access the most widely used features, a developer should take advantage of keyboard shortcuts. Other customization steps include:

  • Exporting IDE settings and integrating them into different devices;
  • Configuring the environment for low-memory devices;
  • Using proxy in Android Studio;
  • Set up a custom JVM.
Not customizing the integrated development environment

Mistake #15. Using too much battery charge

An easily-draining battery is a common issue for Android devices. App developers need to take battery usage into account as they build apps. To reduce the amount of energy needed to sustain the project, software teams have to assess how many background operations are occurring simultaneously and remove all the unnecessary ones. 


Android is growing like no other platform out there. With such an impressive development pace, it’s natural that most approaches that are widely used among modern developers will become obsolete in 2-3 years. 

The key to not making mistakes when building apps lies in keeping track of the changes in tools, practices, and development environments. By educating yourself continuously, you will be able to make Android development as effortless and cost-efficient as possible.

You may also like...

Leave a Reply

Your email address will not be published. Required fields are marked *