5 Python scripts that turn a CSV into a publication-quality map

cyl08 — Thu, 08 Oct 2026 06:50:17 +0000

If you have coordinates sitting in a spreadsheet and you want them on a map, the standard advice is "just use QGIS" or "go learn geopandas". Both are fine answers — but if all you need is one figure for a report, that's a lot of yak-shaving for one image.

I ended up writing five small scripts, each self-contained, each doing one job. Here's what each is actually for.

The five

1. Choropleth — shaded regions from your data

The classic. You have a value per region (population, GDP, case counts) and a boundary file. The script joins your CSV to the GeoJSON on a key, then shades each region by value with a colour scale and a legend that doesn't look broken.

2. POI distribution — points on a coordinate grid

Just "where are my things". Good for store locations, sampling sites, sensors. Plots your lat/lon with a light grid so you can eyeball clustering.

3. Density heatmap — hexbin aggregation

When you have too many points and a scatter plot becomes a solid blob. Hexbin aggregates into hexagonal bins and colours by count — it shows clusters that individual points hide.

4. Bubble map — dot size encodes a value

Same as POI, but each point carries a magnitude (revenue, volume, users). Size encodes the value, so one glance shows both where and how much.

5. Flow map — curved origin→destination lines

For movement data: commutes, migration, shipments. Each row is an origin→destination pair with a volume, drawn as a curved line whose width is the volume. Curves (not straight lines) make overlapping routes readable.

Why matplotlib maps are annoying

The plotting itself is easy. The annoying parts are the ones nobody mentions:

Coordinate systems. Your data might be WGS-84 lat/lon; your boundary file might not. If they disagree your map is subtly wrong, and you won't notice until someone else does.
Colour scales. A linear scale on skewed data makes everything the same colour. Getting quantile vs linear right changes whether the map says anything at all.
Legends and labels. Making a colourbar, a title and region labels not collide is genuinely fiddly — and it's about 80% of the "why does my map look amateur" problem.
Boundary files. You need a GeoJSON. If you don't have one, half the tutorial is over before it starts.

Each script handles those with a CONFIGURATION block at the top: edit the paths and column names, run it, and the figure lands in your output folder.

The setup

pip install pandas numpy matplotlib geopandas

Python 3.9+. Works on Windows, macOS and Linux. No ArcGIS, no QGIS, no account, no API keys.

Every script ships with working sample data so you can run it before pointing it at your own CSV. There's a boundary GeoJSON example too, plus a troubleshooting section for the usual projection mismatches.

Choosing the right map

This is the part that actually matters, and it's not a code question:

What your data looks like	Which map
A value per region	Choropleth
Points, want to see clustering	POI distribution
Too many points to see anything	Density heatmap
Points with a magnitude	Bubble map
Origin to destination pairs	Flow map

Getting that mapping right is worth more than any individual script.

If you'd rather not write them

Everything above is what I built for my own work, and I packaged the five scripts up with the sample data and notes. If it saves you an afternoon of fighting matplotlib projections, that's the whole point: https://mochiway.com/templates.html

Either way — the concepts are the useful part. Happy to answer questions about projections, geopandas joins, or hexbin parameters.

I built a budget app with no backend — everything lives in localStorage

cyl08 — Thu, 08 Oct 2026 06:46:28 +0000

Every budgeting app I tried wanted a monthly subscription. Which is a bit ironic for software whose whole job is to help you spend less.

So I built Mochi — and made one architectural decision that shaped everything else: no backend at all.

No server. No account. No database. It's a single HTML file, about 75 KB, and all your data lives in your browser's localStorage.

Here's what that constraint actually costs, and what it buys.

What you give up

No sync. This is the big one, and I won't pretend otherwise. Your phone and your laptop don't know about each other. Want both? Export a JSON backup from one, import it on the other.

No recovery. Because there's no account, there's no "forgot password" and no way for me to restore your data. Clear your browser storage and it's gone. That's a real risk, so the app nags you to export backups.

No analytics, so no product intuition. I genuinely cannot see how people use it — which features land, where they get stuck. Every improvement is a guess, or comes from someone emailing me.

What you get

Your financial data can't leak, because it never leaves. Not "we don't sell your data" — there is literally no server holding it. That's a different kind of promise.

It works offline, forever. Save the page and it works on a plane. No API can go down.

It costs me nothing to run, so it doesn't have to cost you monthly. This is the part I like most. No infrastructure means no reason to charge a subscription — which is why it's a one-time purchase instead of $5/month.

The technical bits

Single index.html, vanilla JS, zero dependencies, no build step
Charts hand-rolled with plain CSS and SVG — no chart library
Data in localStorage, with JSON export/import for portability
PWA manifest + service worker: installs to your home screen, works offline
~75 KB total, boots instantly

The most interesting constraint was the charts. Without a library, a six-month trend chart is an exercise in viewBox arithmetic and remembering that SVG y-axes grow downward. Worth it though — the whole app loads faster than a single page of most apps I compared against.

The annoyance that started it

I built Mochi because of one specific thing: I had no idea what I was spending on AI tools each month. ChatGPT, Claude, Cursor, a couple of API top-ups — individually each felt small, together it was a real number I only saw when the card statement arrived.

So Mochi keeps a dedicated AI-spend ledger: log subscriptions and top-ups, set a monthly cap, watch a six-month trend. It's the one feature I couldn't find in any other budget app.

Why I'm posting this

Partly because the no-backend architecture is genuinely interesting to argue about — the trade-offs are real and asymmetric, and I'd pick it again for this use case.

And partly, honestly, because it's a paid product and I'd like people to find it. If the architecture is interesting to you, it's at https://mochiway.com — one-time price, no subscription, in keeping with the whole point.

Happy to answer anything about the localStorage trade-offs, the no-build-step decision, or what I'd do differently next time.

DEV Community: cyl08