Ditching the Basemap: Open Source Maps and Vector-Only Overlays

Every spatial application begins with the same assumption: you need a basemap. You need streets, terrain, administrative boundaries, coastlines — the geographic canvas on which your data is painted. This assumption is so deeply embedded in GIS culture that it is rarely examined.

It should be. For many applications, the basemap is a significant source of cost, complexity, vendor dependency, and visual noise — and the data it provides is either free with a little effort, unnecessary for the use case, or actively counterproductive for legibility.

This article examines the full range of basemap options from free open source to commercial, and then makes the case for the subset of applications where the smartest choice is to deliver no basemap at all.

# The Basemap Landscape

# OpenStreetMap: Free but Read the Terms

OpenStreetMap (OSM) is a freely editable global map maintained by a community of millions of contributors and available under the Open Database Licence. The data itself — road networks, buildings, POIs, land use, administrative boundaries — is free for any use with attribution.

However, the tile service at tile.openstreetmap.org — the familiar slippy map tiles many developers use in testing — is not free for production use. The OSM Foundation explicitly prohibits bulk tile downloads and high-traffic use of their servers. The usage policy states that the service is intended for low-volume personal and development use, and that production applications must use an alternative tile provider.

This is a source of significant confusion. The data is free and open. The OSM Foundation’s tile rendering service is not an appropriate production dependency. The distinction matters.

Legitimate free uses of OSM data:

• Self-hosting tiles from your own PostGIS + TileServer GL stack
• Pre-generating PMTiles from OSM extracts (e.g. via GeoFabrik downloads)
• Using OSM data with cloud-native rendering pipelines

Tile providers that use OSM data and are free for limited use:

• Stadia Maps (free tier: 200,000 tile requests/month, no attribution required beyond OSM)
• MapTiler Cloud (free tier: 100,000 tiles/month)
• Carto (free tier for open data projects)

# ESRI Basemaps: Surprisingly Accessible

Esri provides a set of basemap services through ArcGIS Living Atlas that are free to use with an ArcGIS Developer account for low-volume applications:

• https://basemaps.arcgis.com/arcgis/rest/services/World_Basemap_v2/VectorTileServer
• https://basemaps.arcgis.com/arcgis/rest/services/World_Imagery/MapServer (satellite)
• https://services.arcgisonline.com/ArcGIS/rest/services/... (various styles)

The free tier provides 2 million tiles per month with an API key, after which per-tile costs apply. For low-traffic applications, Esri basemaps are a legitimate free option with high-quality global coverage. The satellite imagery basemap in particular is very high quality — Esri sources from WorldView and other premium imagery providers.

Cost at scale: $0.15 per 1,000 tiles beyond the free tier. At moderate traffic (100,000 sessions/month, 50 tiles per session), that is approximately $750/month — comparable to commercial alternatives.

# Google Maps Platform

Google Maps tiles are the most familiar basemap globally, but pricing has changed significantly since 2018. The dynamic maps pricing model charges per map load ($7 per 1,000 after the $200/month free credit). For applications with moderate to high traffic, Google Maps costs escalate quickly.

Google also has restrictive terms of service regarding what can be overlaid on their maps and prohibits certain categories of application (some analytics, competitive mapping products). These restrictions are genuinely material constraints for data-rich spatial applications.

For most new projects, there is no compelling technical reason to use Google Maps tiles when the open source alternatives are this capable.

# Self-Hosted OSM: The Right Architecture for Production

For production applications with meaningful traffic, self-hosting is the most cost-effective basemap solution. The recommended stack:

Data: Download the relevant GeoFabrik OSM extract (country or region). Whole-planet is 70+ GB; most regions are a few GB.

Tile generation: Import into a PostGIS database using osm2pgsql, then generate vector tiles using tilemaker or run a TileServer GL instance with OpenMapTiles vector tiles.

Serving: Host as PMTiles on S3 with CloudFront, or run TileServer GL on a small VM.

Style: Use one of the many open MapLibre GL styles designed for OpenMapTiles data. Positron (light), Dark Matter (dark), OSM Bright, Toner, and Terrain are available under open licences.

The economics are compelling. Serving a national basemap to 1 million monthly users from self-hosted PMTiles on S3 + CloudFront typically costs £20–£80/month, regardless of tile request volume (CDN cached). A third-party tile provider charging per-request at the same volume would cost hundreds to thousands of pounds.

// MapLibre GL JS with self-hosted PMTiles basemap
import maplibregl from 'maplibre-gl';
import { Protocol } from 'pmtiles';

const protocol = new Protocol();
maplibregl.addProtocol('pmtiles', protocol.tile.bind(protocol));

