Stone Maps

What Stone Maps Is

Stone Maps is a place-aware journaling app paired with a physical stone. This is what it is, why it exists, and what we mean by slow over fast.

Building Voice Mode for the Emissary

How we added real-time voice conversation to the Planetary Emissary using OpenAI's Realtime API and WebRTC — and what broke along the way.

Gelling the Experience: Ideas for Making Stone Maps Feel Whole

The app works. But working and cohering are different things. Some ideas — speculative, half-formed, some fully formed — for deepening the physical-digital relationship at the heart of Stone Maps.

Core Workflows: What You Actually Do in Stone Maps

Not features, not API routes — the actual sequences of action that make up a session in Stone Maps. From first scan to daily journal to voice conversation to map discovery.

The Tech Stack: Every Tool and Why It's There

A frank accounting of every tool in the Stone Maps stack — the reasoning behind each choice, the tradeoffs accepted, and what would be chosen differently with hindsight.

Architecture: How Stone Maps Is Put Together

A complete picture of how Stone Maps is structured — the monorepo layout, API patterns, database connection strategy, and the decisions that shape every new feature.

Buying a Stone: Stripe Integration and Fulfillment

Stone Maps is a physical product as much as a digital one. How the Stripe checkout flow, order schema, and fulfillment pipeline work — and the design decision to sell stones at all.

Offline First: PWA and Serwist Service Worker

A journaling app that only works when you have signal is missing the point. How Stone Maps uses Serwist to become a PWA — installable, cacheable, and available offline.

The Map: Building Place Discovery with Mapbox GL

The map is where Stone Maps becomes a place, not just an app. How Mapbox GL powers the discovery layer, how viewport-based queries work, and why the map is read-only by design.

Teams and Campaigns: Scoped Journaling for Groups

Stone Maps is primarily a personal journal. But it also has teams — and within teams, campaigns. Here's how the group model works and the RBAC decisions that shaped it.

The MCP Endpoint: Stone Maps as a Tool

Stone Maps has an MCP server endpoint. Here's what it exposes, how it authenticates, and why building one turned out to reveal something interesting about what the app actually is.

P0 Hardening: Rate Limiting, Validation, and the Road to Production

Before Stone Maps could go to early access, it needed real infrastructure: rate limiting on every endpoint, Zod validation on every input, error monitoring, and a CI/CD pipeline that caught bugs before Vercel did.

Building the Admin Dashboard

A solo founder running an early-access app still needs admin tooling. Here's how the Stone Maps admin dashboard works — the RBAC model, the 2FA gate, and what it can actually do.

The Pebble Onboarding: Five Questions Before the Journal

Before you can write anything in Stone Maps, you answer five questions. This is the genesis — and why we made it the threshold instead of a profile form.

Place and PostGIS: How Stone Maps Thinks About Location

Stone Maps is a place-aware app. That means location data is everywhere — in posts, in stones, in prompts. Here's how PostGIS makes that work without being heavy about it.

Account Lifecycle: Designing Suspend, Reinstate, and Delete

What does it mean for a journaling app to let you leave? The decisions behind account suspension, reinstatement, and permanent deletion — and why the UI makes you confirm twice.

Pairing with a Stone: QR Activation and the Self-Pair

The physical stone is the starting point. How QR activation works, what the genesis questions are for, and why the self-pair is the core relationship in Stone Maps.

The 24-Hour Rule: Designing Sparse AI Interactions

Most apps try to maximize engagement. Stone Maps deliberately limits how often the Emissary speaks — and the code that enforces this is worth examining.

Media in the Field: Building the R2 Pipeline

How Stone Maps handles media uploads — presigned URLs, a proxy route, and the design decisions that kept it working across deployments.