The Map Is the Product: Why We Left Google Maps for Mapbox

A mapping SDK looked like a small decision for our passenger app. It ended up shaping the Twende Simulation Engine, and it taught us that a mobility company can't afford to rent its map.

8 min read

Ask for directions in most of Africa's fast-growing secondary cities and you will rarely hear a street name. You will hear about the roundabout, the church with the blue gate, the petrol station before the hill, the turn after the market where the road goes bad when it rains. These cities have maps. They just don't live where the big platforms expect them to.

These are the cities we're building Twende for. We're launching in the DRC and Uganda, then expanding across East and Central Africa, with one goal: to be Africa's answer to safe urban mobility. That's why a decision that looked like a line item on our backlog, "pick a map SDK for the passenger app", ended up shaping the core of everything we've built since.

This is the story of why we moved from Google Maps to Mapbox, what we found on the other side, and the opinion we came out with: a mobility company that rents its map is renting its product.

A ride-hailing company is a map company

Strip a ride-hailing app down to its essentials and almost everything left is spatial. Where is the passenger? Which driver is closest by road, not as the crow flies? What route will they take, and how long will it take? Where does the fare come from? Twende's prices are fixed and computed from the route, so the answer to that last one is literally a line drawn on a map.

The map isn't the background of the product. It's the surface every decision gets made on: by the rider choosing a pickup point, by the driver following a route, by us when we work out why a request in one neighbourhood took three minutes to match and one in another took twelve.

So when we chose our mapping stack, we weren't really choosing a component. We were choosing how much of our own product we'd be allowed to see, shape and change.

What Google gets right

We want to be fair here, because the lazy version of this article says "Google bad, Mapbox good," and that isn't true.

Google Maps is an extraordinary product. Its places database, its geocoding, its search ("find me a pharmacy near here") are years ahead of anyone else in most of the world. Most of your users already know its interface. Its mobile SDKs are mature, and for a lot of apps that just need to show a pin and a route, it's the obvious and correct choice.

The old criticism that Google serves flat raster images while everyone else renders vectors is out of date, too. Google has shipped WebGL vector maps, with tilt and rotation, for years now.

If your app treats the map as a feature, use Google and don't look back.

Our problem was that, for us, the map isn't a feature.

Where Google stops being yours

Google sells you answers. You ask where something is, how to get there, how long it takes, and you get back a polished result drawn in Google's way, on Google's map, under Google's terms.

That's wonderful until you want to ask a question Google didn't anticipate.

You can restyle the map, but you don't own the style. Google gives you map styling, but it's a set of controls on a product Google designs. We wanted to decide, per layer and per zoom level, what a driver sees at 6am in heavy rain compared with a rider booking from a café. And we wanted that style to be a file in our repository, reviewed and versioned like the rest of our code.

The data comes with a leash. Google's terms restrict how content from its services can be used alongside maps that aren't Google's. In practice, once your routes, places and geocoding results come from Google, your rendering layer has to as well. Each API you adopt makes the next decision for you.

The map is a black box at exactly the layer we care about. We didn't just want to put markers on a map. We wanted to treat the map as a rendering engine, pushing thousands of moving points, routes and zones through it and controlling how each one is drawn.

None of this makes Google a worse product. It makes it a different kind of product from the one we needed.

What Mapbox gave us

Mapbox sells you primitives: vector tiles, an open style specification, a GPU renderer, and a routing API that returns plain GeoJSON. It answers fewer questions for you, and in exchange it lets you ask your own.

Our passenger and driver apps both run on Mapbox's React Native SDK. Here is what changed once we committed.

3D maps

A pitched, three-dimensional camera isn't a gimmick for a driver. It's how a human actually reads a road ahead. Our driver app ships three camera modes, and they're barely a dozen lines of configuration:

export const CAMERA_MODES = [
  { id: "driving",   pitch: 55, mode: FollowWithCourse, show3D: false },
  { id: "street-2d", pitch: 0,  mode: Follow,           show3D: false },
  { id: "real-3d",   pitch: 60, mode: FollowWithCourse, show3D: true  },
];

