We provide IT Staff Augmentation Services!

Sr. Android Developer Resume

Boston, MA


  • 11 years’ experience in Android Mobile development.
  • 2 years’ experience in software development.
  • 7 apps published to Play Store.
  • Hands - on with MVC, MVP, and MVVM architectures.
  • Skilled Kotlin and Java programmer.
  • Experienced applying RxKotlin, RxJava, RxAndroid, and RxBluetooth frameworks.
  • Apply design patterns such as Builder, Factory, Façade, Proxy, Command, Singleton, Observer, Visitor, and Interpreter.
  • Use Espresso, JUnit, Mockito and simulated design patterns in Android to test and develop applications.
  • Strong knowledge in Agile development environments.
  • Familiar with Data Binding using JetPack as well as other methods and decoupling with Dependency Injection (Butter Knife, Dagger).
  • Select and utilize the best new mobile app developments per need, environment, and use case.
  • Hands-on experience with dependency injection in Android mobile apps using Dagger 1, Dagger 2, RoboGuice, Butter Knife, and Android Annotations.
  • Expertise in building source code, troubleshooting build/configuration/integration issues, communicating, and resolving source code related issues between various teams of the project.
  • Expert in the interaction between various devices and different versions of Android.
  • Use of multiple MBaaS (Mobile Backend as a service) and cloud integration tools such as Parse, Firebase, Google Cloud Services, and Amazon Web Services.
  • Practical implementation of Android Life Cycle, Fragments, Intents, and threads on Android; binding services, implicit and explicit Intents, background processes, sync adapters, activity, activities for Result, WebView, ImageView, TextView, RecyclerView, ListView, and Object-Oriented design and programming.
  • Experience working with web Services design and consumption with a RESTful architecture.
  • Expert in Android SDK, as well as testing and profiling with Android development tools using Android Studio.
  • Positive attitude and leadership and support, providing code design, code reviews, and mentoring.


UI Implementation: Android Adapter Views, Listview, Gridview, Gallery, Customized List views, Gallery widgets, Floating Action Button

Programming Languages: Java, Kotlin

IDEs: Android Studio, Eclipse, NetBeans

Project Related: Agile, Scrum, Git, GitHub, BitBucket, Confluence, Javadoc, JIRA

Quality & Testing: Test-Driven Development (TDD), Unit Testing, Jenkins, Hudson, Travis CI, Mockito, JUnit, Robolectric

Automated Testing: Espresso, Robotium, MonkeyRunner, Crashlytics, Leak Canary, Bluetooth Low Energy, TestFairy

Data Management: SQLite, Room, Keychain, Parse, Firebase, Shared Preferences

Dependency Injection: Dagger 1, Dagger 2, Butter Knife, Android Annotations.


Multithreading: Retrofit, RxJava, RxAndroid, RxKotlin, Firebase, Loopers, Loaders, Volley, AsyncTask

Media: Universal Image Loader, Picasso, Glide, MediaPlayer, ExoPlayer, YouTube

Libraries: EventBus, Google Maps, Google Cloud Messaging, NineOldAndroids, SpongyCastle, Content Providers, Job Scheduler, JetPack


Confidential, Boston, MA

Sr. Android Developer


  • Worked in an Agile/Scrum environment with 5 Android developers, QA testers, UI/UX designers and backend developers.
  • Joined daily standup meetings with other team member and participated in demo presentations with stakeholders every other week, and 2-week sprints.
  • Worked with iOS, Mac, Windows teams, UI/UX teams, backend/server team, and internal and external QA teams.
  • Utilized Android Studios as IDE.
  • Built UI with Android Studio.
  • Transitioned existing code to Kotlin and programmed new functions in Kotlin.
  • Used Data Binding Library to support two-way data binding to receive data changes to a property and listen to user updates to that property at the same time.
  • Applied RxKotlin in conjunction with RxAndroid and RxBinding libraries to make app multithreaded and perform synchronous operations.
  • Introduced Kotlin extension functions to efficiently re-use existing codes, reducing code duplication to its bare minimum.
  • Used Intents and Intent Filters to initiate activities and pass information between Activities and Fragments.
  • Applied WebRTC/Pexip for real-time video communication over the internet.
  • Used LiveData builder to combine Kotlin coroutines with LiveData Coroutines Asynchronous Flow to implement async sequence, or stream, of values in MVVM architecture.
  • Used Jira for tracking project stories.
  • Used Confluence to stay organized with other team members.
  • Used GitHub/Git extensively.
  • Reviewed, merged, and made pull requests.
  • Worked with testing libraries and frameworks: Junit, Espresso, Mockito, and Robolectric.
  • Used Observer-Pattern using LiveData and ViewModels.
  • Made API calls for fetching user data and for converting invite into conference token.
  • Applied ADA and Accessibility functionality.
  • Applied multi-language support.

