I am building Nimpu Spatial to solve a very specific last-mile problem: a normal map pin can get someone near an address, but it often does not tell them the exact gate, entrance, apartment door, pickup counter, or handoff point.
Why map pins are not always enough
Most delivery flows already have addresses, GPS coordinates, and map navigation. That is useful, but it is still approximate. In many apartments, gated communities, campuses, and office buildings, the final few meters are the confusing part.
The driver may reach the correct building and still be unsure which gate to use, which entrance is open, or which door is the actual drop-off point. This is the gap Nimpu Spatial is trying to cover.
What Nimpu Spatial adds
Nimpu Spatial lets one user save an AR pin at a real physical spot, and lets another user find that same spot later. The idea is not to replace maps. Maps are still useful to get nearby. The SDK helps after that, when the user needs the exact place.
The flow is simple: create a pin at the exact spot, upload it to your Nimpu Spatial project, share a normal URL, and resolve it later in the Android app.
A pin can be created by scanning the spot, placing the AR pin, and saving it for sharing.
Creating a pin
In the create flow, the user stands at the exact place they want someone to find later. This could be a house gate, apartment door, shop counter, loading bay, or pickup point.
The app asks them to scan briefly and move around the pin so the SDK can build a stronger local map. Once the pin is saved and uploaded, it can be shared like a normal link.
In the screenshot, the sector ring is a simple way to show scan coverage around the pin. As the user moves left and right, more sectors get covered. The changing colors are basically feedback that the SDK has seen the pin area from more angles, which usually gives the resolve flow a better chance later.
The geospatial accuracy text is the coarse location side of the flow. "Strong" accuracy means the phone can attach a useful rough location to the pin. During resolve, that rough location helps bring the user near the saved place. Once they are close enough, AR takes over and finds the exact spot.
What the scan captures
One important detail is that this is not just placing a red 3D object on the camera view. During create, the SDK is looking at the environment around the pin and saving information that can help identify that place again.
In simple terms, the create scan captures visual features around the door, floor, wall, gate, counter, or whatever is near the pin. Later, during resolve, the SDK tries to match what the camera is seeing now with what was saved earlier. When enough of the saved place is recognized, the app can render the final AR pin at the physical spot.
That is why the guided scan asks for movement and multiple angles. It is trying to create a more useful memory of the spot, not just remember a latitude and longitude.
How the SDK fits in
From an Android developer's point of view, the host app keeps the surrounding product experience. Nimpu Spatial SDK provides the create and resolve flows, and the saved pin is uploaded in the background so it can be opened again from a shared link.
The app embeds the SDK, creates a pin, uploads it in the background, shares a URL, and resolves the same spot later.
// SDK initialization
NimpuSpatialSdk.initialize(
context = applicationContext,
config = NimpuSpatialConfig(
apiKey = "YOUR_PROJECT_API_KEY"
)
)
Resolving the pin
When someone opens the shared link, the app can guide them near the saved place first. Once they are close enough, the AR resolve flow searches for the saved visual spot and shows the final pin at the exact physical location.
This is where the two-stage idea matters. When the user is far away, the app should not pretend that AR can identify a door from hundreds of meters away. The rough location helps them approach the area first. Then the precise visual search starts when they are close enough to scan the saved surroundings.
Resolve stages
The resolve screen can change based on distance. When the user is very far or far, the goal is simply to guide them toward the saved area. When they are nearby, the app can show a larger approximate pin so they know which direction to move in.
The precise search starts near the saved place, where the camera can actually see useful details from the environment. At that point, the SDK looks for the visual match from the create scan. If the match fails, the app can allow the user to restart search instead of making them leave the flow.
The large pin is for approach guidance. The final red AR pin appears only after precise visual resolve.
A short resolve flow: open the shared pin, get nearby, and lock onto the exact AR spot.
Practical notes
This is still an early SDK, so I would not describe it as magic. AR quality depends on the device, lighting, movement, camera quality, and how visually distinct the place is. The best pins are created at the actual spot someone needs to find.
But for workflows where the last few meters matter, this approach can add a missing layer on top of maps: not just where the building is, but where the person should actually go.
Try it or inspect the SDK
The public Android SDK repo includes setup docs, the SDK wrapper, and a runnable sample app. There is also a short public demo page showing the create/share/resolve idea in action.
Top comments (0)