A store locator and a delivery tracker can both put a blue dot on a map. From a development perspective, though, they have very little in common.
The store locator might request a position once, find the nearest branches, and stop. The delivery app may need to follow a driver for an hour, send coordinates to a server, and keep doing it after the screen is locked. Add iOS and Android support, and seemingly simple location-based features can
turn into two sets of permissions, background behavior, native configuration, and edge cases.
This is where the architecture matters. Teams that want to ship on iOS and Android from one codebase can share much of the application logic with React Native, but geolocation still touches native services underneath. The useful question is not whether everything can be shared. It is which parts should be.
“We Need the User’s Location” Is Not a Requirement
Before choosing a mapping SDK or installing a location library, define what the product actually needs from the device.
Take a retail app. If its only job is to show nearby stores, it may request the customer’s position when they open the locator. Keeping GPS active after that would add complexity and consume power without improving the feature.
Uber or DoorDash has a different problem. The position of a driver or courier changes constantly, and other people need to see those changes quickly enough for the map to remain useful. Now update frequency, background execution, connectivity, and server load all become part of the design.
Accuracy has similar consequences.
Android distinguishes between approximate and precise location. According to current Android documentation, approximate data from its location services is accurate to roughly 3 square kilometers, while precise positioning is usually within about 50 meters and can sometimes get within a few meters.
Users can choose approximate access even when an app asks for precise location.
Apple makes a similar distinction. With reduced accuracy, iOS typically preserves the user’s city while providing a position within roughly 1–20 kilometers of their actual location. Apple also warns developers that requesting greater accuracy can use more power and take longer to produce a result.
A weather app can live with that uncertainty. Curbside pickup probably cannot.
Decide how accurate the position must be, when it should be requested, how long tracking should continue, and whether the feature still works without it. Those decisions shape the implementation far more than the choice of map library.

