The Coe Lab
← Back to Opinion

Protomaps Makes Maps Portable. Your Deployment Still Needs a Plan.

By November 16, 202610 min read read
self-hostinginfrastructuremaps
A technology notebook with visual symbols for AI, cybersecurity, infrastructure, and automation

PMTiles makes self-hosted maps portable and simpler to run. Here is how to plan costs, data updates, browser dependencies, and reliable delivery.

Self-hosted maps are becoming a realistic option for projects that cannot justify operating a geographic database just to show a few locations. A Protomaps deployment write-up reached 352 points on Hacker News when checked on November 16, bringing renewed attention to a useful architectural shift: a basemap can be a versioned file rather than a permanent application service. For developers and homelab operators, the important question is not whether a map can load cheaply. It is whether the complete mapping feature remains affordable, reliable, and understandable after the first successful demo.

The Coe Lab's view is that PMTiles is most interesting as an operational simplification. Moving read-heavy data into an archive can remove an entire class of servers from a small application. It does not remove the need to manage data freshness, delivery behavior, licensing, or the external dependencies hidden in a browser. Treat this as a chance to make your system smaller, not as permission to stop designing it.

Background: the map is not one service

A website's map often appears to be a single component. In reality, it combines geographic data, tiled representations of that data, visual styling, fonts, icons, a rendering library, and sometimes search or route calculation. A commercial platform may bundle these pieces behind one account. That convenience makes it easy to mistake a tile delivery alternative for a complete replacement of the platform.

The official PMTiles concepts documentation describes a single archive containing tiled data, with readers retrieving relevant byte ranges over HTTP. Instead of downloading the entire archive, a compatible reader requests the portions needed for the current view. The format supports more than vector basemaps, but a conventional interactive basemap is a useful place to start. This is an established format receiving fresh attention, not evidence that an entirely new mapping stack appeared overnight.

That distinction matters when budgeting a migration. If your application only draws a regional background beneath your own markers, replacing a hosted tile dependency may be straightforward. If it also searches addresses, calculates journeys, or depends on a provider's proprietary place identifiers, changing the basemap addresses only one part of the problem. Write down those capabilities separately before comparing costs.

The broader infrastructure lesson is familiar: relatively static data and dynamic application behavior do not always belong in the same service. Separating them allows different update schedules, failure modes, and deployment processes. A basemap that changes periodically can be released like an asset while a rapidly changing vehicle position remains a live application record.

The architectural gain: fewer moving parts, clearer ownership

There are two useful delivery patterns to evaluate. A browser can read a PMTiles archive directly through a compatible client integration. Alternatively, an intermediary can translate conventional tile requests into reads from the archive. Protomaps documents CDN deployments with storage, a serverless translation function, and an edge cache. These patterns solve different integration problems; neither should be adopted merely because it appears in the first tutorial you find.

Direct archive access can be attractive for a new application where you control the frontend. It makes the stored file the central deployment artifact and can avoid maintaining your own tile translation service. A conventional tile endpoint can be more convenient when existing clients already expect coordinate-based URLs. In either case, identify which party operates every component and which failure you would have to diagnose yourself.

A practical benefit is reproducibility. Imagine an application whose map starts displaying unexpected labels after an update. If the deployed archive, style, and frontend versions are recorded together, you have a finite set of changes to inspect. You can compare yesterday's release with today's rather than asking whether a remote service changed underneath you. This is an operational advantage even when the monthly bill is already small.

Portability should still be tested rather than assumed. Copying the archive to another origin proves little if your application hardcodes storage-specific URLs throughout its style configuration. Keep the origin configurable, document response requirements, and run a staging map from a second location. A successful provider exit rehearsal is stronger evidence of portability than an architecture diagram.

Cheap storage does not define the cost of a map

The most tempting comparison is a storage bill against a per-map-load price. That comparison can be directionally useful, but it mixes different units. Self-hosting introduces storage, delivered bytes, requests, possible function execution, observability, and engineering time. A bundled platform may include capabilities your archive does not provide. Price the feature you actually use, not two differently scoped product labels.

