Learn Mappls by shipping something real.
Quick starts for first contact, production patterns for growing teams, and full stateful journeys for systems that run real operations.
Make it work
Your first successful integration, with the concepts made clear.
Put your first Mappls map on the web
Create a key, restrict it to localhost, load Web Maps JS, and add a marker.
Build address autocomplete that users trust
Debounce input, apply bias, handle keyboard selection, and retain the Mappls Pin.
Add Mappls to an Android app
Configure the repository and BoM, initialize the SDK, and manage MapView lifecycle.
Add Mappls to an iOS app with Swift Package Manager
Select distribution packages, configure credentials, and render the native map.
Create a zero-SDK location campaign
Build safe place links, add fallback behavior, instrument hand-offs, and test every device.
Build a server-side geocoding boundary
Resolve addresses on a trusted server, retain provider identity, and return a narrow application contract.
Turn a device fix into a trustworthy check-in
Reverse geocode accuracy-bearing coordinates, preserve consent, and distinguish evidence from an address label.
Generate static maps for receipts and notifications
Render bounded server-side map imagery with safe markers, caching, attribution, and fallback text.
Embed a place picker widget
Mount a bounded widget, synchronize selection with your form, and preserve the selected Mappls Pin.
Hand off to navigation with a resilient deep link
Encode a known place, protect campaign parameters, and provide browser and store fallbacks.
Make it useful
Compose products into a polished user experience.
Build a route preview with alternatives
Resolve endpoints, request alternatives, decode geometry, and explain toll/time trade-offs.
Create a nearby discovery experience
Combine category search, viewport updates, result cards, and map selection.
Give an AI agent grounded Mappls tools
Run the MCP server, scope credentials, call search and routing tools, and inspect provenance.
Call Mappls safely from a trusted server
Exchange OAuth client credentials, keep tokens in bearer headers, call typed Search and Route operations, preserve provenance, and bound retry.
Build a cross-platform React Native map
Install the native wrapper, configure both platforms, add annotations, and handle cleanup.
Build a Flutter map and place picker
Configure native keys, render the map, and return a validated place to your form.
Ship a Mappls map in Cordova and Ionic
Separate web and native configuration, wait for device readiness, and clean up plugin state safely.
Integrate Mappls into a Xamarin application
Configure platform projects, isolate credentials, bridge native lifecycle, and preserve location identity in shared code.
Rank responders with a distance matrix
Batch eligible origins, interpret unreachable pairs, apply deterministic tie-breaks, and keep dispatch explainable.
Build a traffic-aware commute assistant
Compare departure choices, refresh bounded route alternatives, and explain when an ETA becomes stale.
Render a governed GeoJSON operations layer
Validate geometry, assign stable feature IDs, style deterministically, and synchronize map and table selection.
Make it dependable
Operate state, scale, failure, and security in production.
Track a delivery with a trustworthy ETA
Join asset telemetry, map matching, route progress, ETA refresh, and customer visibility.
Automate a complete Workmate task lifecycle
Provision workers, dispatch jobs, consume transitions, enforce proof, and reconcile closure.
Build fleet geofence operations
Create zones, process enter/exit events, suppress noise, and power an exception queue.
Build a reproducible site-selection model
Publish layers, generate catchments, join signals, score candidates, and share results.
Design an interruption-safe offline map update
Verify packages, stage data, check compatibility, switch atomically, and roll back.
Provision and validate a remote MCP client
Approve exact authority, deliver a signed pre-registration event, inspect discovery, validate PKCE and resource binding, then revoke without transporting a token or secret.
Consume Mappls events exactly once in effect
Verify signatures, deduplicate deliveries, order per aggregate, retry, and replay safely.
Operate a Mappls client on embedded Linux
Separate runtime and map-data compatibility, stage updates, survive power loss, and expose health signals.
Reconcile a complete InTouch trip lifecycle
Create provider identity, consume event-time telemetry, own exceptions, and close only after provider acknowledgement.
Build proof review and rework for field jobs
Capture purpose-bound evidence, route weak submissions to review, request rework, and preserve decision history.
Qualify a Cordova location release
Pin bridge and native dependencies, prove lifecycle disposal, automate both release builds, and operate a browser fallback.
Operate deep links across every hand-off
Govern destination identity, universal-link association, privacy-safe attribution, fallback, expiry, and campaign retirement.
Production-harden a Flutter location feature
Lock Dart/native compatibility, control rebuilds and streams, test process recovery, and qualify Android and iOS independently.
Qualify an iOS Mappls release
Resolve package authority, bind credentials and entitlements, own controller generations, test privacy and background behavior, and prove rollback.
Build restart-safe iOS direction and geofence handoffs
Own native editor generations, validate route and geometry candidates, provide an exact navigation-link fallback, separate target acknowledgement and application review, and recover safely after restart.
Qualify React Native native parity
Freeze wrapper/native versions, normalize cross-platform results, constrain bridge traffic, recover process death, and release both native targets.
Operate widgets as untrusted lifecycle surfaces
Validate origin and schema, separate candidate from commit, recover blocked embeds, preserve accessibility, and retire safely.
Harden and migrate a Xamarin location feature
Inventory native dependencies, isolate shared state, qualify each renderer, add rollback, and prepare a controlled successor migration.