Why Our App and Our Book Builder Are Both Free

We make a free phone app and a free book builder. Neither has a subscription, a trial, or even an account.

So how does that work?

There are still bills to pay. We just built both products in a way that keeps those bills pretty small.

Here’s what we actually do, what we pay for, and why none of it needs to end up on your receipt.

September 4, 2026 9 min read Written by Kevin

What we make

KR Maps is a small shop in Fort Collins, Colorado. We make printed wall maps, and over the last couple of years we’ve also built two pieces of software.

Journeys is a free phone app that turns the pins on your wall map into a record of where you’ve been.

The book builder on our website takes your travel photos and turns them into a printed travel book.

They’re separate products. You don’t need the app to use the book builder, and most people who use the book builder don’t have the app.

But we built both with the same basic goal:

We didn’t want to build something so expensive that we’d have to pass it on to you.

That sounds simple, but it affected quite a lot of the decisions we made.

I should probably say where this came from.

I was building web maps before KR Maps existed. Then I spent years making printed ones instead, and the software side of it got rusty.

When I came back to it, things had changed. Ten years ago, an app like Journeys would have needed a team, a long schedule, and a serious budget. Now it runs on open-source map data and the tools already built into your phone. One person can do it.

So I built it. Not as a business plan. I just like web maps, and I like seeing my own hikes drawn out properly.

That’s also why we’ve never had to raise our prices to pay for it. Journeys is free and completely optional — you never need it to buy a map or make a book. And it isn’t making money some other way either. Your trips aren’t a product we sell.

If people use the hiking side of it, that’s where I’d like to take it next.

The problem with renting maps

Map services are usually pretty reasonable when you’re only using a map once in a while.

Google Maps, for example, charges $7 per 1,000 map loads after its monthly free allowance. That’s less than a penny per map.

For a normal website, that’s basically nothing.

A travel book is different.

A book might have dozens of maps. You might open the builder, change a page, move some photos around, come back later, and keep working on it for an evening.

And while you’re doing that, we’re paying for those maps.

Most people who open the book builder are also just looking around. They might never buy a book.

That’s where things get difficult for a small company. The more people who use the software, the bigger the bill becomes, even if those people never place an order.

We didn’t want to solve that by putting the software behind an account, adding a free trial, limiting how much you could use it, or raising the price of the books.

So we stopped renting the maps.

The book builder: we host the maps ourselves

A project called Protomaps packages the map data from OpenStreetMap into a large file. Ours is about 127 GB and contains the whole planet.

We keep that file on our own storage.

When you open a map in the book builder, your computer doesn’t download the whole thing. It asks for the small part of the map it needs, and your browser draws the map itself.

It’s a little like watching a movie online. You don’t download the entire movie just to watch the next few seconds.

The important part for us is that we’re paying to store the map, rather than paying every time someone looks at it.

We also host a second file for elevation data, which lets us add hillshading to things like mountain hikes. That file is much bigger than the map itself, and costs us about $10 a month.

The map files are kept as dated copies rather than being changed in place.

And because your browser draws the map, adding another map style doesn’t require us to create and store another set of map images. It’s mostly a new set of instructions telling the browser how we want the map to look.

That’s how we ended up with more than 30 map styles without needing 30 different map subscriptions.

The app: we put the work on your phone

Journeys had a similar problem.

The usual way to build an app like this is to put the data in the cloud. You create accounts, store everyone’s trips on a server, and build the app around that system.

We didn’t want to do that.

Your phone is already a very powerful computer, so we let it do most of the work.

Put all of that together and, during normal use, Journeys only talks to our servers for two things: finding the pins when you scan your wall map and receiving feedback that you send us.

There is one exception. If you choose to send a journey to the book builder, photographs have to be uploaded because the book is going to be printed.

The one thing the phone can’t do

Finding the actual pin heads in a photo of your wall map is difficult.

The map might be photographed at an angle. The lighting might be bad. There could be dozens of pins on it.

So this is the one part that doesn’t happen on your phone. It takes two steps.

