THE DOC
How it works, documented.
Everything that builds, hosts, and operates your site — written down in one place. What runs, what you get, what we promise, what we don't, and what happens to every account. If it isn't on this page, ask, and it goes on this page.
THE FULL SYSTEM PAGEThe system.
Most studios sell hours and manage them with meetings. We run the same five stations every time — the brief, the scout, the design, the build, the audit — with a human who reads every page before anything ships. One evening of answers from you; those stations turn them into the build.
The brief
You fill a short form in the evening: what you sell, who buys it, what the site must do. Twelve plain questions, and no upload.
YOU SEE — A form, not a discovery process. No 40-page workbook, no alignment call.
IT PRODUCES — A written brief. Within one business day: scope and price in writing — what gets built, what it costs, when it's live.
The scout
Research agents map your market: what competing sites do well and badly, what your customers search for, the exact words they use.
YOU SEE — Nothing yet — unless something in your brief doesn't add up, in which case you get a question, not a guess.
IT PRODUCES — A content plan: what every page must say to be found and to convince a visitor to contact you instead of the next listing.
The design
A design system is picked and tuned for your category: type scale, spacing, colour, AAA contrast, phone-first layouts.
YOU SEE — Nothing yet — or the whole site, if you're up late.
IT PRODUCES — A design system, not a one-off page. Every page you add later inherits it, so the site still looks right in three years.
The build
Real code: Next.js on your GitHub repo, deployed to Vercel, data on Neon Postgres, transactional email through Resend, Stripe or Shopify when you sell.
YOU SEE — A review link, fast — and a client dashboard that updates as the build moves.
IT PRODUCES — A production site on standard infrastructure. No page builder, no platform subscription, nothing proprietary to escape later.
The audit
A human reads every page. Every link checked, every form tested end to end, every claim verified against your brief.
YOU SEE — The audit result on your dashboard before launch.
IT PRODUCES — The green light. The site goes live on your domain, in your accounts.
The lifecycle.
One pass, plainly. You brief, or you buy a plan, and the scope and price are written down — immediately on the plan page, within one business day from a brief. From there we give you a date range and name what we need from you and by when. We do not publish a launch date before we have written one — a date without a written scope behind it is the one promise we would break. When it goes live, you choose whether we keep running it or you take it; either way the work is yours.
- BRIEF FILED
- You answer the brief in the evening, or pick from twelve priced lines. Nothing is built and nothing is charged until you approve the scope.
- WITHIN ONE BUSINESS DAY
- A written scope and price. Immediate on the plan page; within one business day from a brief. You read it, sign it, and the deposit starts the design.
- AFTER YOU APPROVE
- The four build stages run — provision, build, audit, ship — and your portal shows what has actually happened, including the steps that are still open.
- REVIEW LINK
- A link to click through the way a customer would. Mark anything up from your phone, async.
- THE DATE WE GIVE YOU
- A range, with the dependencies written under it — what we need from you, and by when. Not a single date we have not hit yet.
- AFTER LAUNCH
- You choose how it runs: Care — hosting, certificates, backups and small changes, monthly and cancellable — a management retainer, or taking the repository, deployment project, domain and database into your own accounts. A bought build has no countdown; a trial build is told its window in writing, in the terms you sign.
The surfaces.
Three ways into the same system — for you, for us, and for the agents that run it.
Your portal
Sign in →One login: the brief, the build progress, the changes, the billing — updated by real events, not promises. The same resolution every time: what you'd ask in a call, answered on the page.
The cockpit
See system status →Our side of the wall: briefs in, scope accepted, deposits, provisioning, deploys, audits. It is how one studio runs several builds at once without losing track of any of them — and it is one person, not a team you are imagining.
The four build stages
How it runs →The build itself is agent-operable: provisioning, deploys, audits and change requests run through typed tools any agent can call — the platform stops being a page we click.
What you get.
The full written lists are on the What you get page. Scope and price land in writing within one business day of your brief; the number you agree to is the number you pay.
BUILDS — ONE TIME
The Page
ONE-TIME BUILDThe Site
ONE-TIME BUILDThe System
ONE-TIME BUILDThe Operation
CUSTOM, QUOTED IN WRITING
AFTER LAUNCH — PICK HOW IT RUNS
Care
THE DEFAULT AFTER LAUNCHGrowth
OPTIONAL MONTHLY MANAGEMENT RETAINEROperator
OPTIONAL MONTHLY MANAGEMENT RETAINER
The list for each is on /build. Overflow at any tier is quoted per request before it's built — never silent scope creep, never unpaid heroics.
Changes.
A change isn't an email into a void. You ask from your portal; it becomes a tracked job with a visible state — received, in the works, shipped — the same way your build progress is real. When it ships, you see it on your live site, and the trail stays.
- 1 —You write what should change, from your portal, any time.
- 2 —It becomes a tracked job in your dashboard — with your plan's window on it.
- 3 —The change is built in the site's repository, on its own branch.
- 4 —It ships through a pull request, an audit, and a deploy — never a live-site gamble.
- 5 —Your dashboard says shipped. It's live. The history stays readable.
Windows are set for each option and agreed in writing before they are relied on. Care changes are queued and done when we are in there. A management retainer carries a stated response window — when we acknowledge, not when a fix lands. Bigger work gets scoped first. Bigger additions get scoped and quoted first — you approve the number.
The work.
Three real builds — not demos. They run on the same doctrine this page documents.