const map = new maplibregl.Map({
  container: 'map',
  style: {
    version: 8,
    glyphs: 'https://fonts.openmaptiles.org/{fontstack}/{range}.pbf',
    sprite: 'https://openmaptiles.github.io/positron-gl-style/sprite',
    sources: {
      openmaptiles: {
        type: 'vector',
        url: 'pmtiles://https://cdn.example.com/basemap-uk.pmtiles',
        attribution: '© OpenStreetMap contributors'
      }
    },
    layers: [ /* Positron or Dark Matter style layers */ ]
  }
});

# Protomaps / PMTiles: The Whole Planet for ~$10/Month

The Protomaps project offers a pre-built whole-planet PMTiles archive based on OSM data, updated weekly. The file is approximately 110 GB. Hosted on Cloudflare R2 (which has free egress to Cloudflare’s CDN), serving global basemap tiles costs approximately £8–£12/month in storage, with egress effectively free via Cloudflare’s CDN.

This is perhaps the most cost-effective production basemap option available. For applications that can tolerate weekly data freshness (which is most applications — not many mapping products need hourly OSM updates), it is the rational default.

# The Case for No Basemap

Now to the more provocative claim: for a significant subset of spatial applications, a basemap is not just unnecessary — it is actively harmful.

# When Basemaps Add Noise, Not Signal

Consider a map showing mobile network coverage blackspots across a country. The analytical content is the coverage zones — the data your organisation generated or purchased. The streets and building footprints beneath them are potentially useful for orientation, but they are also visual clutter that competes with the data.

At a national overview zoom (where the pattern of blackspots is the insight), streets are too small to see and add nothing. At a regional zoom, the street network may help a user understand why a blackspot correlates with a geographic feature (no coverage in this valley because of the topography), but this is a navigation aid, not an analytical requirement.

At the zooms where location context genuinely matters — “is my house in a blackspot?” — the user already knows where they are. A satellite or road basemap may help orient them, but a simple minimal style (just the coastline and perhaps county boundaries) might serve just as well at a fraction of the cost.

# Building a Vector-Only Coverage Blackspot Map

The minimal approach: serve only your coverage data as a MapLibre GL fill layer, with a very simple background style showing just coastal boundaries:

const map = new maplibregl.Map({
  container: 'map',
  style: {
    version: 8,
    // No external basemap source — just our data
    sources: {
      coverage: {
        type: 'vector',
        url: 'pmtiles://https://cdn.example.com/mobile-coverage.pmtiles'
      },
      // Minimal boundary context from Natural Earth (public domain, ~200KB)
      boundaries: {
        type: 'geojson',
        data: 'https://cdn.example.com/uk-outline.geojson'
      }
    },
    layers: [
      // Dark background
      {
        id: 'background',
        type: 'background',
        paint: { 'background-color': '#0a0e1a' }
      },
      // Land area from Natural Earth outline
      {
        id: 'land',
        type: 'fill',
        source: 'boundaries',
        paint: {
          'fill-color': '#111827',
          'fill-outline-color': '#1e3a5f'
        }
      },
      // No coverage areas (blackspots) — bright
      {
        id: 'no-coverage',
        type: 'fill',
        source: 'coverage',
        'source-layer': 'coverage',
        filter: ['==', ['get', 'signal_level'], 0],
        paint: {
          'fill-color': '#ff4444',
          'fill-opacity': 0.8
        }
      },
      // Good coverage — dim
      {
        id: 'good-coverage',
        type: 'fill',
        source: 'coverage',
        'source-layer': 'coverage',
        filter: ['>', ['get', 'signal_level'], 2],
        paint: {
          'fill-color': '#00e5ff',
          'fill-opacity': 0.15
        }
      }
    ]
  }
});

This map loads two very small assets — the PMTiles coverage archive and a tiny country outline GeoJSON — and renders a publication-quality analytical map with no per-tile commercial costs, no API keys, no rate limits, and no visual noise.

# Traffic Speed Zones: The Same Logic

A traffic speed zone map — showing average speeds or speed compliance rates by road segment — has the same structure. The data is the road network. Adding a basemap that also contains the road network doubles the visual weight of roads on the map and makes the colour encoding of your data harder to read.

The right approach: serve your speed data as a MapLibre GL line layer with width and colour encoding the speed values, over a minimal dark background. No basemap required. Add subtle administrative boundaries for orientation context. The result is cleaner, faster, cheaper, and more legible.

# A Decision Framework

The default assumption — that all maps need a full-featured basemap — costs money, adds complexity, and often reduces analytical clarity. Evaluating each application on its actual orientation needs is worth the effort.

Related reading: Vector Tiles and the Modern Web Mapping Architecture · The Open Source Geospatial Stack · Low-Cost, High-Flexibility Spatial Architecture Patterns