For planning, use a simple model: monthly storage plus delivered gigabytes multiplied by delivery price, plus request or compute charges, plus an explicit allowance for maintenance. Then stress the inputs. Estimate an ordinary month, a publicity spike, and an abusive traffic scenario. There is no universal map-load size because browsing patterns, screen dimensions, zoom levels, cache state, and dataset choices all affect consumption.

Consider a deliberately hypothetical workload of 100,000 sessions transferring an average of 4 MB each. That is roughly 400 GB before accounting for the details of billing units. If extended exploration pushes the average to 16 MB, the same session count becomes roughly 1,600 GB. The point is not that either number describes your application. It is that session count alone cannot predict a bandwidth-based bill.

Cache measurement deserves equal care. A high cache-hit rate can reduce origin work without eliminating charges for bytes delivered to viewers. Conversely, a cold edge location may expose origin latency that users near your own machine never see. Measure the browser experience and the billable resources independently. They are related, but one dashboard cannot reliably stand in for the other.

For a homelab, the relevant cost may be residential upload capacity rather than an invoice. Hosting a public archive from home can compete with backups, video calls, and remote access. A small regional dataset on inexpensive external storage may be a better self-hosting choice than insisting every byte originate from your own hardware. Control comes from an understandable, replaceable design, not necessarily from physical proximity.

Range requests are part of the production contract

An archive-based map depends on delivery semantics, not just an accessible download link. Validate HTTP Range behavior through the exact public endpoint your users will access, including any proxy or CDN in front of storage. A test such as curl -i -H 'Range: bytes=0-16383' https://maps.example.com/region.pmtiles should return a partial response with a meaningful Content-Range header. The example domain is a placeholder, not a working tile service.

A successful partial request is necessary evidence, not a complete acceptance test. Also inspect content length, cache behavior, browser errors, and whether the final endpoint behaves consistently across repeat requests. If an intermediary mishandles ranges or transformations, a file that works locally may fail when deployed. Test the delivered representation rather than trusting the storage backend's advertised capabilities.

Cross-origin browser access is a separate concern. If the map page and archive have different origins, configure and test the applicable CORS policy. Do not confuse that with authorization: a browser's cross-origin restrictions do not prevent someone from fetching a public URL with another client. Referrer checks likewise should not be treated as strong protection against determined bandwidth abuse.

Decide how your application behaves if delivery becomes unavailable. A travel diary can show a clear map-unavailable message while retaining its written itinerary. An operational dashboard should preserve a useful table of locations or statuses rather than hiding all information behind a broken canvas. Designing a degraded view is often cheaper than trying to make every dependency infallible.

Data releases need the same discipline as application releases

PMTiles is read-only in the operational sense that updates require rewriting the archive rather than transactional in-place edits. That tradeoff suits a periodically refreshed basemap. It is not a reason to force constantly changing business data into the same artifact. Keep live inventory, incidents, and user-specific markers in a separate layer with an update mechanism appropriate to their freshness requirements.

The official getting-started guide shows how to inspect a source archive and extract a geographic area or limited zoom range. Use that capability to reduce scope before optimizing infrastructure. A community project covering one city rarely needs the operational footprint of a detailed global basemap. Define the supported area and zoom range as product requirements, then create an archive that matches them.

For production updates, prefer immutable filenames and a controlled reference change over overwriting an object while clients are reading it. Upload the new artifact, validate it, test the associated style, then switch the application configuration. Retain the previous compatible release for rollback. This recommendation follows from treating the map as a versioned artifact; it is not a promise that a particular hosting service will make every update atomic.

Record the source data timestamp, generation or extraction process, file checksum, and compatible style version. A date in the filename is helpful but does not explain when the underlying information was collected. Freshness should be visible to the operator and, where consequential, to the user. A polished map does not automatically imply current roads, current access restrictions, or suitability for navigation.

Privacy and completeness require a browser-level audit

Self-hosting the archive does not necessarily self-host the mapping experience. A style can still request fonts, sprites, or other sources from external hosts. Address search may send user queries to a separate provider. Analytics can reveal location-related interaction regardless of where the basemap resides. Inspect the network panel during a clean browser session, not just the backend configuration.

