Case Study · 05 / 05

Pentinian
the studio

The studio's own operating system, five interlocking pillars, stood up and audited inside three days.

A studio that builds operating systems for other businesses should be running on one. Pentinian is five pillars that interlock. The Foyer, the public site you are reading, wins the work. The Window shows each client a curated, drip-fed view of their own build. The Atelier is the operator surface where that view is curated. A Notion brain holds the truth. Switchboard, a published connector, lets one session reach every account. The sixth thing built was the audit: an unflattering read of the whole system that names which pillars are not ready.

Venture: Pentinian, in-house
Role: Design + build, solo
Stack: Next.js 14 · Supabase · Notion · Node
Period: 22 to 24 July 2026
Status: Live, dogfooded, audited

Interlocking pillars

Switchboard tools

Hour build window

Database tables

D1 · the glance

The situation

A studio that builds operating systems for other businesses has one question it cannot answer badly: what are you running on? Most studios point at a folder of documents and a chat history. Pentinian points at itself.

The answer is five interlocking pillars, and the whole idea is that they interlock. The Foyer, the public site, wins the work and takes the waitlist. The Window shows each client a curated, drip-fed view of their own build. The Atelier is the operator surface where that view is curated. The brain, a Notion workspace, is the single source of truth: clients, projects, work log, invoices, brand protocols. Switchboard, a published connector, lets one session act across every account the studio touches.

Full glory is one motion. A lead enters through the Foyer, becomes a client in the brain, gets a Window that fills itself from logged work, and every branding and process rule is enforced automatically by agents running on Switchboard. One nervous system, not five demos.

And the studio is its own first client. The whole system was stood up, dogfooded, repaired and audited inside a 72 hour window, 22 to 24 July 2026. That last fact is the honest part, and it is why the sixth thing built was an audit of the other five.

Five pillars stood up, dogfooded, and audited inside seventy-two hours. One nervous system, not five demos.

Build note

D2 · the engaged read

What was built

Switchboard, one session every account

A zero-dependency connector exposing 26 tools: four control tools, thirteen Notion tools at full CRUD plus schema, seven Mailchimp, and two Zapier webhooks. Credentials live in a config file the user owns, outside the plugin. A setup wizard takes tokens at a terminal prompt so they stay in your terminal, not in chat. Published, MIT.

Switchboard

The Window, a client watching their own build

Magic-link sign-in, a live-read project view, released work-log entries drip-fed on a schedule, a progress ring, and three stat tiles: updates, sessions, open questions. Marked force-dynamic on purpose, so it always reads live from the database and never serves a cached snapshot of a client's Window.

Window

The Atelier, three lanes and one curation model

Quarry holds raw work-log entries pulled from Notion, never shown to a client. Bench is shaping. Cadence is released. A second tab calibrates the public site: open-for-work, the availability string, and which project cards a stranger gets to see.

Atelier

The brain, Notion as the single source of truth

Clients, projects, a work log shaped for the app, invoices, and brand protocols carrying the studio's actual rules. The app's sync pulls the work log into the Quarry with an upsert keyed on the Notion page ID, so re-syncing is idempotent and never doubles a row.

Notion brain

The Foyer, the public front door, live

The site you are reading. A lean public site plus two zero-dependency serverless functions, the waitlist and the contact form, that email each note to the studio and a short confirmation to the person. A send that fails is never silent: the page says so and offers the same words as a prefilled email. Deployed and taking the waitlist.

Foyer

The audit, the pillar most studios skip

A written, unflattering assessment of the whole system against its own vision: what is live, what is scaffolded, what writes into a void, and which pillar the momentum is pulling toward for the wrong reasons. Self-authored, and reproduced honestly further down this page.

Self-audit

The Window section of the Pentinian foyer, showing a card that explains a client's private page with a March calendar of days worked. — **The Window, explained on the front door.** Six cards a visitor can press, running on invented data and writing nowhere, so a prospective client can see what their own page would hold before there is any account to sign into. pentinian.com · 1382px

