Migrating Gobi to Native iOS and Android Without Pausing the Roadmap
Gobi is a social discovery app that brings together interactive maps, real-time recommendations, hotel booking, and AI-powered chat in one place. It allows users to find interesting places, see what friends recommend, book accommodation, and chat with an AI assistant, all without switching apps.
We began working with Gobi to improve its mobile interface and map experience, with an initial focus on Android. What started as focused improvements grew into a technology partnership, with our team and Gobi’s engineers migrating both mobile apps to native development together.
Together, we moved Gobi from React Native to native iOS and Android apps while continuing to develop its discovery, messaging, sharing, and AI assistant features.
- Mobile architecture and migration
- Native iOS and Android development
- Map integration and optimization
- Product development and API integration
- UI and interaction testing
- Swift
- SwiftUI
- UIKit
- Kotlin
- Jetpack Compose
- Mapbox Maps SDKs
- Stream Chat
- TypeScript
- Next.js
- tRPC
Challenges & goals
Gobi combines several demanding experiences in one interface. The work needed to:
- Make the map and its overlapping panels work together as people scroll, search, and explore.
- Move the app to native development in stages, alongside ongoing product work.
- Keep the experience consistent across iOS and Android, including loading, permissions, and recovery when something goes wrong.
Improving the experience around the map
In Gobi, the map is more than a way to display search results. It remains visible as people open place details, browse recommendations, and move between activities. The draggable panels above it, known as bottom sheets, are central to how people use the app.
Our early work improved that experience within the existing React Native app. We built Software Mansion’s React Native Bottom Sheet library specifically to meet Gobi’s needs. In under two weeks, we built the initial version and integrated it into Gobi, replacing the previous bottom-sheet library. We later evolved the library to handle gestures and animations natively, giving us more control over how stacked panels work with the map.
Mapbox already rendered the map natively. We delivered a custom integration with its SDKs in one month, giving us direct control over how the map responds to navigation and displays places, people, and events. Further work moved marker updates into native code, so moving the map no longer required JavaScript to repeatedly rebuild and resend its markers.
The map and sheet work established native components that we could build on as the rest of the app evolved.
Migrating the app in stages
As more of Gobi’s interactions moved into native code, bringing navigation into the same layer gave the app direct control over how its map and panels worked together. This suited Gobi’s heavily customized interface, where opening a panel also changes the visible map and closing it needs to restore the previous view.
The migration built on the existing React Native app. First, we replaced the content inside individual panels with native implementations. Next, native navigation took over, with the remaining React Native content running inside it. We could then replace those remaining pieces progressively.
This approach let us move different parts of the app at different times. Messaging, place details, and the assistant could each progress without waiting for every other feature to be rewritten. It also gave us an existing experience to compare against as we worked.
The work extended beyond visible screens. Sign-in, saved places, notifications, and background tasks also had to move, so people could continue using their accounts and content across the app. We completed the migration by removing the React Native and Expo runtimes from the mobile codebase.
Both apps now run natively: Swift and SwiftUI on iOS, and Kotlin and Jetpack Compose on Android. The transition also changed how client updates are delivered: new code now ships in app releases rather than through JavaScript over-the-air updates.
Developing the features people use every day
Alongside the native migration, we kept working with Gobi’s team on how people discover and share places, adapting existing features to native development and shipping new capabilities.
Our contributions to native messaging included voice messages, replies, reactions, and group-management tools. Shared place and event cards connect those conversations to discovery, so people can move from discussing somewhere to exploring it in the app.
For stories, we built native creation and media-viewing flows, with upload progress and retry options that remain visible as people continue browsing. We also changed how the app finds nearby photos: an on-device location index helps it find relevant images without scanning the whole library every time the picker opens.
We developed the native interfaces for Ask Gobi, the app’s conversational assistant. People can ask questions using text, voice, or media, read answers as they arrive, and explore places and maps within the conversation.
Connecting discovery to the next action
Finding somewhere interesting is only part of the experience. People also need ways to save it, share it with friends, or take the next step toward visiting.
Our work included native sharing and import flows, helping people bring places into Gobi, review the results, and organize what they want to keep. We also contributed to place information and social features, including awards, comments, and likes.
For actions outside Gobi, we built connections to directions, rides, ordering, and ticketing services. These flows can open a supported app or provide a web alternative, depending on the service and what is available on the device.
The scope connected discovery with practical actions, both within Gobi and through the services people already use.
Keeping the experience consistent across platforms
Moving to native meant maintaining separate iOS and Android implementations. We used shared colors, typography, and icons, along with common descriptions of expected behavior to keep the apps aligned, while allowing each platform to handle its own interactions.
We checked both appearance and behavior. Comparing equivalent screens helped catch differences in layout and typography; interaction checks covered what happens when someone scrolls, opens the keyboard, closes a panel, or returns to the map.
We also standardized empty and error states across features, with clear actions for retrying a request, changing permissions, or reporting a problem. That work made recovery part of the interface rather than leaving each feature to handle it differently.
The native apps share a consistent product experience, with reusable components and checks to support work across both platforms.
Can you believe you can hire these guys? The Software Mansion guys? The guys with their logo on every package? It feels too good to be true, but it’s true.
Results
Our collaboration with Gobi’s engineers has delivered:
- A completed migration to native apps on two platforms, built around Gobi’s persistent map and bottom-sheet interface, with the React Native and Expo runtimes removed
- An initial bottom-sheet library built and integrated in under two weeks, replacing Gobi’s previous library with one tailored to its interface
- A custom Mapbox integration delivered in one month, giving the team direct control over map behavior and a foundation for the wider migration
- Continued product development throughout the migration, with contributions to messaging, stories, Ask Gobi, sharing, imports, and external-service connections