Confidential, Pleasant Grove, UT

Senior Android Mobile App Developer


  • Produced work in alignment with an Agile/Scrum methodology, with Sprints every 2 weeks.
  • Worked on an Android team consisting of 5 Android developers.
  • Participated in Sprint backlog, Sprint Grooming, Sprint Planning, Sprint Retrospective, and daily Standups using Slack.
  • Worked with Android Studio as the main IDE for the project.
  • Utilized Android SDK and supporting development devices.
  • Applied a modified MVVM architecture with a ViewModel inside every Activity and Fragment, creating a ViewModel for every single view.
  • Utilized third-party libraires such as Dagger, Retrofit, Robolectric, and Picasso.
  • Used Android Keychain to secure information.
  • Monitored crashes using Google Crashlytics.
  • Used Kotlin as the main code language for the Android application.
  • Replaced RxJava implementation with Kotlin coroutines and dispatchers to make asynchronous Network requests, JSON parsing, and reading/writing from a database.
  • Android Architecture Components used to improve the user experience and facilitate the development work (included LiveData, ViewModel, and Room as the SQLite database to cache the app data).
  • Customized the UI using CustomViews.
  • Initially used Workfront for task tracking and then migrated task management to Jira.
  • Worked with remote project offshore in Ukraine, managing various work schedules and time zones.
  • Applied Dagger 2 Dependency Injection inject single instances of services that many ViewModels needed.
  • Used Robolectric to create unit tests.

Confidential, Parsippany, NJ

Senior Android Developer


  • Worked on an Android development team consisting of 3 Android developers, 1 front-end designer, 2 QA testers, and 1 Product Manager.
  • Followed Agile Scrum process with daily Scrum, Sprint meetings and helped assign tasks and followed up on backlog and issue tasks to make sure they were completed.
  • Developed the Android app in both Java and Kotlin using Android Studio.
  • Implemented improvements in performance and maintainability through Android JetPack components.
  • Proposed and took personal ownership converting application architecture using the Model View View Model (MVVM) architectural design pattern.
  • Made use of various design patterns such as Singleton, Façade, and Abstract Factory.
  • Transitioned the Android code base from MVP to MVVM architectural pattern to better manage the different functional modules and views.
  • Managed consumption of RESTful Web Services with Retrofit and RxJava, managing back-end threading and also parsing of JSON objects with Moshi.
  • Worked in a Test-Driven Development environment using GitHub repository for version control and Bitrise.io for continuous integration.
  • Implemented Push Notifications through Firebase Cloud Messaging.
  • Added JetPack Room over SQLite for a more robust database with data persistence.
  • Added JetPack ViewModel - to manage UI related data in a lifecycle conscious way.
  • Used JetPack Slices and Fragments in UI elements and composition.
  • Managed Android background jobs using JetPack WorkManager.
  • Participated in code reviews and mentored developers on Android best practices.
  • Oversaw Android app testing and replaced older testing framework with Espresso automated testing.

Confidential, St. Louis, MO