David Andrew Furniture
A real furniture procurement business, online at last. Education-first: dealer markups, landed cost, real project numbers in plain English — with a costed plan preview before anyone commits.

Motion Menu
597 numbered, working motion patterns — a design library real enough that other developers build with it. The site funds the product; the product is the proof.
Nimos OS
The business cockpit that runs Nimos itself: agents on a fixed schedule, honest queues, receipts for everything. The same doctrine that runs this platform.
After launch.
The site runs on our stack by default — that is how a build ships and keeps working. Accounts are opened in the business's name, and the logins and the record of what was opened are handed over.
Once an invoice is paid, the code, the design, the content and the database are delivered, and they belong to you. Running it is a separate choice: keep it on our stack for a monthly hosting rate, or take the repository, the deployment project, the domain and the database into your own accounts. The second one is started the day the final invoice clears and walked with you on a call — two of the steps need you to accept an invitation in your own account, because nobody can push ownership into an account that has not authorised it. Nothing is withheld to keep you.
AFTER LAUNCH —After launch there are two things to choose: how much of the running we do, and when you want a review. The first is one line in the portal, and it can change. A build bought from the plan page has no trial clock — the deposit is what starts it. A brief can be built as a trial first: a private link, nothing payable, and the terms you sign say how long it stays up.
YOUR MONEY —Payments run through Stripe or Shopify under the business's account. Card numbers never touch us, and we never hold your money.
The honest parts.
Service windows, not heroics.
Changes run on business-day windows by arrangement. We do not promise 24/7 monitoring or instant response — anyone who promises that is selling you a story.
No guaranteed business results.
We build fast, accessible, well-structured sites and stand behind the work. We don't guarantee revenue, traffic, or rankings — nobody honestly can.
A human reads everything.
Fast on assembly; a person signs off every page before launch and every claim before it ships.
Your data stays yours.
Ask us to delete an enquiry and we will do it and confirm it in writing. Analytics stay aggregate. We don't sell personal information, ever.
Legal.
The short version, numbered the way contracts read. The full documents govern:
- Scope first. Every project starts with a written scope — what we build, what it costs, when it's live. Work begins when you approve and sign that scope and the deposit is paid. Anything outside the scope is quoted before it's built.
- Delivered in full. Once an invoice is paid: code, design, content and database. Hosting is a separate monthly choice; the repository, deployment project, domain and database can be taken into your own accounts at any time. We keep our internal tools; third-party components keep their licences.
- You vouch for your content. You confirm the information you give us is accurate and you have the right to use it. Claims about your business are yours to verify.
- Third parties run their own terms. Sites run on services like Vercel, Neon, Shopify, Stripe and Google. We configure them; we don't control their outages or policy changes.
- Ending it is clean, and taking it is clean. Either side ends ongoing services with written notice. The work belongs to you; ending a hosting subscription moves the site rather than removing it, and the handover checklist is walked with you.
- BC law governs. These terms are governed by the laws of British Columbia, Canada. Our privacy practices are written to meet PIPEDA.
Made with.
Thirty-one tools carry the platform. Official marks, real roles — each one earns its place, none are decoration.
Next.js
THE FOUNDATION
Vercel
THE HOST
Neon Postgres
YOUR RECORDS
GitHub
NEVER LOSE IT
Resend
ARRIVES, READ
Stripe
GET PAID
Shopify
SELL ANYWHERE
Google Analytics 4
KNOW WHO'S COMING
Google Search Console
GET FOUND
Playwright
THE QA RIG
The four stages
FOUR STAGES
Motion Menu
MOVES RIGHT
Cloudflare DNS
STAYS REACHABLE
GitHub Actions
CHECKS ITSELF
The audit stage
FINDS IT BEFORE LAUNCH
Lenis
FEELS EXPENSIVE
GSAP + ScrollTrigger
THE MOTION
Tailwind CSS
ONE SYSTEM
TypeScript
CHECKED CODE
Gantry
THE BUILD ORCHESTRATOR
CUIFMARE
THE UI ENGINE
MPKL
THE MOTION ENGINE
3DSPTL
THE 3D ENGINE
EDGESTACK
THE EDGE LAYER
ASTE
THE SAFETY NET
DILAISDK
THE DESIGN BRAIN
MCPAC
THE CONNECTORS
AgentAPILayer
THE OVERNIGHT SHIFT
Documentation
THE MEMORY
LSPIntelligence
THE CODE READER
LocalDev
THE WORKSHOP
Every tool has a deep dive — what it is, what it does for your business, and its honest proof. Live status, checked in real time: /status.
How this page was made.
The document is itself the smallest proof of the system. Same rails, same gates, same trail — no special case.
Designed against a spec
The composition came from the design-intelligence layer against written constraints — docs reading rules, house type, measured density. Not taste, a spec.
Written in the product's repo
One Next.js codebase: this page is a route in the same app that runs the portal, the cockpit and the four build stages.
Checked by the gates
Typecheck, production build, the design-system gate, a scripted stress test against the live site, and every screenshot read by a person before we said it was done. Checks we run, before we tell you — not a hook that fires on its own.
Shipped and checked
Committed to GitHub, deployed to Vercel, then read back on the production URL before anyone was told. This site itself is deployed by a command we run ourselves — client sites go through the ship stage, which is a different path.
That's the whole thing.
One evening of answers starts it. Scope in writing within one business day. A date you can plan around. It runs when we ship, and the accounts can move whenever you want them moved.
File the brief