You might be surprised to find out that some of the most frequently googled questions about Android programming are: Why is Android app development hard? Why is Android development so complicated?
However, with enough knowledge, working on an Android project doesn’t have to be more difficult than any other kind of app. While there are a lot of things to keep in mind, with the tips in this guide, you can make the Android development process more seamless and manageable.
Before development begins, validate and refine your business idea
Whether you're developing an app for a client, the company you work for, or your own startup, your business analysis of the product idea is either a game-changer or a deal-breaker. What are the problems you’re trying to solve? Who are your customers? What’s the value proposition? What’s your business model? What are the essential features of your app intended to meet customer needs?
No matter how good the UI/UX is, how much time the developers worked on it, or how much capital was invested on it, any product won’t be successful if it doesn’t solve real problems. There are several frameworks that can help you validate and refine your product idea such as the business model canvas or the lean canvas. Processes such as scoping sessions will help you assess the real scope of your Android project and create initial estimations.
Choosing the technologies right for your product idea
Before jumping right into a project’s technical requirements, it’s critical to plan properly for the project, including your application’s functional requirements. This includes the app’s features, the dependencies between these features, the general idea about the most important screens, and so on. Prepare an implementation roadmap of the app’s features. All these will make the planning and estimation of your project something more than pure guesswork.
On the technology side, remember that Android apps today are mostly written in Kotlin. However, it’s good to have a development team that knows Java. While Kotlin can integrate with Java code without a problem, they need to be able to understand what’s going on under the hood.
Further, Android developers can now choose between writing UI in XML or Jetpack Compose, the latter being faster and easier. Everybody knows that XML is an old technology, and it seems that Google will eventually stop supporting it.
Google appears to be leaning towards Jetpack Compose, but it’s still quite a new technology, which makes it harder to find a team with adequate experience. In addition, you should also have developers with experience in Kotlin Coroutines, which is the best solution for asynchronous tasks, instead of RxJava, its outdated peer.
System versions to support
Selecting the system versions you want to support is one of the most important decisions you need to make as it affects how you’ll develop your Android project, and it will be extremely difficult to change course later on.
This comes with some caveats and that it still depends on the type of your application. For instance, for fintech apps, you only need to support newer versions because older Android versions lack the most recent security features that keep user data secure. In another example, because Huawei devices don’t support Google Play Services and Play Store, it might also be a good idea to add support for Huawei AppGallery.
All these important details and distinctions come from the nature of the Android market being highly fragmented. It's practically impossible to give users all the latest features and maintain a broad device support at the same time.
In effect, the more platforms you need or choose to support will mean extended development time. Some features might need to be coded specifically for each of your chosen versions. It’s the responsibility of your development team to know and explain the differences between the versions your app will support.
Tools and services
The crucial part now is to decide where your data will come from. Today, almost all applications use connections with the backend. Hence, you should think about your use cases and if the application requires external sources. If so, there are two options for your development to consider: REST or GraphQL. After this, decide if your app needs internal data storage and whether your app will be online or offline first.
To speed up the development process, it would also be wise to select external services with mobile in mind. Some solutions offer easy-to-use libraries, which can quickly integrate many features. Firebase is a good example of this as it offers crashlytics, app distribution, remote config, A/B testing, and cloud messaging, among others.
Once you select the services right for your app, it will take a significant amount of time to set them all up properly. In most cases, developers will spend a lot of time on preparing separate sets of authentication keys (needed to integrate external services and APIs) for staging and production environments, creating multiple configuration files, and registering test users and devices.
Managing the development process
After a thorough analysis of your product idea and choosing the right technologies in building it, you should concern yourself next with the project management of the development process. If you break your project down into smaller and more manageable tasks, it will be easier to oversee all the work, track what has been done and what still needs to be done, and handle unexpected problems.
Further, the development process should be led by a competent Android project manager, who will be responsible for creating a development plan and delegating tasks.
Agile project management with JIRA tickets
All tasks should be stored in one place so that you can continuously track your team’s progress. In my experience, the best tool for project management is JIRA. Developers who are heavy users of JIRA know that every feature should have its own epic, to which tasks for views and business logic could be added.
Further, ticket description, business value, and feature description in every epic is a key for a seamless development process. JIRA does all of these well because it provides a broad range of tools to visualize progress and plan future work.
One consideration for you to remember is that Android developers prefer a clear division between "view" and "logic" tasks. Make sure your PM is aware of this.
This division has several consequences:
- It’s easier to control the development rate.
- View tasks are never blocked.
- It’s easier to review the code.
- Layout XML files are big. Writing layouts and custom views in XML can take a long time depending on the complexity. Moving to Jetpack Compose can reduce that time
- The code on mobile is more interconnected than web front-end.
- It helps to separate the presentation layer from the data layer.
Designing for Android apps
Nowadays, designing a beautiful app is just as important as keeping your app responsive and free from bugs. From the range of apps that solve the same problem and offer the same functionalities, the user is more likely to choose the one whose interface is the most intuitive and looks best. Regardless of whether you’re going to develop a professional business app or a game, you need to make your app’s design one of your top priorities.
Of course, these two examples — a business app and a gaming app — will differ in what makes for a good design. A game will have fun graphics, whereas a professional business app will need to look clean and smart. “Fun” designs for a business app will not be received as professional. If your company or product team doesn’t have an experienced app designer, make sure to engage a professional in order to deliver a UI that will delight your users.
Another important thing to keep in mind when designing for Android is this idea of “not Android enough”. When you plan an app to be run on both iOS and Android, the initial designs are created for one of the platforms — typically for iOS.
While this is a common practice, developers know well the downsides to this approach. One platform supports some solutions and UI elements while the other doesn’t. If your design follows the Material Design guidelines, your team can work faster and deliver an outstanding design no matter the platform.
However, some UI widgets, even when they follow the Material Design guidelines, can extend development time. Bring this up with your PM in advance so you can work on some solutions to save time and return to your initial ideas if ever you have some spare resources. A case in point here would be replacing a scrollable calendar view with a date picker.
Overseeing the Android development process
Considering all of these, even if you don’t have a technical background, there are some things that you should monitor during actual development, particularly your team’s version control system (e.g. tools such as Continuous Integration and Delivery Platform) and the system for logging and crash reporting.
The code that your development team produces should be versioned under Git and later pushed to a remote version control repository such as Github. Version control makes it easier to keep track of changes that they make in code. When something goes wrong, they can always restore the last working version.
In addition, a version control platform makes coding easier when more than one developer is working on the project. It makes the decision-making process more efficient, especially when encountering problems that have more than one solution.
Another reason for version control is code review. Someone who works on the project and has a deeper understanding of it can make a review of the commits that are part of Pull Request. Developers working on the project will need access to the code so as to make changes and review other developers’ changes. There’s no other way to achieve this other than a version control system.
Tools and platforms
Version control can work miracles for your project. To increase the chances of your app’s success, you need to use various tools and platforms that make the development process more effective and efficient.
Here are some of the most important ones:
- Github: a version control system
- Bitrise: a Continuous Integration and Delivery <CI/CD> Platform
- CodeCov: a reporting tool processing coverage reports
- AppCenter or Firebase App Distribution: a service for app distribution and logging crash reports
- Firebase Crashlytics: a cloud-based platform for aggregating events and crashes
For new developers, getting familiar with these and setting it up requires some time, but it will surely pay off, making the development and maintenance of the project a breeze.
Testing your Android app
Testing is a must-do step, irrespective of the kind of app you build. First, nobody wants to launch a buggy app, which will push your users away. If you deliver a bad experience to your users as a first impression, they may never go back to your app. The other important reason in testing your app is to avoid regression. When developing new features, you should always make sure that changes won’t break the existing code.
Make sure that the developers working on your app also write unit tests for business logic and instrumental tests for layers depending on the Android framework. Tests are written to ensure that the crucial elements of the app work as intended. They test the logic of the app.
For example, our process in Netguru looks as follows: First, developers write automated tests that cover the most important parts of the application. Then, test suites are run on Bitrise, and reports are uploaded to CodeCov. A short report is also attached to every Pull Request on Github.
Read our brief guide on how to successfully test Android apps to help you understand this process better.
Other aspects that need to be tested are the app’s appearance, design, and UX. In Netguru, we have qualified QA specialists who are also part of the mobile development team. They not only verify whether the application’s design corresponds to the initial designs, but they also try to act like a typical user and tweak the app to suit their needs better.
Tests must also be performed on all supported system versions. Some features will either not be available or act completely different on some platforms (and even with a different Android launcher installed on the user device).
Also, because nobody has control over what Android devices emerge on the market and their screen sizes, we use "density-dependent" units to position our layouts. It means that we tell devices how to display certain things only in approximation. Most of the time, it works out really well.
However, to ensure that the app will be properly displayed on all devices (which doesn't always mean perfectly), a QA needs to test it on Android devices with all possible screen sizes.
After releasing to the app store
Android development is quite demanding. Developing apps for Android differs from developing apps for other platforms because the Android market is fragmented. Hence, what you do after the release of a Play Store app could be almost as important as the development process.
It’s very essential for your app to have a clean, well-written, and well-documented code, which needs to be easy to maintain. High-quality code will make it more manageable to introduce corrections and react to user feedback after launching the app.
This is why it’s better to engage an agency to do this for you as they generally have a predictable development process, a solid knowledge base, years of experience, and fully scalable teams of Android developers who will already know the code of your app and understand your business idea.