Android Mobile Developer


  • Worked on a development team that applied an Agile methodology with daily Scrums and bi-weekly Sprints.
  • Wrote user stories in Jira.
  • Tracked issues and pulled issues from Jira.
  • Implemented Dagger to work with a Dependency Injection environment to help with the unit testing.
  • Android development team worked in Android Studio, using various Android tools such as jUnit to compose Unit Tests.
  • Used Parcelable to serialize Java objects from Activity to Activity.
  • Replaced Scriptaculous with UI jQuery libraries to improve maintainability.
  • Used AsyncTasks hosted in Fragments to handle the network information lookup.
  • Implemented the multithreading communication using the built-in Android frameworks like AsyncTasks and Handlers.
  • Used Test-Driven Development and Continuous Integration.
  • Dagger 2 was the library for dependency injection in this Android app.
  • Analyzed, tested, debugged, and resolved complex issues affecting conferencing, connectivity, and communications.
  • Used Android Debug Bridge (ADB) and Leaf Canary to performance profile the Android app.
  • Worked with testing team using testing tool Robolectric.
  • Contributed to full lifecycle development process from product definition through design, development, test, release and maintenance.
  • Performed Testing (Junit) of the new version to solve common debugging problems.
  • Involved in working with Location Manager and Restful Web service with JSON.
  • Added Push Notification through backend support to get users specials and discounts on the device.
  • Efficiently used Activity, Intents, Fragments, Services, Broadcast Receivers, notifications, Content Providers and Media Players for building the app.
  • Embedded local storage solutions such as SQLite.

Confidential, Canton, MA

Android Developer


  • Attended daily SCRUM meetings to track app development progress.
  • Gathered requirements and managed JIRA tasks, stories, and epics.
  • Wrote Java mode JSON Parsers for the API URL call data.
  • Transitioned consumption of RESTful services from Volley and AsyncTask to Retrofit and RxJava.
  • Used JIRA for team collaboration.
  • Implemented Event Bus library and Java Interface listeners to communicate between fragments.
  • Used Atlassian Stash Bitbucket for GIT source control management.
  • Implemented the User Interface with a TabLayout and a ViewPager, using multiple Fragments.
  • Added Google LocationServices API to get location.
  • Debugged Fragment Card Flip Animations and Dialog Fragments.
  • Added RecyclerView to display parsed data.
  • Used ScrollView to display Two RecyclerViews at once.
  • Implemented Support Libraries to build backward-compatible source code for multiple Android OS API levels.
  • Worked Jira issue backlog with the other Android developers and back-end developers as shared tasks.
  • Implemented SharedPreferences to store user data.
  • Used Firebase Push Notifications for messages and alerts.
  • Worked with the Facebook API for user login authentication.

Confidential, Atlanta, GA

Mobile Android App Developer


  • Worked with an Agile Scrum/iterative development methodology.
  • Utilized Eclipse IDE to implement the application in Java and automating testing with Robotium.
  • Implemented Continuous Integration with Jenkins, using Git with BitBucket for code repository/version control.
  • Managed the build creation with a Jenkins instance hosted on a private server.
  • Wrote Javadoc for documenting the different modules, hardware, and software features.
  • Performed regular code reviews to ensure overall code quality and adherence to company coding standards and industry best practices.
  • Created CustomViews to present data as it was needed.
  • Integrated Flurry for mobile analytics.
  • Implemented UI/UX look-and-feel in the app, applying styles and themes following Google’s Material Design guidelines.
  • Created multiple Content Providers with a native approach to handling UI asynchronous updates.
  • Applied OOP knowledge of software design patterns/best practices.
  • Set up proper interactions of the front-end design and implementation with backend servers.
  • Refactored un-optimized pieces of code to guarantee maximization in the use of resources.
  • Utilized AsyncTask to connect to a remote server to retrieve user information.
  • Made use of Activities and Activities for Result and RecyclerViews to get a better performance of the application.
  • Used Implicit and Explicit Intents.
  • Introduced Google Maps API integration with the application.
  • Developed graphic interface and UI for some activities.
  • Worked with asynchronous requests to the server with Volley library.
  • Added Push Notification features with Urban Airship.

Confidential, Dallas, TX

Jr. Android Mobile App Developer


  • Participated in complete Software Development Life Cycle (SDLC) for proper analysis, development, testing, deployment, and enhancement of the code.
  • Programmed in Java using Android Studio.
  • Managed data using SQLite.
  • Conducted UAT testing by porting the app to different devices with varying screen sizes.
  • Closely worked with a testing team and used developer testing tools such as Robotium in Android.
  • Used JIRA to track and document incidents, tasks, and backlog., as well as stories and Epics.
  • Integrated communication framework between the three fragments within the activity.
  • Provided subsequent releases which included feature changes, enhancements, and bug fixes.
  • Debugged and tested the mobile application.
  • Presented demos of the application’s features to management.
  • Builtnew features to enhance the UX for consumers.

Hire Now