04 / SELECTED WORK

Auropress

Holds any number of blogs behind one collaborative editor, serves them to sites through a Hashnode-compatible GraphQL API, and lets assistants draft and edit over MCP.

Auropress screenshot
Build
WEB · API

I built Auropress in November 2026 to move this website's blog off Hashnode, and to give assistants a proper way to write alongside people. It has no website of its own, so people write in a dashboard and sites fetch the published posts through its API.

That API answers Hashnode's GraphQL queries the way Hashnode does, which is why a site built for Hashnode moves by changing two settings: its endpoint and its host.

Hashnode's API going Pro-only was one of the excuses, but I had already started paying for it. I guess I was already looking for an excuse to build my own, to have more control.

Copying Hashnode's API

The first decision was to copy Hashnode's API rather than design my own. The GraphQL schema covers the operations my sites use, checked against Hashnode's own introspection from 14 November, and webhooks are signed the way Hashnode signs them, so the portfolio's verifier did not change.

An importer brings an existing Hashnode blog in, images included, so nothing keeps pointing at Hashnode's CDN.

That is why the move was a change of settings and not of code. The portfolio still reads its blog through variables named HASHNODE_GQL_ENDPOINT and HASHNODE_PUBLICATION_HOST, and on 16 November they started pointing at Auropress. Until Hashnode is retired, moving back is the same two settings.

One blog, built for many

Auropress holds publications, not one blog, and each publication is a tenant. I chose to go multi-tenant because I plan to have multiple publications myself, and to offer it to others as a service.

I have two publications on it now, and a third is owned by a colleague whose website is also in production, with its blog content served by Auropress.

Every write to tenant data goes through one package, packages/domain, and its Prisma client carries a guard that refuses any query on a tenant table that does not name its publication.

The guard checks the value and not only the key, because Prisma drops a key whose value is undefined, so where: { publicationId: undefined } would quietly become a query over every tenant.

Underneath that, Postgres enforces the same rule with row-level security on all 20 tenant tables, so a transaction that has not declared its publication sees no tenant rows at all.

The app connects as a role that cannot bypass it, and in production it refuses to start if it can. The cross-tenant suite runs 37 operations from one tenant on another's ids, and every one comes back NOT_FOUND.

Assistants as writers

Assistants were the other reason for Auropress, so they get their own door: an OAuth 2.1 server and an MCP server with eighteen tools. An assistant drafts and edits by exact find and replace, for the person who connected it, inside the publications and scopes that person chose on the consent screen.

There is no delete tool, and a test fails if any tool's name contains "delete" or "remove". Publishing is off until an owner turns it on for the publication, and a client that supports it asks the person first.

The harder part was an assistant editing a draft someone has open. The open draft is a Yjs document in the collab service, and a write straight to the database would be overwritten by the next save from the screen.

So every text write, from the dashboard, the API or MCP, goes through one service that applies it to the live document when there is one. The change shows in the editor as "Claude Code via MCP" for eight seconds, becomes a revision labelled with the app and the person, and can be restored from the margin.

How it was built

Auropress started from two Stacks templates, nest-monorepo for the API and the worker and react-app for the dashboard, and the rest was built by hand. The 39 screens were drawn on a design canvas first, and the specification gave every requirement an ID.

The build took two days, 14 and 15 November, and was gated on six milestones, each with evidence that can be run again, from the cross-tenant suite to my own Claude Code connecting through the consent screen and drafting a post.

Writing the documentation meant reading the code closely, and that turned up real bugs. A publication set to require a token could still be read by any signed-in account, and GraphQL's updatePost published whatever the post's working draft held, even a draft still in review. Each fix came with a test that fails on the old code.

What it cost

Mostly time. The rest is in the limits. Row-level security leans on a Prisma internal to know when a query is inside a transaction, so every Prisma upgrade has to pass the RLS tests before I take it. Search is English only, and collab runs as a single instance because open documents live in its memory.

And some things were decided against: no word count in the editor, only read time, no importer other than Hashnode's, and comments that refresh every 15 seconds instead of live.

POST api.auropress.dev/graphql
query {  publication(host: "wesscoby.com/blog") {    posts(first: 3) {      edges { node { title readTimeInMinutes } }    }  }}# 200 OK→ An MCP Server for One Person              4 min→ What the Hell Are AI Software Factories?  7 min→ Code Is No Longer the Product             4 min
Role
FULL-STACK
Stack
Node · NestJS · GraphQL · React · Tiptap · Yjs · Hocuspocus · Prisma · PostgreSQL · BullMQ · Turborepo · MCP
Status
LIVE