Cloud-Native Web Mapping: PMTiles, Martin & PostGIS

Why Monolithic GIS Servers Are Failing Modern Applications

GeoServer deployments require deliberate JVM memory configuration. Its official production guidance documents heap sizing, garbage collection, and related Java settings that add state and capacity planning to an otherwise elastic cloud deployment.

Cloud-Native Geospatial Formats: The Foundation

The paradigm shift does not just replace one server with a faster one. It removes the server entirely for the majority of use cases, leveraging a class of cloud-native file formats built around HTTP range requests.

The OGC Cloud Optimized GeoTIFF standard established this methodology for raster data. The GeoParquet specification brings interoperable geospatial types to columnar analytics, while FlatGeobuf documents its HTTP range-request and spatial-indexing model.

PMTiles: The Gold Standard for Static Map Delivery

For spatial data with update cycles measured in days, weeks, or months, PMTiles is the premier static delivery mechanism. The PMTiles v3 specification defines a single-file tile archive whose directories and tile payloads can be retrieved with HTTP range requests, completely bypassing tile servers.

Infrastructure Economics: Escaping the Egress Trap

PMTiles’ technical brilliance only matters if you can serve it economically at scale. Traditional hyperscale cloud providers charge punishing egress fees on high-traffic range queries.

Dynamic Data: Rust-Powered Vector Tile Microservices (Martin)

When data updates in real time, static PMTiles are paired with dynamic tile servers. Martin, written in Rust and maintained under the MapLibre organization, generates vector tiles directly from PostGIS functions with zero JVM overhead.

# Martin configuration (config.yaml)
postgres:
  connection_string: 'postgresql://postgres:secret@db.internal:5432/spatial_db'
  auto_publish:
    tables:
      from_schema: 'public'
    functions:
      from_schema: 'public'

pmtiles:
  sources:
    basemap: '/data/planet.pmtiles'

PostGIS Optimization: The ST_AsMVT Pipeline & Dynamic LOD

PostGIS aggregates binary Mapbox Vector Tiles using ST_AsMVT() and transforms planar geometry into screen-space tile coordinates with ST_AsMVTGeom().

However, querying full-resolution geometries at low zoom levels produces multi-megabyte MVT payloads that choke network bandwidth and exhaust client WebGL memory. Production pipelines implement Zoom-Dependent Level of Detail (LOD) using ST_SimplifyPreserveTopology() with dynamic pixel tolerance:

-- Martin Custom Function: Generates optimized vector tiles with dynamic LOD
CREATE OR REPLACE FUNCTION public.get_parcels_tile(
  z integer, x integer, y integer
) RETURNS bytea AS $$
DECLARE
  tile_bbox geometry;
  pixel_tolerance float8;
  result bytea;
BEGIN
  -- Generate EPSG:3857 bounding box for current tile
  tile_bbox := ST_TileEnvelope(z, x, y);
  
  -- Calculate meters per pixel at this zoom level (Web Mercator)
  pixel_tolerance := (40075016.68 / (256 * (2 ^ z))) * 0.5;

  WITH mvt_data AS (
    SELECT
      ST_AsMVTGeom(
        -- Simplify vertex density to pixel resolution; preserve topology
        ST_SimplifyPreserveTopology(geom, pixel_tolerance),
        tile_bbox,
        4096, 64, true
      ) AS mvt_geom,
      id,
      name,
      -- Omit granular property attributes at coarse zooms to minimize byte weight
      CASE WHEN z >= 14 THEN parcel_type ELSE NULL END AS parcel_type,
      CASE WHEN z >= 14 THEN assessed_value ELSE NULL END AS assessed_value
    FROM parcels
    WHERE geom && tile_bbox
      -- Filter out micro-polygons smaller than 4 screen pixels at current zoom
      AND (z >= 14 OR ST_Area(geom) > (pixel_tolerance * pixel_tolerance * 4))
  )
  SELECT ST_AsMVT(mvt_data.*, 'parcels', 4096, 'mvt_geom')
  INTO result
  FROM mvt_data
  WHERE mvt_geom IS NOT NULL;

  RETURN result;
END;
$$ LANGUAGE plpgsql STABLE PARALLEL SAFE;

Architecture Comparison: Legacy vs. Cloud-Native

Modern web mapping replaces bloated monolithic servers with lightweight, single-purpose primitives:

Multi-Tiered Caching: The Final Performance Layer

Vector tile URLs are completely deterministic. Modern pipelines deploy multi-tier caching across CDN edges, Nginx reverse proxies, and Martin's internal memory cache.

Frequently Asked Questions