First, a segmentation model called SAM 3 traces the pins it can see, so you can check what it found before you move on. That step uses an outside service, and it’s only the quick look.

The second step is ours. Our own service lines your photo up against the real printed artwork of your map, works out where each pin’s spike enters the paper, merges what it saw across several photos, and drops the duplicates. That’s the part that decides where a pin lands on your digital map. We built it, and it runs on a server because it takes more computing power than a phone has.

We wanted to be very clear about what happens to that photo. It’s a picture of the map on your wall — a printed object — not one of your travel photos. Those never go near any of this.

• Before it leaves your phone, we shrink it and strip out the location, the timestamp and the camera details.
• Two numbers do go with it: how zoomed in the lens was, and how level you were holding the phone. Our service needs both to work out the angles.
• Everything goes out through our own server. The quick-look step passes straight through it, and nothing is kept there.
• Our own service deletes the photo when it’s finished with it.
• What comes back are pin positions, and they land on your digital map.
• We don’t use the photo to train anything of ours.

There is also a setting that lets you send us corrections when the app gets a pin in the wrong place. That setting is off by default.

If you turn it on, we receive the corrected pin positions. We don’t receive the photo.

Where your photos actually go

This is probably the part people care about most.

Most of it is already answered by how the software is built. We don’t have a server holding everyone’s trips. So there’s nothing there for us to lose, sell, or hand over to anyone.

In Journeys: your photos stay on your phone. The app reads the date and location information attached to them, but it doesn’t look at the actual contents of the photos.

It never asks for your location either. It doesn’t need to — your photos already know where they were taken. Check the app’s permissions and you won’t find it listed.

There are no ads in it, no tracking, and no analytics beyond anonymous crash reports, which you can switch off.

In the book builder: while you’re working on a book, your photos stay on your computer.

Nothing is uploaded until you do something that requires it, such as saving your progress so you can come back later, inviting someone to add photos, or ordering the book. We ask before the first upload.

When you order, the finished book file is sent to our printer so they can make your book. They keep it long enough to print and ship, then delete it.

Saved drafts are deleted 30 days after your last edit.

No AI looks at your travel photos. Both products use the date and place information already attached to a photo and leave the picture itself alone.

The one image that ever goes to a model is the photo you take of your wall map, and only so the pins on it can be found. We don’t sell your photos either.

You can read the full privacy policies here: the book builder’s, and the Journeys app’s.

What we still pay for

Obviously, none of this means KR Maps has no bills.

Here are the ones that still matter:

• Storage and delivery for the map files, wall-map artwork, and images.
• Place search on the website. When you type a place such as “Lisbon” into the book builder, that search uses a paid outside service. The phone app doesn’t need this because phones already have their own geocoder.
• The wall-map scanner. The outside model we use for the quick look, and the server our own pin-finding service runs on.
• The computer that makes the print file. Preparing a book at full print resolution takes a lot of computing power, so that job runs on a rented computer.
• Crash reporting in the app, so we can find bugs that only happen on particular phones. There’s a setting for this in the app.
• Shopify, which runs the shop you’re using right now.
• And of course printing, paper, binding, packaging, and postage.

Those last things are by far the biggest costs.

And that’s actually how we want it.

We’d much rather have our costs go up because someone bought a book than because someone spent an hour playing around with the book builder.

There’s one part we’re still working on, too. Fifteen of the app’s eighteen map styles use our own map artwork and storage. A few of the others still use rented map tiles.

The book builder has already been moved completely over. The app isn’t finished yet.

So what are you actually paying for?

A printed object.

Paper. Ink. Binding. A box. Postage. And the work behind it.

The software isn’t part of that price. We don’t add a usage charge for the builder or the app.

That’s because we built it this way from the beginning.

We could have built the book builder around a service that charged us every time someone opened a map. We could have put everyone’s Journeys data on our servers and paid for storage and databases for every user.

Instead, we decided to make the computer you’re already using do more of the work.

It took us more time to build some parts this way. But once it was working, we weren’t left with a big bill that grew every time someone used the software.

That’s a trade we’re pretty happy with.

Questions we get

---