There’s a category of side project that exists purely because nothing else does exactly what you want. Jotcache is that project for me.

It started as a single HTML file. It’s still a single HTML file at its core, conceptually — even though it’s now a Next.js app with a Supabase backend, an MCP server, and a PWA manifest. The soul of it hasn’t changed: a distraction-free space to write 750 words every day, with the cursor locked to the center of the screen like a typewriter.

The 750 Words Philosophy

The concept behind Jotcache comes from Julia Cameron’s The Artist’s Way, which prescribes “morning pages” — three pages of stream-of-consciousness writing every morning, before the inner critic wakes up. The goal isn’t to produce good writing. It’s to clear the noise.

750 words is roughly three handwritten pages. Long enough to push past the surface. Short enough to finish in 15–20 minutes.

I’d used 750words.com for years, but it always felt a little heavy. Too many features competing for attention, too many widgets, too much UI. I wanted something that felt closer to sitting down with a notebook and a good pen. So I built it.

The Typewriter Mechanic

The defining feature of Jotcache is typewriter scroll: the cursor stays anchored to the vertical center of the screen, and the text flows above and below it as you type. There’s no scrollbar. There’s no toolbar. Just the cursor, moving in place, while your words accumulate.

Implementing this was more interesting than it sounds. The trick is a hidden mirror <div> that clones the textarea’s exact styling — font, size, line height, padding — and then measures where the cursor actually sits within it. From that measurement, we scroll the container so the cursor line sits at exactly 50vh.

It’s a small thing. But it completely changes how writing feels. There’s no cognitive overhead of watching text pile up below you, no temptation to scroll back and read what you wrote. The cursor is always here, always ready. You just keep going.

Keyboard-First, By Design

Every action in Jotcache has a keyboard shortcut. This is not an afterthought — it’s the whole design philosophy. Moving your hand to a mouse breaks the flow of writing. So does hunting through menus.

Cmd+K opens a searchable command palette. From there, you can save, browse past entries, request a writing prompt, toggle fullscreen, switch themes — all without leaving the keyboard. On mobile, the same actions are available through slash commands and a toolbar.

The writing prompts are one of my favorite features: contextual suggestions generated by analyzing what you’ve already written in the session, so they’re always relevant to where your head is at.

What I Learned Building It

Building for yourself is liberating

The product decisions were easy because I was the only user I had to satisfy. I didn’t need to run user research or A/B test the progress bar. I just built what felt right, used it every day, and iterated based on whether it was working for me.

This is a dramatically different mode than startup product development, where every decision has to go through the filter of “what do our users want?” Both are good, but building something purely for yourself is a different kind of creative exercise. More akin to carpentry than software engineering.

The MCP layer was the most interesting recent addition

Jotcache has a Model Context Protocol (MCP) server — which means you can connect Claude or any MCP-compatible AI client directly to your writing entries. The server exposes two tools: list_entries and get_entry. In practice, this means you can ask Claude to summarize your last two weeks of morning pages, identify recurring themes, or pull a specific entry.

I built it partly as an experiment, partly because I was curious what patterns an LLM would surface from months of stream-of-consciousness text. The answer: more than I expected. Your writing patterns are more legible to a language model than they are to you.

The MCP server also supports OAuth, which I implemented from scratch — including the full authorization server dance (discovery endpoints, token exchange, bearer auth). Getting the OAuth spec right was the most technically gnarly part of the whole project, and also the most satisfying to finish.

Local-first, cloud-second

Jotcache was local-first from day one. Entries save to localStorage, keyed by date (jot_YYYY-MM-DD). The app works offline. No account required.

Cloud sync (via Supabase) came later, as an opt-in feature for signed-in users. When you sign in, your entries start syncing — and the sync logic handles the conflict-resolution edge cases carefully. The invariant: you never lose a word. If the cloud copy and the local copy diverge, the longer one wins.

I’ve been surprised by how much this architectural decision changes the feel of the app. Because your data is local, the app is instantaneous. There’s no loading state, no waiting for the server. You open it, you write.

---

Jotcache is at jotcache.com if you want to try it. It’s free — no account required to start writing. The source is something I keep tinkering with, usually in 30-minute bursts when I have an idea I want to try.

The best side projects are the ones you build because you genuinely want them to exist. Jotcache is that for me. Still using it every morning.