Android App Development

You’ve got your app idea, you’ve decided which mobile platform to work with first, and you’re ready to get your app into development mode. What steps are next, and who do you need to make it happen?

An important step in finding the perfect freelancer to develop your app is writing the most clear, in-depth work description possible—the more requirements and details, the better. That’s why it’s helpful to know a bit about what goes into Android mobile app development and what skills and technology are required so you know exactly what to ask for, and who to hire.

In this article, we’ll review the Android app development and distribution process, look at Android-specific development environments, and identify the designers and developers you’ll need each step of the way.

Getting Your Android App Designed, Developed, and Launched

Here’s a step-by-step look at the life cycle of an Android application, from discovery and concept through the app submission process.Android Mobile App process

  1. Discovery & research phase

Before any production work can begin on your app idea, a discovery phase is an important first step. By gathering information and nailing down any objectives, you’ll have a clear idea of what problems you’re trying to solve with the project before starting to really firm up the concept. This is also a time to see what else is out in market, identify your audience, and pull together any market research pertinent to the project.

  1. Concept phase

Before the concept phase of your application, you’ll want to have done your research and finalized your objectives and value propositions. Now it’s time to lay important groundwork for your app. With the help of a product manager, this is when you can really refine your idea, get a developer to weigh in on the app’s functionality early on, write up a specification document, and a technical specification document.For Android app development, it’s also imperative that you establish which devices your app will run on, and the earliest version of the Android OS your app will support. Once this is determined, you’ll be developing for and optimizing for those targeted devices and operating systems all the way through the testing phase.

  • Goals: A spec document lays out the business logic of the app, while a technical spec document scopes out the features and functionality of the app. This will help you determine the requirements of the app, and whether or not you’ll need server-side support and integration. (For example, a utility-style app like a flashlight does not require server or database support. A messaging app, however, will.) Common technical aspects to consider include: Do you have a Google Play publisher account to publish the app through? What is the earliest version of the Android OS your app will support? Will the app be distributed to multiple countries?
  • Who you’ll need: A project manager and developer with experience in Android app development, mobile app development in general, and technical knowledge (an understanding of what is required from a coding standpoint to bring an app’s features to life) are needed to size up the scope of the development workload.

For more information on how to write a technical spec document, read our Intro to Technical Specification Documents for Apps article, or to learn more about navigating this phase of your app’s development, read our How to Draft Clear Mobile Design Specifications article.

3. Wireframe phase

Once the tech specification document is written—translating all of the features of your app into specifications for your development team—it’s time to create wireframes. Wireframes act as a user experience (UX) map—demonstrating what a user’s options will be—and an information architecture blueprint, laying out which parts of the site will have what content. A good wireframe hinges on excellent UX as well as user interface (UI) design, so engage a designer at this phase to help think through a natural flow for your app.

  • Goals: Establish and approve what content goes where in your app, its functions, and the flow of the user experience with wireframes. This is the next phase of your tech spec document, demonstrating how the app will come to life.
  • Who you’ll need: A product manager, Android app development and deployment experience, and UX/UI expertise are needed.

4. Design & Software Planning

4a. Design

At this phase, you’ll want to consider a few different angles: creating an appealing visual design (how it looks), an intuitive UI (how it works), and an engaging UX (how it feels to the user). For more information, read our article describing the differences between UI and UX design. Using Android Studio, a designer will create the Android User Interface (UI), including:

The Action Bar. The Action Bar exists in every Android app and does a few important things: it houses the app’s navigation, lets the user know where they are in your app, and includes predictable actions the user might take on each page.

Contextual Menus. These menus—like dialog boxes or floating menus—include more specific actions directed at specific frames within your app’s UI.

Material Design. This is the style of design provided by Android that dictates how elements look, move, and interact with each other. It comprises all the patterns, layouts, styles and animations of your app’s UI. Take a look at the Android Material Design Guidelines for more details information.

Note: The designer will continue to remain engaged into the development phase, as developers may come back with problems or ideas that the designer needs to address.

  • Goals: Create design mockups and prototypes of the Android UI for the development team. This phase is collaborative with the development phase—expect some back and forth between designer and developer. Learn more about hiring a designer in our What Type of Designer Do You Need? article.
  • Skills required: Android Studio, Adobe Creative Suite (Photoshop, Illustrator).

Read more in our Mobile User Interface Design Tools article.

4b. Software Architecture Planning

Scalability is one of the most important things for a mobile application—it has to be written to support growth from the very beginning. “Architecting” an app at this phase is crucial and could prevent you from having to completely rewrite it when it needs to grow. This phase happens parallel to design so you’re ready to kick off the development phase next.

  • Goals: Create a cohesive plan for the software architecture of the app—both the front-end architecture and the back-end architecture. If you’re opting for a back end as a service (BaaS) software bundle, there will still be integration required.
  • Who you’ll need: For smaller projects, one Android developer may be able to create software architecture for an app. For larger projects, you’ll need at least one developer with experience in software architecture—and plenty of expertise with both the front end and the back end.