The Selected Work rows on a phone, each project one row with its tags and status. — **Selected work, on a phone.** 390px

D3 · the hood

Under the hood

Switchboard, the mechanics26 tools · zero deps

Hand-rolled JSON-RPC 2.0 over newline-delimited stdio. No SDK, no npm install, Node 18+ for the built-in fetch. The entire server is one file, and every design choice in it is the difference between a connector you can script against and one you have to babysit.

Config shape is provider, { default, accounts } at ~/.pentinian-switchboard/config.json. A module-level active map tracks the current account per provider, and every tool takes a one-call account override that does not change session state.
Notion responses are enormous. Every tool returns a trimmed shape by default with raw: true available on any call, and a property flattener switches over eighteen Notion types. That is what fits a connector inside a context window instead of blowing it.
Provider details that read as care: Mailchimp's data-center suffix is parsed off the API key, member IDs are the MD5 of the lowercased email per the API's own contract, and the Zapier trigger validates the URL against the hooks hostname before it posts.
The wizard is not a tool. switchboard_setup returns a Terminal command rather than prompting in chat, so tokens stay in your terminal, and the first account added becomes the default.

The app tier, schema and the sync7 tables · 5 deps

Next.js 14 App Router with five runtime dependencies and seven Supabase tables, each with its purpose written into the schema as a comment. work_log_raw is the Quarry, upserted from Notion on notion_id and commented never shown to the client directly. work_log_released is the Bench and Cadence, and its join back to the raw row is on delete set null, so a release outlives its source. site_config is a single jsonb row governing the public site.

The Notion pull is forty-six lines with a property-name fallback chain, and returns an empty array silently if unconfigured. Auth is magic-link only, and middleware refreshes the session on every request and guards both surfaces. Dogfooding found two production bugs on day three and fixed both in thirteen lines: the Window was serving a cached snapshot, fixed with force-dynamic; Approve was not idempotent, fixed by selecting on the raw ID first and bailing with "Already approved."

The self-audit, graded against its own vision6 pillars

The audit is written to be honest rather than flattering, so it is useful. Its at-a-glance table grades six pillars and names the gap to full glory for each. The deepest finding is two sources of truth: the Notion brain and the app database both hold clients and projects, and they do not sync, which is invisible until it bites. The sharpest is the trap it names for its own author, polishing Switchboard further because it is the most finished pillar and therefore the most satisfying to touch, while the multi-tenant gate goes unaddressed. An audit that names its own author's likely next mistake is a more useful artifact than most roadmaps.

Momentum likes the wrong pillar here. Most self-assessments grade the work; this one grades the attention.

Vision audit

the surface

The design system

One token set spans all four surfaces, the public site, the bio page, the client Window and the operator Atelier, so the studio's own system and its shop front are visibly the same object. Warm paper, ink that is never black, sage for what is alive and clay for what is becoming. Status language is organic and binary: a live card carries a sage dot, an in-build card carries a clay dot, and a reader learns the whole vocabulary in one glance.

The mark is the same SVG on every surface, two concentric sage circles around a clay dot: a foyer, a window, an aperture. A light serif at display weight, a neutral sans for body, mono reserved for numerals and system labels. And every surface ends the same way, with prefers-reduced-motion cutting all animation, because the calm is not conditional.

Paper#F1ECE1 · ground

Bone#FAF7EF · raised

Ink#23251E · text

Sage#7E9270 · live

Clay#B0805C · in build

Haze#93A6AC · the quarry

operations

How the studio runs differently

Was. Client updates written from memory on a Friday, or a shared document that quietly goes stale.

Now. The client opens a Window and sees released work, sessions and open questions, live from the database. The studio curates from a Quarry rather than composing from scratch.

Was. Credentials for each client's Notion, Mailchimp and automation accounts, re-authenticated per session and pasted into chat.

Now. One connector, one config file the user owns, one call to switch accounts mid-session. Tokens are entered at a terminal prompt and never pass through a conversation.