A Map and Geolocation Are Two Separate Pieces
They often appear together on the screen, which makes them easy to treat as one feature.
They are not.
Geolocation answers a question such as “Where is this device?” Map integration deals with displaying geographic information. A map might show the user’s position, but it could just as easily display stores returned for a ZIP code, a delivery area drawn by an administrator, or a route supplied by a
backend service.
Keeping those responsibilities separate pays off later.
Suppose a retailer currently uses the phone’s position to find nearby branches but later wants customers to search around a manually entered address. The store-search logic should not care whether its latitude and longitude came from Core Location on iOS, Google’s Fused Location Provider on
Android, or a geocoding API.
The same principle applies to mapping providers. If calls to Google Maps Platform are scattered through screens and business logic, switching a service or adding another provider becomes a larger project than it needs to be.
Share the Store-Finding Logic, Not the OS Behavior
Cross-platform mobile app development can remove a lot of duplicate work, but location is a good example of where the abstraction eventually ends.
Imagine an app that finds the five nearest pharmacies. Once it has coordinates, most of the workflow can be common to both platforms: send the coordinates to an API, receive nearby locations, sort or filter the response, update application state, and render the results.
That belongs in the shared codebase.
Getting those coordinates is different. React Native ultimately has to communicate with Apple’s Core Location framework on iOS and Android location services on Android, whether that happens through a library or custom native code. Permissions and background behavior also follow the rules of the
underlying operating system.
Trying to hide every difference behind identical code can make the implementation harder to reason about. The cleaner boundary is usually a small platform-facing layer that gives the rest of the application a consistent interface.
The application asks for a position. The platform layer figures out how to get it.
That approach does not produce a 100% shared application, and it does not need to. The expensive duplication is usually business logic, screens, networking, state management, and feature behavior, not a limited amount of native configuration.
Permission Denied Is a Normal State
Location permissions are easy to treat as a technical prerequisite: ask for access, get coordinates, continue.
Real users make that flow less tidy.
They can deny access. They can allow an approximate position instead of a precise one. They can change the permission later in Settings. Location services can be disabled at the device level.
The product needs an answer for each of those states.
For a coffee shop finder, denying access does not have to end the journey. Let the user enter a neighborhood, address, or ZIP code instead. If precise positioning is genuinely necessary, explain why when the feature needs it rather than requesting maximum access as soon as the app launches.
Android explicitly recommends designing apps to work with approximate access when the use case permits it. On Android 12 and later, the user can choose approximate location even when the application requests precise access.
iOS applications also need to account for reduced accuracy. When a user has authorized only reduced location accuracy, asking Core Location for greater precision does not override that choice.
This is one place where forcing iOS and Android into exactly the same implementation is counterproductive. The product behavior can be consistent while the permission flow respects each platform.
Every Pin on the Map Can Have a Cost Behind It
The map itself is rarely the whole integration.
A product might turn coordinates into street addresses, search for places, calculate routes, estimate travel times, or find distances between many origins and destinations. Those operations often call paid APIs.
Google Maps Platform, Mapbox, HERE, and other providers have their own services and pricing models. With Google Maps Platform, for example, Maps, Routes, Places, and related APIs are billed according to their respective usage rules rather than as one unlimited “Google Maps” service.
That matters once traffic grows.
Imagine a delivery app recalculating a route every few seconds for thousands of active orders. Or a property app reverse-geocoding the same coordinates whenever a component rerenders. Both can generate API calls that add little value.
The architecture should make unnecessary requests easy to avoid. Stable results can sometimes be cached. Duplicate calls can be removed. Some calculations may belong on the backend, particularly when multiple clients need the same result or an API key should not be exposed in the mobile
application.
Before committing to a provider, model how the feature will actually use its APIs at expected traffic levels. A map integration that looks inexpensive in a prototype can have a very different cost profile in production.
Background Tracking Is a Different Class of Feature
Getting the user’s position after they tap “Use my location” is relatively contained. Following a courier while the app is no longer on screen is not.
Background tracking introduces another set of constraints: how frequently the app requests updates, what happens when the operating system limits background activity, how much battery the feature consumes, and how coordinates reach the server when the network is unreliable.
Android treats background location as a separate permission. On Android 10 and later, applications requesting it must declare ACCESS_BACKGROUND_LOCATION, and Google Play restricts background access to apps where it supports core functionality.
There is also no universal “correct” update interval.
A navigation app needs fresher data than an application that records the approximate location of a field technician every few minutes. More updates can improve freshness, but they also mean more location work on the device, more network traffic, and more events for the backend to process.
Connectivity complicates this further. A courier can drive through an area with poor mobile coverage while the phone continues receiving location data. If the trip record matters, the app may need to queue coordinates locally and synchronize them later.
This is where location-based features stop being a map problem and become a distributed-systems problem.

Simulators Won’t Show You the Whole Problem
A simulated route is useful during development. It cannot reproduce everything that happens to a phone in somebody’s pocket.
GPS can drift between tall buildings. Indoor positioning may be poor. A user can revoke precise access halfway through the product’s lifetime. Mobile data can disappear during a trip. Android may restrict background work to save power.
Testing therefore has to go beyond checking whether a marker moves.
For a delivery tracker, an old position should not quietly look current when updates stop arriving. For a store locator, failure to get the device’s position should lead to another way to search. If a map service is temporarily unavailable, the rest of the app should not necessarily become
unusable.
Those cases deserve attention before release because users will encounter them eventually.
One Codebase Does Not Mean Zero Platform-Specific Work
There is no useful architecture in which iOS and Android suddenly become the same operating system.
A cross-platform framework can keep product logic, UI, networking, state, and many location workflows in common code. Native configuration still belongs where the platforms differ. Location permissions are one example; background execution and some SDK behavior are others.
That is a reasonable tradeoff.
The aim is not to remove every line of platform-specific code. It is to keep those lines at the edges, so adding a store locator, service-area map, or live tracking feature does not create two independent versions of the product.