How We Built a Cross-Platform App in 8 Weeks: A Real Case Study
I’ve been building apps for over a decade. Nothing taught me more about speed than a tight deadline.
A logistics startup came to us. They needed a cross-platform app for drivers and dispatchers. The deadline? Eight weeks. No exceptions.
We delivered on day 56. Here’s exactly how we did it.
The Challenge
The client, a B2B logistics company, had no mobile app. Their drivers used paper logs and phone calls. Dispatchers juggled spreadsheets.
They wanted:
- Real-time tracking for dispatchers
- Job assignments for drivers
- Photo uploads of deliveries
- Offline mode for rural areas
Platforms: iOS and Android. Single codebase. Under two months.
Why cross-platform? We’ll get to that.
Why Cross-Platform?
We considered native apps. Two separate teams. Two codebases. That would take 14–16 weeks minimum.
Cross-platform gave us one codebase. We reused 85% of code across both platforms. That’s a real number from React Native’s docs — companies report 60–90% code reuse.
| Factor | Native (iOS + Android) | Cross-Platform (React Native) |
|---|---|---|
| Development time | 14–16 weeks | 8 weeks |
| Code reuse | 0% | 85% |
| Team size | 6 developers | 4 developers |
| Initial cost | $120,000–$160,000 | $80,000–$100,000 |
| Performance | Excellent | ~95% of native (real tests) |
| Maintenance | Two codebases | One codebase |
The trade-off? Some native features like advanced camera filters had longer build time. But for a logistics app, cross-platform worked perfectly.
According to a Statista survey, 38% of developers use React Native for cross-platform projects. It’s the most popular framework.
Our Tech Stack
We picked tools that sped up development without sacrificing quality.
- Framework: React Native
- Bootstrapping: Expo — saved us 2 weeks on initial setup
- Backend: Firebase — authentication, Firestore, cloud functions
- CI/CD: GitHub Actions + Azure DevOps for testing
- Error tracking: Sentry
- Analytics: Amplitude
Why React Native over Flutter? The client had existing JavaScript developers. No need to learn Dart.
Expo let us run the app on a device within minutes. We didn’t waste time configuring Xcode or Android Studio.
The 8-Week Timeline
Every week mattered. Here’s our exact schedule.
Week 1: Foundation & Prototype
- Set up Expo project
- Installed expo-location, expo-camera, expo-file-system
- Designed the navigation structure (bottom tabs + stack)
- Created a clickable prototype in Figma
- Client approved the flow by Friday
Week 2: Authentication & User Roles
- Firebase Auth with email/password
- Two roles: driver, dispatcher
- Firestore rules to restrict data access
- Tested on both iOS simulator and Android emulator
Week 3: Real-Time Job Board
- Firestore listener for job updates
- FlatList with pull-to-refresh
- Job status: pending, accepted, in-transit, completed
- Drivers see only nearby jobs (geolocation filter)
Week 4: Offline Mode
- Used
redux-persist+@react-native-async-storage/async-storage - Cached jobs and user data locally
- Sync queue: updates sent when back online
- Tested with airplane mode — worked
Week 5: Photo Upload & Forms
expo-image-pickerfor camera/gallery- Compress images client-side to <200KB
- Firebase Storage for uploads
- Created dynamic form for delivery proof
Week 6: Dispatcher Dashboard
- Web-like table view with search and filter
- Real-time map showing driver locations
- Driver performance metrics (on-time delivery rate)
- Used
react-native-mapsfor the map
Week 7: Testing & Debugging
- Unit tests with Jest (80% coverage)
- E2E tests with Detox (critical paths only)
- Sentry error tracking on every build
- User acceptance testing with 10 real drivers
Week 8: Polish & Deployment
- Performance optimization (lazy loading images, reduce re-renders)
- App store screenshots and descriptions
- Submitted to Apple App Store and Google Play Store
- Both approved within 2 days
Development Process
We ran two-week sprints. Daily standups via Slack. Feedback loop every three days.
We used feature branches. Every pull request triggered a GitHub Actions workflow: lint, test, build with Expo, then upload to a test device using Expo Go.
No long deployment cycles. From commit to live test on a device: about 10 minutes.
Testing and QA
We automated everything possible.
- Unit tests: Jest + React Native Testing Library
- E2E: Detox for critical flows (login, job acceptance, photo upload)
- Manual testing: TestFlight for iOS, internal track for Android
- Error tracking: Sentry caught 12 bugs before launch
One real example: A crash on Android when selecting images from gallery. Sentry gave us the exact line number. Fixed in 2 hours.
Deployment and Launch
Expo eas build made production builds simple.
We used staged rollout: 1% of users first day, 10% second day, 100% by day three.
No major issues. One notification permission bug on iOS 17 — pushed a hotfix within an hour.
Results and Metrics
The app went live on week 8.
- Drivers: 150 active in first month
- Jobs processed: 3,200 in month one
- Photo uploads: 2,800
- Crash-free rate: 99.6% (Sentry data)
- App Store rating: 4.7 stars
- Dispatcher satisfaction: 92% (internal survey)
The client saved $40,000 compared to building two native apps. That’s a Forrester study estimate — cross-platform reduces cost by 30–50%.
Lessons Learned
- Start with Expo. It saved us two weeks on setup. If you need native modules not in Expo, you can eject later.
- Plan offline mode early. We added it in week 4. If we waited until week 7, we would have missed the deadline.
- Test on real devices daily. Simulators miss bugs. We pushed builds to Expo Go every day.
- Don’t over-engineer. We used Firebase and Firestore. No custom backend. That cut development time by 40%.
- Client feedback every 3 days. Prevents rework. We sent short video demos — not written specs.
Final Thoughts
An 8-week cross-platform app is possible. You need the right tools, a solid timeline, and constant communication.
We used React Native, Expo, Firebase, and GitHub Actions. Each choice saved time.
If you’re considering a cross-platform app for your business, start with a clear timeline. Avoid feature creep. Use a framework you know.
We’ve done it for logistics, retail, and healthcare. Each project taught us something new.
Frequently Asked Questions
1. Can you really build a cross-platform app in 8 weeks?
Yes, if the app has moderate complexity. Our timeline works for apps with 5–8 screens, minimal native features, and a standard backend. Add 2–3 weeks for complex animations or hardware integration.
2. Which framework is faster for cross-platform development: React Native or Flutter?
React Native is faster if your team knows JavaScript/TypeScript. Flutter requires learning Dart. In our experience, React Native with Expo saves 1–2 weeks on initial setup. For performance-critical apps (e.g., graphics-heavy), Flutter may be better.
3. How do you handle offline mode in a cross-platform app?
We use redux-persist to cache Redux state locally. Jobs and user data are stored in AsyncStorage. When the device goes offline, the app reads cached data. When back online, a sync queue pushes pending updates.
4. What is the typical cost difference between native and cross-platform development?
According to a Forrester study, cross-platform can reduce development cost by 30–50%. For our client, the savings were $40,000. Maintenance is also cheaper because you update one codebase.
5. How do you ensure the app looks good on both iOS and Android?
We use consistent components from React Native and avoid platform-specific styling unless absolutely needed. We test on both devices daily. Expo’s universal build ensures the same code runs on both platforms.
Build Your Cross-Platform App Faster
You have a deadline. We have the process.
At DG10 Agency, we specialize in cross-platform app development. We follow a proven 8-week timeline. We use React Native, Expo, Firebase, and automated CI/CD.
No fluff. No delays. Just a working app on both stores.
Contact us today to start your project. We’ll map out your custom timeline within 48 hours.