5. Front-end & Back-end Coding & Integration phases

This is the most complex phase—expect many iterations, with a constant feedback loop between your designer and your developer along the way. At this phase, both the front-end and back-end architecture of your app are built as a coordinated effort. While your app’s functionality is created, its system architecture is getting built. The front-end interface and the back-end server support software are dependent on one another, and the process usually involves a lot of back and forth. On the front end, you’ll be making decisions about how your app’s functions come to life with code—its computing logic. At the same time, any back-end engineering—any server-side components your app needs to run, like a database, APIs, middleware, etc.—are coded and integrated in this phase, linking them to the front end.

  • Goals: Code a scalable app that’s fully integrated to all of your back-end software—the database, mobile APIs, and other related infrastructure it needs to run. If you don’t have the scope to build a server-side infrastructure, you may opt to purchase a Backend as a Service (BaaS) software bundle. These include an array of storage options and features, but they aren’t completely “turn-key”—you’ll still need a developer who understands back-end engineering to integrate it into your app. Also, writing unit tests and running integration testing are crucial steps in this phase. Unit tests will run bits of code within the app software to ensure there aren’t bugs, while integration testing will ensure your backend is running smoothly and doesn’t affect your app’s performance.
  • Who you’ll need: An experienced Android developer versed in both server-side and client-side coding, with an understanding of responsive design, Android’s software development kit (SDK), Android Studio, the Java or Kotlin programming languages, the Gradle build system, server-side scripting, database administration and integration, and server administration.

Terms to Know

Let’s take a quick look at the technical components of an Android Project. First, your developer downloads Android’s integrated design environment (IDE) application from Google, the Android Studio SDK software development kit (SDK). The SDK Manager gives developers access to all the latest tools and platforms required to build the app. A new project is set up in the IDA, which will include an application’s modules (with its source code and resource files) and the following components:

  • Activities. There can be lots of different activities within an app, occurring at different times, each of which gives your users a way to interact with your app. There can be a main activity when your app launches (e.g., log in), secondary activities when you select a piece of content (i.e., getting more details about a product on a product page), and more.
  • Manifest. The Manifest describes the very basic characteristics of your app, defining each component from the ground up.
  • Gradle. There’s a Gradle file for each module of your app, and they make up the code that compiles and builds the app—its structure. Gradle is the official build system for Android, and it’s based on the Java programming language. It’s got a number of application frameworks, test frameworks, and a general-purpose compiler that makes it cross-platform and able to support other languages than Java.

6. Testing Phase

Thorough quality assurance (QA) testing is up next. Your developer will run unit tests, user tests, and run through the Launch Checklist to make sure everything is wrapped up. In testing, your developer will either install and run your app on a device plugged into their machine, or they will run the app on the Emulator, testing screen by screen to ensure there are no bugs and everything works smoothly. They’ll debug the application with the Android Device Monitor and tools available in the SDK. Cover all your bases when you test. You’ll need to test for functionality (does it work well?), load time and handling (does it slow down when traffic increases?), and UX (how easy is it to learn or get used to?). Also, review any crash reports to locate fixes.

  • Goals: Ensure your app runs well on all of the targeted devices and versions of the Android operating system that you’ve built your app to support. This is especially important given the sheer number of different devices and older operating systems Android has running, and you’ll need to test for each. Test your app against Google’s quality criteria, determine content rating, country distribution, the size of the app, screen resolution, and more. Your app should run without crashing, slowing down, or any bugs.
  • Who you’ll need: A developer with knowledge of Android’s latest submission requirements, cross-device testing, knowledge of security and privacy measures, and UX/UI expertise are needed.

7. Preparation, Publishing & Distribution

At this phase your developer/development team is preparing your app for release by assembling a release-ready Application package (APK). You’ll need a Google Play Publisher Account before you can register for a Developer Account. Set up Google Payments if your app will be for sale, or has in-app products. The release-ready APK is optimized, its code is cleaned up, it gets a release key, a final round of testing, then it’s uploaded to the Developer Console. If the app meets all requirements for UI, compatibility, and quality, you’re ready to publish. Publishing is the process that makes your app available to end users—and puts your app live and in the Google Play Store.

Remember: An app is never really ‘done.’

Developing an app is an ongoing process—they’re never really finished, even if you’re not adding new features down the line. There’s always a degree of maintenance, bug fixing, and OS updates (like Nougat) that make developing an application a living, breathing project. Android developers on Upwork are experts at prototyping, designing, and building engaging, responsive applications that strategically leverage your business, game, or product for a mobile environment.

Get more work done, faster with freelance help. Post a job today and get started!

Read more: 11 Questions to Ask Before Hiring a Mobile Developer