CarDekho Android Engineer Interview: Questions, Experience & Prep (2026)

CarDekho is one of India's largest automotive portals, connecting car buyers with dealers, listings, and financing options across the country. Their Android app is a core product, serving users who research cars, check EMIs, read reviews, and contact dealers, all from their phones. As of July 2026, CarDekho has 7 open roles listed on knok jobradar, with Android Engineer positions among them. The role sits within their product engineering team and typically involves working on features used by millions of active users.

If you are interviewing here, expect a strong focus on Android fundamentals, Kotlin, architecture patterns, and performance. CarDekho's app handles large car listing data, real-time price updates, and rich media, so candidates who can speak to performance optimization and scalable architecture tend to do well. Candidates report a process that typically includes an online coding assessment, one or two technical interviews, and a hiring manager conversation, though the exact structure can vary by team and seniority level.

These questions are commonly reported by candidates who have interviewed for Android Engineer roles at CarDekho and similar product-first companies:

1. How have you optimized RecyclerView performance when showing large car listing feeds?
2. Walk me through how you would design a feature using MVVM with Clean Architecture in an Android app.
3. How do you detect and fix memory leaks in Android? Which tools do you rely on?
4. How have you used Kotlin Coroutines for background tasks like fetching car prices or dealer data?
5. How would you implement deep linking so a user clicking a car listing in WhatsApp opens the right page in the app?
6. How would you build offline-first functionality so users can browse saved listings without internet?
7. How do you unit test a ViewModel that fetches car search results and updates the UI state?
8. When would you choose Jetpack Compose over XML layouts, and have you migrated any screens to Compose?
9. How would you design a real-time price alert feature that notifies users when a car's price drops?
10. Describe how you handle API pagination in a listing-heavy screen with active filters.
11. How do you make an Android app feel fast on entry-level devices that many Indian users carry?
12. What is your approach to handling push notifications for personalized car deal recommendations?

Use these as a starting point and adapt them to your own real experience.

Q: How have you optimized RecyclerView performance for large data sets?

*Situation:* At my previous company, our home feed showed car listings with images, prices, and dealer badges. Scrolling was janky on mid-range devices and users were dropping off the screen.

*Task:* I was responsible for fixing scroll performance without redesigning the whole screen.

*Action:* I replaced notifyDataSetChanged with DiffUtil so only changed items re-rendered. I moved image loading to Glide with a loading drawable to prevent layout shifts. I also profiled the ViewHolder's onBindViewHolder using Android Studio's profiler and found a repeated string formatting call that I moved out of the bind cycle.

*Result:* Frame drops on the listings screen reduced noticeably, and internal testing on a budget device showed much smoother scrolling. The fix shipped with no regressions.

---

Q: How do you detect and fix memory leaks in Android?

*Situation:* A QA engineer flagged that the app's memory kept climbing after navigating between car detail pages and back.

*Task:* I needed to find the leak source and fix it before a major release.

*Action:* I added LeakCanary to the debug build. It pointed to a static reference holding onto a Fragment's Context. I also found a Coroutine launched in the wrong scope that kept running after the Fragment was destroyed. I moved it to viewLifecycleOwner.lifecycleScope and removed the static reference.

*Result:* LeakCanary reported zero leaks for that flow after the fix. Memory usage during navigation stabilized and the release went out cleanly.

---

Q: How have you used Kotlin Coroutines for background tasks?

*Situation:* Our app needed to fetch car prices, dealer availability, and EMI rates in parallel when a user opened a car detail page. Doing them serially was too slow.

*Task:* I had to reduce time-to-loaded for the detail page without blocking the main thread.

*Action:* I used async/await in the ViewModel to fire all three API calls concurrently inside a viewModelScope.launch block. Each call had its own try/catch so a failed EMI call did not block the price from showing. I also added a loading state using StateFlow so the UI could show partial data as each call completed.

*Result:* The detail page felt much faster because price and images appeared quickly even when the EMI section took longer. The pattern became the team's standard for parallel fetches.

