Self-hosting your own map tiles used to mean running a tile server, a database, and a bill you had to watch. The claim going around this week is that it got cheap and easy: one file, no server worth naming, no key, no per-view charge. I wanted to see how true that is, so I picked a city I know, Dhaka, cut it out of the planet, and served it from my own laptop. The whole thing took about ten minutes of actual work, and the numbers are better than the claim.
Cutting Dhaka out of the planet
Protomaps builds the whole of OpenStreetMap into a single file every day. The full planet build is about 140 GB. Nobody downloads that. The point of the format is that you cut out just the piece you need, and the tool only downloads the bytes belonging to your piece.
I took the November 15 build and asked for Dhaka, a box from 90.30 to 90.50 east and 23.70 to 23.90 north, roughly the city centre and its edges. The tool came back with 578 tiles and a file of 17,797,402 bytes, about 17 MB. It took 35.5 seconds and 53 small downloads adding up to 19 MB, because the tool pulls the index first and then only the chunks holding my tiles. Nineteen megabytes in, 17 out, and the planet file never crossed my machine in full.
That ratio is the whole pitch, stated as a number. The planet is about 140 GB. My city is 17 MB. That is roughly eight thousand times smaller, for a map that covers the place I actually wanted. If you run a site about one city, one region, one trail, you are not in the planet business at all. You are in the 17 MB business.
The file itself checks out. It is a version 3 archive, vector tiles, zoom levels 0 to 15, gzip-compressed, built from OpenStreetMap data as of November 15 at 04:00 UTC. I ran the format's own verify step over it and it came back clean. The map data inside is a day old. If a road changes tomorrow, my file does not know about it until I cut a fresh one. That is the trade, and I will come back to it.
Serving it: one command, 148 milliseconds
Serving the file took one command and no configuration. The tool starts a small tile server on your machine, and the first tile came back 148 milliseconds after I started it. No database to start, no cache to warm, no config file to write.
Then I asked it for 27 tiles: nine spots around Dhaka at zooms 5 through 15, each one three times. Every single one came back with a 200. The middle of the pack, the median, was 1.1 milliseconds. The average was 4.3. The slowest was 31.4 milliseconds, and that was the very first request for the zoom-5 tile, before the cache had anything in it. Every warm request after that landed between 0.7 and 1.3 milliseconds. On a plain laptop, on a local network, a map tile is about a millisecond of work.
The tiles themselves are not all the same size. The smallest I asked for was 1,254 bytes, a quiet corner at zoom 15. The biggest was 107,624 bytes, the city centre at zoom 12, where every road, building and label in central Dhaka is packed into one square. The average was about 44 KB. So a screen full of map at street level is a handful of 40 KB squares, each arriving in about a millisecond. That is the part that surprised me: I expected the format to be clever about storage, and it is, but I did not expect the serving to be this boring. It just answers.
Two more details from the run, because they are the kind of thing you only learn by trying. First, a tile outside my box, one step east of Dhaka at zoom 12, came back empty in 0.65 milliseconds, a 204 with no body. The map outside your cut is not wrong or broken. It is blank. If your readers pan past the edge, they see nothing, and you need a bigger cut or a low-zoom world underneath it. Second, the little TileJSON document the server is supposed to hand out, the one that tells a map library where the tiles live, refused to work until I gave the server a public address. Without it, a 501. That is the one thing in the whole run that did not work out of the box, and it took a minute to understand.
The catch, and it is a real one
Nothing here is wrong. But three things are worth knowing before you move your maps to this.
The first is the dead link in the docs. The guides that teach this format point beginners at a demo archive, v4.pmtiles, hosted for testing. When I went to look at it on November 16, it returned a 404. The file is gone, for now at least. If you followed a tutorial this week and your map loaded empty, that may be why, and it is not your fault. Cut your own file instead. It takes 35 seconds.
The second is freshness. A file is a snapshot. OpenStreetMap changes every hour, and my Dhaka file is already a day old. A live tile service updates under you. A file does not. If your map needs today's roads, you need a routine that cuts a fresh file every week or every month, and you need to remember that routine exists. For most small sites, a monthly cut is plenty. For a delivery app, it is not.
The third is size at the edges. A city is 17 MB. A country is hundreds of megabytes to a few gigabytes. The whole planet is 140 GB. The format scales, but your hosting bill and your download time scale with it, and the "one small file" story is really a "one small file for one small place" story. Pick your place honestly.
What it costs, and what it replaces
Here is the comparison that matters. A hosted map tile service charges per view, or per thousand views, and the bill grows with your traffic. A file like this costs whatever your plain file hosting costs, which for 17 MB is nothing, and the traffic it serves is ordinary file traffic. There is no key to rotate, no account to watch, no usage dashboard to check at the end of the month. The map library in the visitor's own page reads the file in pieces, asking only for the parts of it that cover the screen, which is why the whole thing works from plain static hosting in the first place.
That is the real change. Not that maps got cheaper, though they did, but that the moving parts disappeared. The database, the tile server, the cache layer, the key management: all of it collapses into a file you can copy, back up, and serve from anywhere that serves files. I built this on a laptop in an evening. A city map, 17 MB, tiles in a millisecond, no bill attached.
If you run anything with a map on it, a shop finder, a trail guide, a local history page, try cutting your own place first. Thirty-five seconds and 19 MB will tell you whether the claim holds for you. For Dhaka, it held.
Sources
- Protomaps basemaps and downloads: protomaps.com and docs.protomaps.com/basemaps/downloads
- Planet builds: build.protomaps.com (build used: 20261115; the Nov 16 build returned 404 at check time)
- PMTiles command-line tool v1.31.2: github.com/protomaps/go-pmtiles
- Every number in this article comes from my own run on 2026-11-16: the extract log, the archive inspection, and 27 timed tile requests, all saved under
runs/protomaps/
P.S. Everything I write stays free — that part doesn't change. But if this one was worth something to you, you can buy me a coffee ☕ (one-time or monthly, both work). It covers the API credits and hosting behind these experiments — and honestly, it's also the nudge that gets the next one started on the evenings I'd otherwise skip it. — Salam


