Why does your Android app’s performance depend on the agency’s database choices?
Most UK businesses assume Firebase or a custom backend is just a technical detail, but the choice directly impacts scalability—and budget. Firebase’s free tier handles up to 50,000 daily active users (DAUs) without extra cost, but once you exceed that, pricing jumps to £0.20 per 100K reads/writes. A food-delivery app we reviewed hit this limit during peak hours (7–9 PM), forcing last-minute fixes that cost three times more than a proactive PostgreSQL backend would have. The agency had defaulted to Firebase to ‘save time’ but didn’t disclose migration costs or scalability limits until the app was live.
The trade-off is clear: Firebase accelerates MVP development (ideal for startups with <50K DAUs), but a custom backend avoids vendor lock-in. For example, a retail app targeting 100K users would need a dedicated PostgreSQL setup from day one—adding £3K–£5K upfront but saving £12K+ in Firebase scaling fees by year two. The catch? Agencies often pitch Firebase as ‘cheaper’ without explaining when the cost curve spikes. Ask for a breakdown of DAU projections and migration paths before signing.
What goes wrong in practice? Agencies may not account for third-party API limits. A logistics app using Firebase’s Firestore hit rate limits during Black Friday, causing a 4-hour outage. The fix required rewriting queries and adding caching—work that could have been avoided with a custom backend designed for traffic spikes.
Key question to ask: ‘What’s your experience scaling beyond Firebase’s free tier, and what’s the cost of migrating if we outgrow it?’
How do agencies handle Android’s fragmentation without breaking your app?
Android’s device fragmentation isn’t just about old phones—it’s about compatibility trade-offs that agencies often gloss over. Jetpack Compose, Google’s modern UI toolkit, reduces fragmentation headaches by sharing code across Android versions, but it requires testing on devices as far back as Android 8 (released in 2017). The problem? If your app targets older users (e.g., 15% on Android 7), Compose may not support them, forcing a fallback to XML layouts—adding 2–3 weeks to development.
A retail app we assessed needed to support Android 7 for accessibility reasons. The agency proposed Jetpack Compose but couldn’t guarantee full functionality on older devices without extensive manual testing. The alternative? Sticking with XML layouts, which added £4K to the budget but ensured 100% compatibility. The agency’s initial pitch of ‘future-proof’ Compose development hid this cost until the design phase.
Fragmentation also affects performance. A banking app using Compose on Android 9+ saw a 20% slower render time on older devices due to unsupported transitions. The fix required rewriting animations—work that could have been avoided with upfront testing on a device matrix.
What goes wrong? Agencies may assume your audience uses recent Android versions. A healthcare app targeting NHS users (many on Android 8) crashed during login because the agency hadn’t tested session management on older OS versions. The £6K emergency fix could have been avoided with a device compatibility matrix upfront.
Key question to ask: ‘What’s your testing strategy for Android versions below 12, and how do you handle unsupported features?’
What happens when your agency’s ‘fixed-price’ Android project turns into a money pit?
Fixed-price contracts sound safe, but they hide scope creep in Android development—especially around third-party integrations. A payment app we reviewed had a £25K fixed-price budget for 12 weeks. The agency didn’t account for Stripe’s Android SDK deprecating old methods mid-project, adding £8K in ‘unplanned’ work. The contract’s fine print excluded API changes, but the agency still charged for fixes.
The mechanism is simple: fixed-price projects assume stable APIs, but Android’s ecosystem changes constantly. For example, Google’s Play Services updates can break background location tracking, requiring last-minute code changes. A fitness app’s fixed-price contract added £5K when the agency had to rewrite GPS polling logic after a Play Services update.
Trade-off: Fixed-price offers predictability, but it fails when dependencies change. Agencies may underestimate API risks to win the contract, then pass costs back as ‘change requests.’
What goes wrong? Agencies may not disclose API dependency risks upfront. A logistics app’s fixed-price contract included a ‘weather data API,’ but the agency didn’t specify that the provider’s Android SDK had a 90-day deprecation cycle. When the API changed mid-project, the app’s route-planning feature broke, adding £7K in fixes.
Key question to ask: ‘How do you handle third-party API changes in fixed-price projects, and what’s the cost if an API deprecates a feature we rely on?’
Can your agency deliver an Android app faster than your in-house team—without cutting corners?
Speed isn’t just about developer hours—it’s about architecture choices that agencies often rush. A modular approach (e.g., Clean Architecture) speeds up development by isolating business logic, but it requires 2–3 weeks of upfront design in a 12-week project. Agencies may skip this to meet deadlines, leading to ‘spaghetti code’ that slows future updates.
The trade-off is compliance. A healthcare app we reviewed needed UK GDPR-compliant data storage, which required 4 weeks of design work. The agency in India prioritized meeting the 12-week deadline, rushing the GDPR layer. The app was rejected by Google Play for non-compliant permissions, costing £10K in delays and a 30-day review extension.
Mechanism: Agencies in non-EU locations may lack local compliance knowledge. For example, an agency in the US might not understand UK ICO data processing rules for Android apps handling sensitive user data. A fintech app’s fixed-price contract added £6K when the agency had to rewrite data encryption to meet UK regulations.
What goes wrong? Agencies may cut security corners to hit deadlines. A social app’s fixed-price contract included ‘end-to-end encryption,’ but the agency used a third-party library with known vulnerabilities. Google Play flagged the app for security risks, requiring a £9K rewrite.
Key question to ask: ‘How do you ensure compliance with UK GDPR and other local regulations in Android apps, and what’s the cost if we discover gaps post-launch?’
How do you avoid an Android app that looks great but crashes in production?
‘UI testing’ (e.g., Espresso) catches visual bugs, but real-world crashes require Firebase Crashlytics + manual QA in diverse environments. Agencies may skip Crashlytics to save £2K/month, but crashes cost £10K+ in user churn and fixes. A social app we reviewed lost 20% of daily users in the first week after launch due to untested background service crashes on Android 9.
The mechanism is simple: Crashlytics logs real-device crashes, but agencies often treat it as an afterthought. A fitness app crashed on Android 7 due to untested WakeLock permissions, causing a 15% user drop-off. The fix required rewriting background sync logic—work that could have been caught with device-specific QA.
Trade-off: Crashlytics adds £2K/month but prevents £10K+ in post-launch fixes. Agencies may omit it to undercut competitors, but the cost of crashes far outweighs the subscription. For example, a navigation app’s unoptimized GPS polling caused crashes on Android 8, leading to £8K in emergency fixes and a 2-star rating drop.
What goes wrong? Agencies may assume ‘beta testing’ is enough. A retail app passed QA but crashed on Android 6 due to untested StrictMode violations. The fix required rewriting database transactions—work that could have been avoided with version-specific testing.
Key question to ask: ‘What crash-reporting tools do you use beyond UI testing, and how do you test on Android versions below 12?’
What’s the real cost of ‘free’ or ‘cheap’ Android development agencies?
A £5K Android app built by junior devs (£30–£50/hour) may seem cheap, but technical debt adds £20K+ in refactoring costs within 18 months. For example, a £10K ‘budget’ app we reviewed required £18K in fixes after 6 months because the agency didn’t use dependency injection (DI), making updates error-prone.
The mechanism is simple: Junior devs lack experience with Android architecture components, leading to spaghetti code. A £7K app built without DI required £12K to refactor when adding new features, because every class was tightly coupled.
Trade-off: Cheap agencies cut corners on certified developers. An agency in Eastern Europe hired uncertified devs for a £6K app, leading to Google Play rejection due to improper AndroidManifest.xml permissions. The £3K fix could have been avoided with a Google Android Associate-certified team.
What goes wrong? Agencies may use freelancers to undercut prices, but freelancers lack accountability. A £4K app built by freelancers crashed on Android 8 due to unoptimized coroutines, costing £9K in fixes and a 1-star review wave.
Key question to ask: ‘What’s the seniority level of your Android developers, and do they hold Google Android certifications?’
How do you ensure your Android app’s battery life doesn’t scare users away?
Battery drain is a make-or-break factor for Android apps, yet agencies often treat it as an afterthought. Unoptimized foreground services or wakelocks can drain 30% battery in 2 hours, leading to 1-star reviews and uninstalls. A navigation app we reviewed drained 40% battery in 30 minutes due to unoptimized GPS polling, forcing a £7K emergency fix post-launch.
The mechanism is testing: Agencies should use Android Profiler to monitor CPU/wake usage, but many skip it to save time. A fitness app’s heart-rate monitor drained 25% battery in 15 minutes because the agency didn’t test Doze Mode compatibility.
Trade-off: Battery optimization adds 1–2 weeks to development but prevents £5K–£10K in post-launch fixes. Agencies may cut this step to meet deadlines, but the cost of poor battery life is 25% higher uninstalls (per Google Play Console data).
What goes wrong? Agencies may assume ‘background sync’ is optimized, but WorkManager misconfigurations can double battery drain. A news app’s push notifications drained 35% battery because the agency didn’t limit WorkManager’s execution window.
Key question to ask: ‘How do you test battery impact, and what tools do you use to optimize foreground services?’
What questions expose an Android agency’s hidden weaknesses?
Vague answers reveal red flags. An agency claiming ‘we use the latest tools’ is hiding a lack of specific experience. Instead, ask: ‘How many Android apps have you fixed using Firebase Crashlytics, and what was the worst crash you resolved?’ A strong answer cites concrete examples (e.g., ‘We fixed 50+ crashes in a logistics app using Crashlytics’).
Mechanism: Agencies avoid discussing failures, but asking about worst-case scenarios exposes preparedness. For example: ‘How would you handle a 50% API failure rate during Black Friday?’ A weak answer: ‘We’d monitor it.’ A strong answer: ‘We’d implement circuit breakers and fall back to cached data, as we did for [Client X] during a 3-day outage.’*
Trade-off: Agencies may overpromise ‘24/7 support’ but deliver 48-hour response times for critical bugs. A healthcare app’s agency promised ‘instant fixes’ but took 36 hours to patch a HIPAA-compliant data leak, costing £15K in fines.
What goes wrong? Agencies may avoid discussing post-launch support costs. A retail app’s agency charged £2K/month for ‘maintenance’ but didn’t disclose that app store updates (e.g., Android 13 compatibility) would require extra fees.
Key questions to ask:
- ‘What’s your worst-case scenario for an API failure, and how did you handle it?’
- ‘What’s your response time for critical bugs, and is that included in the fixed price?’
- ‘How many apps have you supported past 12 months, and what’s the average cost of post-launch fixes?’
Next step
Before signing with an agency, audit their Android-specific experience—not their portfolio screenshots. Ask for:
- A device compatibility matrix (Android versions they’ve tested on).
- Crashlytics reports from past apps (not just QA logs).
- API failure post-mortems (how they handled third-party outages).
- Battery optimization case studies (not just ‘we tested it’).
For a fixed-price quote, use our pricing page to compare scope-based costs. If the agency can’t answer these questions concretely, the risk of hidden costs—and crashes—is high.
Contact us for a no-obligation review of your Android project’s technical risks.
Frequently asked
Ask for **live app links** (not just screenshots) and **Google Play Store ratings**. A real portfolio includes case studies with metrics like ‘crash reduction’ or ‘battery drain improvements.’ Agencies that can’t provide these likely rely on staged demos. Also, check for **app store reviews**—if the app has 1-star ratings about crashes or battery life, the agency may have cut corners.
'Development' covers building the app (fixed price or hourly), while 'maintenance' includes post-launch fixes, updates, and app store compliance. The catch? Many agencies **exclude** critical tasks like Android OS updates or API changes from maintenance pricing, leading to £5K–£10K in unexpected costs. Always clarify what’s included—and ask for a **year-one budget** for maintenance, not just a monthly fee.
Yes, but only if the agency uses **modular architecture** (e.g., Clean Architecture) and **pre-built components** (e.g., Jetpack libraries). The catch? Cutting corners on **compliance testing** (e.g., UK GDPR) or **battery optimization** can add £8K–£12K in fixes later. A 3-month timeline works for MVPs but not for apps needing **high security** (e.g., fintech) or **offline functionality** (e.g., healthcare).
Require a **signed support agreement** with **minimum response times** (e.g., 4 hours for critical bugs) and **financial penalties** for abandonment. Also, ask for **client references**—not just names, but **contact details** of past clients who can vouch for post-launch support. Agencies that can’t provide this may vanish after payment, leaving you with an unsupported app.
Start with **Firebase Crashlytics** to identify crash patterns, then prioritize fixes for **Android versions with the most complaints** (e.g., Android 8). If reviews mention battery drain, use **Android Profiler** to find unoptimized services. For **permission-related issues**, audit the `AndroidManifest.xml` for overreach. The fastest fix? **Roll back recent updates** while debugging—many 1-star issues stem from new code, not legacy bugs.
- android-app-development
- android-fragmentation
- fixed-price-contracts
- technical-debt
- uk-software-agency