Was. The studio's own operational memory living in whichever tool happened to be open at the time.

Now. One Notion brain: clients, projects, work log, invoices, brand protocols, with the app deriving from it rather than duplicating it. That is the stated destination; today it is one bridge, and the audit says so.

Was. A portfolio that describes the work, and a proposal process that describes the process.

Now. A public site that is itself the first proof, an app tier the studio runs on as its own first client, and a connector published under its own name that anyone can install.

cost

Economics

Line	Basis	Annual
Client-portal SaaS	Displaced by the Window. Hosted client-portal products are the alternative shape for drip-fed project visibility, and they price per seat, which is exactly backwards for a studio that wants to add clients.	not quoted
Integration-platform seats	Reduced by Switchboard. Multi-account access across Notion, Mailchimp and webhook triggers without a per-connection or per-task subscription. Zapier stays for what it is genuinely better at.	displaced
Domain	The Pentinian domain at an at-cost registrar, live and serving the Foyer. The one real recurring price in the whole system.	~$11
Hosting and database	Vercel plus Supabase, both within free allowances at current volume. Notion is already in use as the operational brain.	$0
Per-client marginal cost	The property that matters most. Adding a client is a row in a table and a magic link. No seat, no license, no per-connection fee.	~$0

Modeled, awaiting actuals. No dollar figure for the Pentinian stack exists in the record. Vercel, Supabase and Notion tiers are referenced only as setup instructions, never as prices, and the displaced-SaaS lines are category claims rather than quotes. The strongest number here is the marginal one: a studio whose client portal costs nothing per client can afford to give every client a portal, which changes what it can offer, not just what it spends.

Reserved for your numbers. Three figures would make this real: current monthly Vercel, Supabase and Notion spend, what a comparable client-portal product would cost at your client count, and your actual project rate. Drop them in and this stops being a posture and becomes a margin argument.

outcomes

In the world

A connector published under the studio's own name

MIT-licensed, documented, installable in two commands, zero dependencies, 26 tools across three providers. The audit calls it the most finished pillar, and then warns against polishing it any further.

The studio running as its own first client

The seed SQL inserts Pen as client one, on a project called Pentinian Studio Build, at sixty percent. Dogfooding found two production bugs on day three and fixed both in thirteen lines.

A design language that survives four surfaces

The same tokens, the same mark, the same status vocabulary across the public site, the bio page, the client Window and the operator Atelier. The audit names this as the thing hardest to buy and easiest to keep.

An audit that names its author's own likely mistake

Most self-assessments grade the work. This one grades the attention, and tells its author exactly which finished pillar not to keep touching.

what is not done

Honest edges

The multi-tenant gate is not built.

The Window loads the first project for everyone. Row-level security is off, and the Atelier is reachable by any signed-in account. None of this matters with one person and test data. All of it matters the moment client number two signs in, and it is named as the wall in front of paying work.

Two sources of truth.

Notion and the app database both hold clients and projects, and they do not sync. Only the work log flows. Every pillar drifts slightly out of agreement with the others until this is reconciled, and the audit calls it the deepest architectural debt.

The client loop runs one way.

Approve, Suggest a change and Request an adjustment are rendered and unwired. The hours tracker with before-and-after screenshots and the question-approval loop, both specifically asked for, are scaffolded tables with no surface yet.

The Atelier's calibration writes into a void.

Saving site configuration reports that the public site reads this config. The public site does not read it yet, so the operator's dial turns and nothing downstream moves.

The agent layer does not exist.

The brain and the connector were built to be the substrate for protocol-bound agents running the studio. The foundation is poured. Nothing stands on it yet.

Provenance. Every figure traces to the Switchboard server source and both plugin bundles, the Pentinian app tier and its Supabase schema, the public site source, the seed and repair SQL, the git history of three repositories, and the full-vision audit dated 24 July 2026. Where the record was silent, this page says so rather than estimating. Cost figures are architectural observations and category claims, labeled as such.