By Matija, the developer behind Build with Matija. Between 21 and 25 October 2026 I took four of my own products to production, each with a remote MCP endpoint that claude.ai can add as a custom connector. Written from the commit history and design records of those four repositories. Last updated 2026-10-25.
An MCP-first product is one where the first interface you design is the set of MCP tools an AI agent calls, and the web UI comes second. In one week in October 2026 I launched four products this way: Async (asynchronous project discovery), Attest (human translation approved in context), Sedule (a scheduling backend) and Docket (shared work state for people and coding agents). Every one of them can be added to Claude as a connector, signs users in with OAuth, and runs on the same self-hosted server. Building them close together showed me which parts of an MCP-first launch are product decisions and which parts are a kit you set up the same way every time. This article covers both: the four rules I now apply to the tool surface, and the launch checklist I repeated four times.
What shipped, and when
Here is the week as the repositories record it. Dates are when production deployment or the domain move landed.
Search Console confirmed the Async and Attest domain properties on the evening of 23 October, and both products sent their first password reset emails from their own domains that same evening. Docket's launch commit records that the claude.ai connector was verified before the old static owner token was removed from the server.
The same month also included smaller MCP surfaces in tools I use myself: an image host with OAuth-protected MCP uploads, a Mermaid rendering service with a render_visual tool, and write tools on a meeting knowledge base. So the pattern below rests on more than one launch week.
The reason is simple: for these products the first real user is an agent working on my behalf. Docket exists so that a coding agent can continue a task from recorded state. Sedule's first milestone is to create a team, set working hours, query free slots, book one and prove that two concurrent bookings cannot take the same slot, all through MCP. Async lets me run discovery for a client project while Claude reads the answers and drafts the summary.
Designing the tools first also gives you a contract before you have a screen. Sedule's README says it plainly: version 1 exposes MCP tools only, with no UI, dashboard or separate REST API, and "HTTP may transport MCP messages; that does not make it a REST API." When the /app UI arrived a day later, it called the same team-scoped tools the agent uses. One code path served both.
Rule 1: Write the tool contract before the code
In every repository, the tool surface was written down before it was built. Async has an MCP interface specification (AD-29) that came before the read and write tools (AD-31, AD-33). Docket's documentation index describes its MCP-facing capabilities and states that "minimum context for correct continuation" is the primary optimisation target (ADR 0016). Sedule went through four merged planning pull requests before its first feature.
That order matters more for MCP than for a REST API, because the reader of your contract is a model. The model sees the tool name, the description and the input schema, and nothing else. A vague description produces wrong calls, and a wrong call that writes data is expensive. Writing the contract first forces you to decide three things early:
Which tools are writes. The meeting knowledge base marks and explicitly as write tools, so the client can ask before calling them.
The Expanding Your Next.js MCP Server guide shows how to add write tools to an existing server. The point here is upstream of that: decide the read/write split and the scope rules on paper, then build.
Rule 2: Make writes safe to repeat
Agents retry. Connections drop, a client times out and calls the tool again, or two sessions do the same job at once. Each product hit some version of this.
The meeting knowledge base deduplicates repeated transcript ingestion by a hash of the transcript per project, so a re-delivered transcript does not publish a second set of events. A follow-up fix made the losing side of two identical ingests that race each other report already_ingested correctly. Docket's change records require the revision you last read before you change an item, and an optional operation ID turns a retry into a replay of the first result. Sedule's first milestone includes proving that concurrent bookings cannot overbook a slot.
Plan for duplicate and concurrent calls from the first write tool you ship, because an agent will produce both.
text
Write-tool checklist I now apply to every MCP product
- Name says it writes (create_, update_, ingest_, book_)
- Description says what it changes and what it never changes
- Idempotency key or natural dedupe key (content hash, slot + customer)
- Optimistic concurrency on updates (expected revision)
- Result says whether this call changed anything or replayed an earlier one
- Tenant or team scope is an explicit argument, checked on every call
Rule 3: OAuth from day one, static tokens only while building
Claude's custom connectors call your MCP endpoint without credentials, expect a 401 that points to your protected-resource metadata, and then run an OAuth flow with dynamic client registration and PKCE. I explained that handshake in why remote MCP servers need more than an API key and built it by hand in OAuth for MCP servers.
For these launches I used the shorter path from that second article: Better Auth's OAuth 2.1 provider. Docket records it as ADR 0022, "OAuth 2.1 for MCP with Better Auth, single owner". Async added a web sign-in redirect and consent page for MCP OAuth before it had public sign-up. The order in Docket's launch-day commits is the part I would copy:
Build and test with a static owner token while the tools are changing every hour.
Add OAuth 2.1 and a consent page once the tool surface settles.
Connect the production endpoint from claude.ai and verify it works end to end.
Delete the static token from the server's environment.
Step 4 is easy to forget. A static token that still works after launch is a second, unscoped way into the product. If you also want ChatGPT to connect, read the Claude vs OpenAI authentication differences before you pick your discovery URLs.
One small bug from this step is worth sharing. Docket's command that creates the owner account had to learn to ignore bracketed-paste markers and control characters in the password prompt, because pasting a password into a terminal can add invisible characters. If your first account is created from a CLI, strip those before hashing.
Rule 4: One origin for the landing page, the app and MCP
All four products ended up with the same layout on one domain:
text
https://product.example/ marketing landing page
https://product.example/app the signed-in web app
https://product.example/mcp the MCP endpoint
https://product.example/.well-known/oauth-protected-resource
https://product.example/.well-known/oauth-authorization-server
Async moved to "marketing page at / and the app under /app from one origin" (AD-42). Attest made the same move the same day. Docket's launch commit organised its virtual host into /mcp, /app and a landing page, proxied through Cloudflare with the real client IP restored.
One origin simplifies three things at once. There is one TLS certificate and one Cloudflare zone. The session cookie, the OAuth issuer and the MCP resource share a host, so the discovery documents point at URLs on the same domain the user already trusts. And the connector URL you hand to a user is the product's own domain followed by /mcp, which is easy to explain on the landing page.
Two details to get right behind Cloudflare. First, restore the real client IP at the proxy, or rate limits and audit logs see only Cloudflare's addresses. Second, make sure the /mcp path is never cached and that Cloudflare does not challenge requests without a browser, because a bot challenge on the MCP endpoint looks to the connector like a broken server. My Cloudflare CDN cache headers guide covers the caching side.
The launch kit I repeated four times
Everything in this section was set up the same way in each product, and by the third launch the commit messages started saying "modelled on Attest" and "following the host's Sedule pattern". That is the sign that it belongs in a template.
The self-hosting choice deserves one sentence of reasoning. Four products with background workers, databases and long-lived MCP connections would be four separate serverless bills and four sets of cold starts. On one VPS they share a machine and a deployment tool, and a new product costs a domain and an afternoon of setup. I wrote about the general trade-off in self-hosting Payload to avoid Vercel's hidden costs and the full server setup in self-hosting Next.js and Payload on a VPS. For the email templates, the Brevo transactional templates guide is the one I follow.
What broke when four launches landed in three days
Shipping this fast leaves a trail of small fixes in the history, and they are more useful than the successes.
A production build broke on a removed component. Attest's reset-password page still imported a component that had been deleted during a UI refresh. The development server never loaded that page, so only the production build caught it.
Client and server disagreed on a validation rule. Async's reset-password page had to be changed to require 10 characters "matching the server". When the UI and the API each define the rule, they drift. Define it once and import it on both sides.
The consent page was not tested end to end at first. Async's MCP consent page commit says so directly. The full flow was confirmed once the owner connected the production endpoint from Claude.
My takeaway is a short pre-launch pass that is cheaper than a full test suite and catches exactly this class of bug: run the production build, click through sign-up, verification email, password reset and the OAuth consent page once, and connect the production /mcp URL from claude.ai. All three products that skipped part of this fixed something within hours of going live.
How the work itself was coordinated
Every repository shows the same working style, and it is what made four parallel launches possible. Each product has numbered tasks (AD-, AT-, BM-, MKB-, L-), a ledger where an agent claims a task, a run report when it finishes, and recorded owner decisions when a question needs me. Agents work in their own branches or worktrees and merge back when a task is done.
That ledger pattern became one of the products. Docket is the shared, durable version of those Markdown ledgers, exposed over MCP, so that a fresh agent session can pick up a task from its recorded findings, decisions and blockers. It is also the tool I used to track this launch week. I wrote about why architecture becomes the control layer when AI writes the code; this is what that looks like in practice for a solo developer.
When MCP-first is the wrong order
Start with the screen when the value of a product is something a person has to see. Attest is the clearest example in this batch: translating a string in place, at real screen widths, so overflow and tone problems show up while you translate, needs a visual workspace. Attest built that workspace first and gives agents JSON exports of approved translations.
A useful test: if you can describe the product's core job as a sequence of tool calls with clear inputs and outputs, start with the tools. If the core job is a person judging something on a screen, start with the screen and add MCP as the automation lane.
What I would set up before the next launch
The repetition in the launch kit is the obvious thing to remove. Here is what I would change:
A starter repository with the kit already wired: one-origin routing, Better Auth with the OAuth 2.1 provider, Brevo templates for the three auth emails, the shadcn auth pages, favicon generation and a Coolify deploy file.
The pre-launch pass from the section above as a script or checklist that runs against the production URL, including connecting /mcp from Claude.
Landing pages from a shared design method. I started a separate design-systems repository on 25 October for exactly this, so each product gets its own visual identity from the same process.
FAQ
Do I need OAuth for a Claude custom connector?
For a remote connector that touches user data, yes in practice. Claude expects OAuth discovery from the endpoint and does not prompt for a static key. Use a static token only while you develop, and remove it after the OAuth flow works from claude.ai.
Can MCP be the only API a product has?
For a first version, yes. Sedule's v1 is MCP only. HTTP still carries the MCP messages. You can add a web UI later that calls the same tools, which keeps one code path for people and agents.
Should the MCP endpoint live on its own subdomain?
One origin is simpler. Serving /, /app and /mcp from the same host keeps the cookie, the OAuth issuer and the MCP resource on one domain, and gives users one URL to remember.
How many products can one VPS host?
That depends on load, but small products with modest traffic share a server well. Put each product in its own containers with its own database, give each its own domain, and let a deployment tool such as Coolify handle builds and restarts.
Is Better Auth required for MCP OAuth?
No. You can write the OAuth endpoints yourself, as I did in an earlier guide. Better Auth's provider plugin saves you the authorization server code when you already use it for sign-in.
Conclusion
Launching four MCP-first products in one week sorted the work into two groups. The product decisions are the tool contract, safe repeated writes, OAuth for the connector and a single origin for the landing page, app and MCP endpoint. The kit is self-hosting on Coolify, Cloudflare at the edge, Better Auth, Brevo templates, standard auth pages and Search Console on launch day. Write the tool contract before the code, plan for retries from the first write tool, delete the static token once the connector works, and turn whatever you repeat into a template before the next launch.
Let me know in the comments if you have questions, and subscribe for more practical development guides.
Stakeholders answer discovery questions by text or voice, at their own pace, and a facilitator builds a shared project summary
getasync.eu, 23 Oct
MCP tools live 21 Oct, round lifecycle tools 22 Oct, landing page and sign-up 23 Oct
Attest
Translators open a real page of a website and translate each string where it appears, with a record of who approved it
getattest.eu, 23 Oct
Capture and translation UI first, exports as JSON for agents and Markdown for people
Sedule
Multi-tenant appointment scheduling
Coolify, 23 to 24 Oct
MCP only for v1, then a small /app UI that calls the same tools
Docket
Tasks, findings, decisions and handoffs that a coding agent can pick up without the previous chat
getdocket.eu, 25 Oct
MCP first, OAuth 2.1 for the claude.ai connector verified on launch day
ingest_transcript
correct_event
What scope every call carries. Sedule sends the team from the URL with every team tool call made from /app, so a tool never guesses which tenant it is working in.
What the agent should learn from a result besides the data. Docket attaches warnings such as REVIEW_PENDING and STALE_FINDING to the mutations that cause them, and the meeting knowledge base attaches a rerun_notice to event results. The agent finds out about state it did not ask for, at the moment it matters.
Piece
What I used
Evidence in the repos
Hosting
Coolify on one self-hosted VPS, push-to-deploy webhooks, one Docker image for the API and its background worker
Attest and Async deploy notes, meeting knowledge base MKB-77, Docket ADR 0020
Edge
Cloudflare proxy in front of the host's own reverse proxy, real-IP include
Docket and Attest deploy notes
Auth
Better Auth with email verification required for open sign-up, OAuth 2.1 provider for MCP
Async AD-47, Docket ADR 0022
Email
Brevo transactional templates for verification, password reset and invitations
Async AD-43 and AD-44, Attest invitations
Auth pages
shadcn login-02 and signup-02 two-column layouts
Attest first, then Async AD-50
Brand basics
Favicon set generated with sharp, logo in the app and emails, Open Graph tags
Async AD-45, Attest
Search
Domain property verified in Search Console on launch day, SEO research written into the repo
Search Console emails 23 Oct, Async and Attest SEO docs 24 Oct
Browser tests were switched off on purpose. Attest's agent instructions say "no browser tests during rapid prototyping", and one task notes that typecheck and lint passed but the form was not exercised in a browser. That was a deliberate trade for speed. The two bugs above are what it cost.