For architecture questions, describe the layer you own (UI, domain, data), what problem the pattern solves, and give a concrete example from your work. Interviewers want to know you understand *why* MVVM or Clean Architecture exists, not just that you have used it.

For performance questions, lead with the symptom (jank, ANR, high memory), the tool you used to diagnose it (Profiler, LeakCanary, Systrace), the specific root cause, and the fix. If you have real numbers from your own experience, use them. But only cite figures you personally measured.

For system design questions (real-time alerts, offline sync), start with the user problem, then walk through the data flow from server to UI. Mention trade-offs clearly, for example polling vs. WebSockets, or Room vs. in-memory cache. CarDekho's product serves a price-sensitive audience that includes users on slower connections, so mentioning network-efficiency trade-offs is a plus.

For coding rounds, Kotlin is expected. Use idiomatic Kotlin: extension functions, data classes, sealed classes for UI state. Avoid Java-style boilerplate. If asked to solve a problem live, talk through your approach before you start coding.

CarDekho is a product company with a large active user base, so they value engineers who think about real-world impact, not just code correctness.

Depth on Android internals. Interviewers tend to dig into how things work under the hood. Know the Activity and Fragment lifecycle well enough to explain edge cases, and know what happens when a user rotates the screen mid-API call.

Performance awareness. The app serves users across device tiers. Candidates who can speak to memory management, battery usage, and rendering performance stand out above those who only talk about 'clean code'.

Clean, testable code. CarDekho's engineering job descriptions emphasize code quality. Be ready to discuss how you structure code so it is unit-testable and how you write tests for async ViewModel logic.

Product thinking. Because the app is the product, interviewers appreciate candidates who connect technical decisions to user experience. When you describe a feature, briefly explain why you made a UX-impacting choice.

Kotlin fluency. Java knowledge is fine for background, but the team works in Kotlin. Coroutines, Flow, and Kotlin-idiomatic patterns should feel natural to you.

Week 1: Core Android and Kotlin.
Revisit the Activity, Fragment, and ViewModel lifecycle. Practice explaining what happens during configuration changes. Review Kotlin Coroutines and Flow, especially the difference between StateFlow and SharedFlow, and how to collect them safely inside a Fragment.

Week 2: Architecture and testing.
Build or review a small MVVM project using Clean Architecture layers. Write unit tests for a ViewModel using a fake repository. Practice explaining why each layer exists and what it protects against.

Week 3: Performance and Jetpack.
Profile a RecyclerView-heavy screen using Android Studio's profiler. Run LeakCanary on a personal project and trace any leaks. Read up on Jetpack Compose basics and be ready to discuss migration trade-offs.

Week 4: CarDekho-specific prep.
Download the CarDekho app and use it as a real user. Notice the listing feed, the car detail page, the search filters, and the EMI calculator. Think about how you would build or improve each screen. Read any public engineering content from CarDekho. Prepare two or three stories in STAR format from your own work history.

As you search for roles, knok checks 150+ job sites nightly, applies to jobs matching your resume, and messages HR for you, so you can focus your energy on interview prep rather than job hunting.

Saying you 'know' MVVM without explaining it. Interviewers will ask follow-up questions. If you cannot explain what problem the ViewModel solves during rotation, the answer falls apart quickly.

Ignoring device diversity. Designing a feature that only works well on flagship phones signals you have not worked on apps with a wide user base. Mention low-memory or slow-network scenarios proactively.

Using Java patterns in Kotlin. Writing Kotlin that looks like Java (verbose null checks, no data classes, no sealed classes) is a red flag at a Kotlin-first team.

Skipping the 'why' in architecture answers. Saying 'I used Clean Architecture' is not enough. Explain what it protected you from, for example a business rule change that did not require touching the UI layer.

Not asking questions at the end. Candidates who ask nothing signal low interest. Ask about team structure, current technical challenges, or how Android and backend engineers collaborate.

Overstating test coverage. If your testing experience is limited to unit tests, say so clearly and explain what you are learning. Interviewers respect honesty over inflated claims.