Make an inventory of every external hostname contacted when opening the map, zooming, searching, and selecting a marker. For an internal application, repeat the test with public network access blocked in a controlled environment. Missing glyphs and icons often reveal dependencies that an ordinary success-path demonstration overlooks. Do not describe a deployment as offline-capable until all required resources have been tested that way.

Keep sensitive overlays separate from publicly downloadable background data. A public basemap archive is not the place for private customer locations or internal infrastructure coordinates merely because the interface hides them at the initial zoom. Data delivered to a browser should be considered accessible to that browser's user. Enforce access controls before delivery, and avoid sharing caches for personalized responses without deliberate design.

Finally, account for attribution and licensing as release requirements. Check the obligations attached to the specific dataset, styles, fonts, and libraries you distribute, and preserve the required notices in the interface. Technical ownership of storage does not confer ownership of the underlying geographic information. This is another reason to inventory the complete stack rather than thinking only about one file.

What This Means: run a bounded migration experiment

For developers, the opportunity is to make a simple map feature independent of a large platform without rebuilding an entire geospatial business. For IT leaders, the decision is about staffing and dependency control as much as marginal delivery prices. For homelabbers, a regional archive offers a manageable experiment in artifact-based infrastructure. Each group benefits from measuring one representative workflow before committing to a broad migration.

Start with an acceptance checklist:

  • Choose one region, a supported zoom range, and a written freshness target.
  • Identify whether you need only a basemap or also search, routing, and live overlays.
  • Validate partial responses and cross-origin access through the real public endpoint.
  • Measure cold and warm browser loads, requests, transferred bytes, and rendering errors.
  • Inventory fonts, icons, styles, data sources, attribution, and external hostnames.
  • Rehearse a version upgrade, rollback, and temporary tile-service failure.
  • Set budget alerts and decide who responds when usage or latency exceeds expectations.

The result should be a short deployment record, not merely a screenshot of a working map. Include measured load behavior, the chosen archive's identity, expected monthly consumption, and a recovery procedure another person could execute. If the experiment shows that the existing hosted platform remains cheaper after labor and required features are included, that is a useful outcome rather than a failed self-hosting project.

Looking forward: portable data beats invisible complexity

The next thing to watch is not another impressive lowest-possible hosting bill. It is whether tooling makes map releases, dependency inventories, and end-to-end diagnostics easier for ordinary application teams. Better defaults around deployment validation would reduce the gap between a successful tutorial and a service someone can operate confidently. This is a prediction about useful engineering direction, not an announced product roadmap.

PMTiles illustrates a broader pattern worth applying elsewhere: package read-heavy data into portable artifacts, keep mutable application state separate, and make the delivery contract explicit. That pattern can reduce operational load without pretending that files eliminate infrastructure. For a small team, deleting an unnecessary service can be a more durable improvement than optimizing it indefinitely.

The practical takeaway is simple. Try a regional map, measure the real delivery path, and practice replacing it. If you can explain how the map updates, what it costs, which requests leave your control, and how it fails, you have gained something more important than cheap tiles: a mapping dependency you can actually own.

Sources and further reading

Hacker News discussion (352 points when checked)

Original deployment write-up

PMTiles concepts and format tradeoffs

Protomaps deployment architecture

Getting started and regional extraction

MapLibre integration

Related Posts

CVE-2026-123890: VMware vCenter authentication bypass exploited since September — CISA patch deadline is November 23

A critical unauthenticated vCenter Directory Service flaw was used in real intrusions weeks before disclosure. CISA gives federal agencies until November 23 — everyone else should not wait longer.

Nov 22, 2026• 12 min

Your USB-C Dock Is Part of Your Network. Test It That Way.

A trending Ethernet investigation shows why docks belong in your network diagram. Here is how to isolate bottlenecks before replacing routers or adapters.

Nov 22, 2026• 9 min

CVE-2026-129448: Apache Roller XML-RPC deserialization gets CISA KEV deadline — unauthenticated remote code execution in versions before 6.1.5

Apache Roller before 6.1.5 runs unauthenticated XML-RPC deserialization before authentication; it is now on CISA's exploited list with a patch deadline of November 23, 2026.

Nov 21, 2026• 11 min