"Driving" follows the vehicle's heading at a tilt, like a satnav. "2D" is the flat overview you want when you're scanning the city for your next ride. "Real 3D" extrudes buildings, which matters more than you'd think in cities where "the tall building after the bank" is a genuine set of directions.

High-density geometry

Routes, pickup points and live vehicles are all just data layers we style ourselves. When a trip starts, the route comes back from the Directions API as GeoJSON and is drawn as our own layer, not as a polyline the SDK draws however it likes. Because everything is data, we can stack a lot of it (many vehicles, many routes, zones and heatmaps) without the map turning into a slideshow.

GPU-accelerated rendering

Vector tiles are drawn on the device's GPU rather than shipped as finished images. For our users that means smooth panning and zooming on the mid-range Android phones that dominate our markets, and less data spent on every map interaction. Where people top up mobile data in small amounts, that isn't a nice-to-have. It's respect for someone's money.

Cost we can reason about

The honest version of the cost argument isn't "Mapbox is cheaper." Pricing on both platforms changes, and it depends heavily on what you call and how often. The real point is that our costs follow our architecture. We decide what gets cached, what gets rendered on the device, and which calls actually need to go to a server. We can model our bill from our own usage instead of discovering it.

The accident: the Twende Simulation Engine

Here's the part we didn't plan.

Once the map was a rendering engine we controlled, rather than a picture we were allowed to decorate, it stopped being only for riders and drivers. We started pointing it at ourselves.

Ride-hailing is hard to test. A single trip involves a passenger, a driver, live location updates, a matching decision, a route, status changes and a payment, all happening in real time between devices that are moving. You can't really test that with unit tests, and you can't put a hundred motorbikes on the road every time you change the dispatch logic.

So we built a place where we can watch it happen. The Twende Simulation Engine runs the platform on top of the same map our users see: simulated drivers moving along real roads, ride requests appearing, matches being made, routes being drawn and trips playing out from pickup to drop-off. When something behaves strangely, we don't read logs and imagine it. We watch it happen on the map.

It started as a debugging aid. It has become the way we visualize, test and run the ride-hailing system as a whole. One architectural decision about how to draw roads became the foundation for how we understand our own product.

That's what we mean by owning the map. Not that we drew the tiles ourselves, but that we can point the map at any question we have.

What we gave up

Every honest migration story has a cost column. Here's ours.

  • Search and places. Google's points-of-interest data is hard to beat. In secondary cities, where a lot of what matters (a moto stage, a market entrance, the gate of a compound) isn't in anyone's database, we lean on landmarks, pinned locations and what our own users teach us.
  • Familiarity. Google Maps is the map most people already know. A custom map has to earn its legibility through design.
  • A different kind of lock-in. Mapbox isn't a charity. In 2020 it moved its web renderer to a proprietary licence, and the community forked the last open version into MapLibre. We see that as a feature of the ecosystem, not a bug. The style specification and vector tile format are open, which means our exit is a migration, not a rewrite. With Google, there's no equivalent door.

Mapbox's base map is built largely on OpenStreetMap, which also means its knowledge of our cities is only as good as the community that maps them. Across many African cities, volunteer mappers have done remarkable work filling the gaps, and it's a debt we intend to repay as we grow.

Our opinion, stated plainly

If you're building a product where location is an input, use Google Maps. It's excellent and you'll ship faster.

If you're building a product where location is the product, such as ride-hailing, logistics, delivery or anything that moves through a city, then think very carefully before you hand your map to someone else. That choice will set:

  1. What you can see. You can only visualize what your map lets you draw.
  2. What you can test. Our simulation engine exists because the map was ours to point at our own system.
  3. What you can change later. Pick the stack where leaving is a migration, not a rewrite.

We didn't move to Mapbox because it was trendy, or even because it was cheaper. We moved because a mobility company building for Africa's cities has to understand those cities better than anyone. You can't do that through an interface designed to answer someone else's questions.

Ready to ride with Twende?

Join the waitlist and be among the first to experience safer, fairer transport in African cities.

Related posts