Rupeek Android Developer Interview Experience | Real Questions Asked, Preparation Tips & Complete Process

Recently, I interviewed for the Android Developer role at Rupeek and wanted to share my complete experience because the process was quite detailed and focused heavily on Android fundamentals, Java/Kotlin concepts, real project discussions and practical engineering thinking. I was rejected in the end, but honestly, the experience itself was very useful and gave me a clear understanding of how fast-growing startups evaluate Android developers.

I had around 1 month of preparation before the interviews. My preparation mainly focused on Android fundamentals, Java, Kotlin, Object-Oriented Programming and basic Data Structures & Algorithms. One thing I realized during the process is that companies like Rupeek do not expect only textbook answers. They want developers who understand real application development, architecture decisions, debugging, scalability and production-level thinking.

The entire process had 5 rounds, including an assignment round, DSA round, Android technical discussion and managerial discussions.

Round 1 – Android Assignment Round

The first round was an assignment-based round with a duration of around 3 hours. The task was to create a simple weather application using a provided mock server and some icons.

At first, the problem looked easy, but the interviewer expectations were much higher than simply displaying weather data on the screen. They were evaluating:

• Project structure
• Clean architecture
• API handling
• Code readability
• UI design
• Best practices
• Error handling
• Overall Android development standards

I used Retrofit for API integration and tried to follow MVVM architecture as much as possible within the limited time. I also focused on maintaining proper package structure and reusable code instead of rushing only toward completing features.

One important thing I noticed is that UI quality mattered. Even though this was a technical assignment, they still evaluated how polished and user-friendly the app looked. A basic working app with poor structure probably would not leave a strong impression.

If you are preparing for Android assignments, I would strongly recommend:

• Learn Retrofit properly
• Practice MVVM architecture
• Understand RecyclerView, ViewModel, LiveData
• Focus on clean UI layouts
• Handle loading, empty states and API failures correctly

This round felt very practical and close to real Android development work.

Round 2 – DSA Live Coding Round

The second round was a live coding interview conducted over a video call. It happened on a Sunday morning and lasted around 45 minutes. The interviewer was actually quite friendly and supportive, which helped reduce nervousness.

The questions were basic-to-medium level DSA problems. The focus was mainly on logic building and writing clean code rather than tricky competitive programming.

The first question was: the classic Majority Element problem

The interviewer first asked for a straightforward solution and later discussed optimization possibilities. They were checking whether I understood time complexity and space optimization.

The second problem was: Row of Matrix With Maximum Ones

This question involved a sorted binary matrix where we had to find the first row with the maximum number of 1s.

The interviewer was interested in:

• Binary search optimization
• Matrix traversal logic
• Edge case handling
• Code clarity

While solving, I explained multiple approaches before implementing the optimized one. I noticed the interviewer appreciated discussion more than simply jumping into code.

The overall DSA round was not extremely difficult, but you definitely need strong basics in:

• Arrays
• Binary Search
• Trees
• Linked Lists
• Matrix problems

For Android roles, companies usually do not ask extremely hard competitive programming questions, but they still expect solid problem-solving ability.

Round 3 – Android Technical Round

This was the most important round in the entire process and probably the deciding round for Android developers. The interviewer asked a very wide range of Android, Java and Kotlin questions. It felt less like a rapid-fire quiz and more like a deep technical discussion to evaluate whether I actually understood Android internals and development concepts. Some of the major topics discussed were:

• Services and IntentService
• Running parallel processes
• HashMap vs HashSet
• PendingIntent vs Sticky Intent
• Abstract classes and interfaces
• Kotlin lateinit vs lazy
• Java vs Kotlin inheritance
• Firebase push notifications
• Fragment back stack handling
• AsyncTask and its issues
• Inter-process communication between apps
• MVVM vs MVP
• Activity lifecycle
• Context types in Android
• onSavedInstanceState
• Intent types
• HTTP response codes
• finally vs finalize

The interviewer kept asking follow-up questions after every answer. For example, if I explained MVVM, they immediately asked where exactly I had used it in my projects and what problems it solved compared to MVP.

One thing I learned from this round is that interviewers can easily identify whether someone has only memorized Android interview questions or has actually worked on production applications.

They were especially interested in:

• Real-world implementation experience
• Architecture decisions
• Memory management understanding
• Lifecycle awareness
• Multi-threading concepts
• Clean code practices

There were also discussions around Kotlin adoption and modern Android development practices, which aligns with how Android development has evolved toward safer and more maintainable codebases.

If you are preparing for Android interviews, focus deeply on:

• Android lifecycle
• Architecture components
• Concurrency
• Memory leaks
• Coroutines
• MVVM
• Networking
• Firebase
• Kotlin fundamentals
• OOPS concepts

Round 4 – Engineering Head / Managerial Round

This round was conducted by the Engineering Head and lasted around 90 minutes. Surprisingly, this became one of the most interesting rounds. Instead of only technical questions, the discussion focused more on:

• My projects
• Product thinking
• Ownership
• Decision making
• Handling deadlines
• Production bug fixes
• Team collaboration
• Learning attitude

The interviewer asked questions like:

• What features are you most proud of?
• If you rebuild your project today, what would you improve?
• How do you handle urgent production bugs alongside ongoing sprint work?
• How do you stay updated with Android changes?
• Why do you want to switch jobs?
• Why Rupeek specifically?

This round felt more like a real engineering conversation instead of a formal interview. One thing I realized is that senior team members care a lot about:

• Ownership mindset
• Product understanding
• Communication skills
• Long-term thinking
• Learning ability

So while preparing, do not ignore your own projects. Be prepared to explain:

• Architecture decisions
• Challenges faced
• Optimizations done
• Trade-offs
• Mistakes and learnings

Round 5 – VP Round

The final round was shorter, around 15 minutes and conducted by a VP-level person. The discussion was mostly around:

• Introduction
• Previous projects
• API understanding
• Retry mechanisms
• Learning new projects quickly
• Career goals
• Startup culture
• Interest in fast-growing environments

The interviewer wanted to understand whether I would fit well in a startup ecosystem where things move very fast and engineers are expected to take ownership beyond their assigned tasks.

One interesting question was whether I voluntarily work on features or ideas outside official tasks that could improve products. This clearly showed that the company values proactive developers who think beyond assigned tickets.

Final Result

Unfortunately, I got rejected after the final rounds.

Still, I genuinely feel the interview process was worth experiencing because it exposed many areas I needed to improve, especially around Android internals, architecture discussions and communication.

The overall process at Rupeek was professional, practical and heavily focused on real engineering understanding instead of pure theoretical knowledge. Similar experiences shared by other candidates also show strong emphasis on Android architecture, DSA basics and project discussions.

My Preparation Tips for Android Developers

If you are preparing for Android developer interviews at startups or product-based companies, here are a few things that genuinely help:

• First, do not ignore DSA completely. Even Android roles expect decent problem-solving skills.

• Second, prepare your projects extremely well. Most deep discussions actually come from your own resume.

• Third, focus heavily on Android architecture and lifecycle concepts because interviewers ask many scenario-based questions from them.

• Fourth, learn Kotlin properly. Many companies now expect strong Kotlin knowledge rather than only Java.

• Finally, improve communication. Senior interviewers often evaluate how clearly you explain technical concepts and justify decisions.

Overall, the experience was challenging but very educational, especially for someone preparing for Android product-company interviews.